@librechat/agents 3.0.80 → 3.0.771

package/src/messages/cache.ts

@@ -7,13 +7,57 @@ type MessageWithContent = {
   content?: string | MessageContentComplex[];
 };
 
+/**
+ * Deep clones a message's content to prevent mutation of the original.
+ * Handles both string and array content types.
+ */
+function deepCloneContent<T extends string | MessageContentComplex[]>(
+  content: T
+): T {
+  if (typeof content === 'string') {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.map((block) => ({ ...block })) as T;
+  }
+  return content;
+}
+
+/**
+ * Creates a shallow clone of a message with deep-cloned content.
+ * This ensures modifications to content don't affect the original message.
+ */
+function cloneMessageWithContent<T extends MessageWithContent>(message: T): T {
+  if (message.content === undefined) {
+    return { ...message };
+  }
+  return {
+    ...message,
+    content: deepCloneContent(message.content),
+  };
+}
+
+/**
+ * Checks if a message's content needs cache control stripping.
+ * Returns true if content has cachePoint blocks or cache_control fields.
+ */
+function needsCacheStripping(content: MessageContentComplex[]): boolean {
+  for (let i = 0; i < content.length; i++) {
+    const block = content[i];
+    if (isCachePoint(block)) return true;
+    if ('cache_control' in block) return true;
+  }
+  return false;
+}
+
 /**
  * Anthropic API: Adds cache control to the appropriate user messages in the payload.
  * Strips ALL existing cache control (both Anthropic and Bedrock formats) from all messages,
  * then adds fresh cache control to the last 2 user messages in a single backward pass.
  * This ensures we don't accumulate stale cache points across multiple turns.
+ * Returns a new array - only clones messages that require modification.
  * @param messages - The array of message objects.
- * @returns - The updated array of message objects with cache control added.
+ * @returns - A new array of message objects with cache control added.
  */
 export function addCacheControl<T extends AnthropicMessage | BaseMessage>(
   messages: T[]
@@ -22,22 +66,47 @@ export function addCacheControl<T extends AnthropicMessage | BaseMessage>(
     return messages;
   }
 
-  const updatedMessages = [...messages];
+  const updatedMessages: T[] = [...messages];
   let userMessagesModified = 0;
 
   for (let i = updatedMessages.length - 1; i >= 0; i--) {
-    const message = updatedMessages[i];
+    const originalMessage = updatedMessages[i];
     const isUserMessage =
-      ('getType' in message && message.getType() === 'human') ||
-      ('role' in message && message.role === 'user');
+      ('getType' in originalMessage && originalMessage.getType() === 'human') ||
+      ('role' in originalMessage && originalMessage.role === 'user');
+
+    const hasArrayContent = Array.isArray(originalMessage.content);
+    const needsStripping =
+      hasArrayContent &&
+      needsCacheStripping(originalMessage.content as MessageContentComplex[]);
+    const needsCacheAdd =
+      userMessagesModified < 2 &&
+      isUserMessage &&
+      (typeof originalMessage.content === 'string' || hasArrayContent);
+
+    if (!needsStripping && !needsCacheAdd) {
+      continue;
+    }
 
-    if (Array.isArray(message.content)) {
-      message.content = message.content.filter(
+    const message = cloneMessageWithContent(
+      originalMessage as MessageWithContent
+    ) as T;
+    updatedMessages[i] = message;
+
+    if (hasArrayContent) {
+      message.content = (message.content as MessageContentComplex[]).filter(
         (block) => !isCachePoint(block as MessageContentComplex)
       ) as typeof message.content;
 
-      for (let j = 0; j < message.content.length; j++) {
-        const block = message.content[j] as Record<string, unknown>;
+      for (
+        let j = 0;
+        j < (message.content as MessageContentComplex[]).length;
+        j++
+      ) {
+        const block = (message.content as MessageContentComplex[])[j] as Record<
+          string,
+          unknown
+        >;
         if ('cache_control' in block) {
           delete block.cache_control;
         }
@@ -81,9 +150,20 @@ function isCachePoint(block: MessageContentComplex): boolean {
   return 'cachePoint' in block && !('type' in block);
 }
 
+/**
+ * Checks if a message's content has Anthropic cache_control fields.
+ */
+function hasAnthropicCacheControl(content: MessageContentComplex[]): boolean {
+  for (let i = 0; i < content.length; i++) {
+    if ('cache_control' in content[i]) return true;
+  }
+  return false;
+}
+
 /**
  * Removes all Anthropic cache_control fields from messages
  * Used when switching from Anthropic to Bedrock provider
+ * Returns a new array - only clones messages that require modification.
  */
 export function stripAnthropicCacheControl<T extends MessageWithContent>(
   messages: T[]
@@ -92,18 +172,30 @@ export function stripAnthropicCacheControl<T extends MessageWithContent>(
     return messages;
   }
 
-  const updatedMessages = [...messages];
+  const updatedMessages: T[] = [...messages];
 
   for (let i = 0; i < updatedMessages.length; i++) {
-    const message = updatedMessages[i];
-    const content = message.content;
+    const originalMessage = updatedMessages[i];
+    const content = originalMessage.content;
 
-    if (Array.isArray(content)) {
-      for (let j = 0; j < content.length; j++) {
-        const block = content[j] as Record<string, unknown>;
-        if ('cache_control' in block) {
-          delete block.cache_control;
-        }
+    if (!Array.isArray(content) || !hasAnthropicCacheControl(content)) {
+      continue;
+    }
+
+    const message = cloneMessageWithContent(originalMessage);
+    updatedMessages[i] = message;
+
+    for (
+      let j = 0;
+      j < (message.content as MessageContentComplex[]).length;
+      j++
+    ) {
+      const block = (message.content as MessageContentComplex[])[j] as Record<
+        string,
+        unknown
+      >;
+      if ('cache_control' in block) {
+        delete block.cache_control;
       }
     }
   }
@@ -111,9 +203,20 @@ export function stripAnthropicCacheControl<T extends MessageWithContent>(
   return updatedMessages;
 }
 
+/**
+ * Checks if a message's content has Bedrock cachePoint blocks.
+ */
+function hasBedrockCachePoint(content: MessageContentComplex[]): boolean {
+  for (let i = 0; i < content.length; i++) {
+    if (isCachePoint(content[i])) return true;
+  }
+  return false;
+}
+
 /**
  * Removes all Bedrock cachePoint blocks from messages
  * Used when switching from Bedrock to Anthropic provider
+ * Returns a new array - only clones messages that require modification.
  */
 export function stripBedrockCacheControl<T extends MessageWithContent>(
   messages: T[]
@@ -122,17 +225,22 @@ export function stripBedrockCacheControl<T extends MessageWithContent>(
     return messages;
   }
 
-  const updatedMessages = [...messages];
+  const updatedMessages: T[] = [...messages];
 
   for (let i = 0; i < updatedMessages.length; i++) {
-    const message = updatedMessages[i];
-    const content = message.content;
+    const originalMessage = updatedMessages[i];
+    const content = originalMessage.content;
 
-    if (Array.isArray(content)) {
-      message.content = content.filter(
-        (block) => !isCachePoint(block as MessageContentComplex)
-      ) as typeof content;
+    if (!Array.isArray(content) || !hasBedrockCachePoint(content)) {
+      continue;
     }
+
+    const message = cloneMessageWithContent(originalMessage);
+    updatedMessages[i] = message;
+
+    message.content = (message.content as MessageContentComplex[]).filter(
+      (block) => !isCachePoint(block as MessageContentComplex)
+    ) as typeof content;
   }
 
   return updatedMessages;
@@ -145,8 +253,9 @@ export function stripBedrockCacheControl<T extends MessageWithContent>(
  * Strips ALL existing cache control (both Bedrock and Anthropic formats) from all messages,
  * then adds fresh cache points to the last 2 messages in a single backward pass.
  * This ensures we don't accumulate stale cache points across multiple turns.
+ * Returns a new array - only clones messages that require modification.
  * @param messages - The array of message objects.
- * @returns - The updated array of message objects with cache points added.
+ * @returns - A new array of message objects with cache points added.
  */
 export function addBedrockCacheControl<
   T extends Partial<BaseMessage> & MessageWithContent,
@@ -155,42 +264,62 @@ export function addBedrockCacheControl<
     return messages;
   }
 
-  const updatedMessages: T[] = messages.slice();
+  const updatedMessages: T[] = [...messages];
   let messagesModified = 0;
 
   for (let i = updatedMessages.length - 1; i >= 0; i--) {
-    const message = updatedMessages[i];
+    const originalMessage = updatedMessages[i];
     const isToolMessage =
-      'getType' in message &&
-      typeof message.getType === 'function' &&
-      message.getType() === 'tool';
+      'getType' in originalMessage &&
+      typeof originalMessage.getType === 'function' &&
+      originalMessage.getType() === 'tool';
+
+    const content = originalMessage.content;
+    const hasArrayContent = Array.isArray(content);
+    const needsStripping =
+      hasArrayContent &&
+      needsCacheStripping(content as MessageContentComplex[]);
+    const isEmptyString = typeof content === 'string' && content === '';
+    const needsCacheAdd =
+      messagesModified < 2 &&
+      !isToolMessage &&
+      !isEmptyString &&
+      (typeof content === 'string' || hasArrayContent);
+
+    if (!needsStripping && !needsCacheAdd) {
+      continue;
+    }
 
-    const content = message.content;
+    const message = cloneMessageWithContent(originalMessage);
+    updatedMessages[i] = message;
 
-    if (Array.isArray(content)) {
-      message.content = content.filter(
+    if (hasArrayContent) {
+      message.content = (message.content as MessageContentComplex[]).filter(
         (block) => !isCachePoint(block)
       ) as typeof content;
 
-      for (let j = 0; j < message.content.length; j++) {
-        const block = message.content[j] as Record<string, unknown>;
+      for (
+        let j = 0;
+        j < (message.content as MessageContentComplex[]).length;
+        j++
+      ) {
+        const block = (message.content as MessageContentComplex[])[j] as Record<
+          string,
+          unknown
+        >;
         if ('cache_control' in block) {
           delete block.cache_control;
         }
       }
     }
 
-    if (messagesModified >= 2 || isToolMessage) {
+    if (messagesModified >= 2 || isToolMessage || isEmptyString) {
       continue;
     }
 
-    if (typeof content === 'string' && content === '') {
-      continue;
-    }
-
-    if (typeof content === 'string') {
+    if (typeof message.content === 'string') {
       message.content = [
-        { type: ContentTypes.TEXT, text: content },
+        { type: ContentTypes.TEXT, text: message.content },
         { cachePoint: { type: 'default' } },
       ] as MessageContentComplex[];
       messagesModified++;

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', 'redacted_thinking'],
+  [Providers.ANTHROPIC]: [..._allowedTypes, 'thinking'],
   [Providers.BEDROCK]: [..._allowedTypes, 'reasoning_content'],
   [Providers.OPENAI]: _allowedTypes,
 };

package/src/scripts/thinking.ts

@@ -1,11 +1,7 @@
 // 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';
@@ -25,23 +21,17 @@ 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) => {
@@ -49,38 +39,29 @@ 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>({
@@ -112,7 +93,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();
 
@@ -120,32 +101,30 @@ 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) => {
@@ -168,4 +147,4 @@ testThinking().catch((err) => {
   console.log('Content parts:');
   console.dir(_contentParts, { depth: null });
   process.exit(1);
-});
+});

package/src/scripts/tools.ts

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

package/src/stream.ts

@@ -339,8 +339,7 @@ hasToolCallChunks: ${hasToolCallChunks}
         (c) =>
           (c.type?.startsWith(ContentTypes.THINKING) ?? false) ||
           (c.type?.startsWith(ContentTypes.REASONING) ?? false) ||
-          (c.type?.startsWith(ContentTypes.REASONING_CONTENT) ?? false) ||
-          c.type === 'redacted_thinking'
+          (c.type?.startsWith(ContentTypes.REASONING_CONTENT) ?? false)
       )
     ) {
       await graph.dispatchReasoningDelta(stepId, {
@@ -366,8 +365,7 @@ hasToolCallChunks: ${hasToolCallChunks}
       Array.isArray(chunk.content) &&
       (chunk.content[0]?.type === ContentTypes.THINKING ||
         chunk.content[0]?.type === ContentTypes.REASONING ||
-        chunk.content[0]?.type === ContentTypes.REASONING_CONTENT ||
-        chunk.content[0]?.type === 'redacted_thinking')
+        chunk.content[0]?.type === ContentTypes.REASONING_CONTENT)
     ) {
       reasoning_content = 'valid';
     } else if (

package/src/tools/ToolNode.ts

@@ -145,9 +145,9 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
 
       /**
        * Inject session context for code execution tools when available.
-       * Each file uses its own session_id (supporting multi-session file tracking).
        * Both session_id and _injected_files are injected directly to invokeParams
        * (not inside args) so they bypass Zod schema validation and reach config.toolCall.
+       * This avoids /files endpoint race conditions.
        */
       if (
         call.name === Constants.EXECUTE_CODE ||
@@ -156,18 +156,14 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         const codeSession = this.sessions?.get(Constants.EXECUTE_CODE) as
           | t.CodeSessionContext
           | undefined;
-        if (codeSession?.files != null && codeSession.files.length > 0) {
-          /**
-           * Convert tracked files to CodeEnvFile format for the API.
-           * Each file uses its own session_id (set when file was created).
-           * This supports files from multiple parallel/sequential executions.
-           */
+        if (codeSession?.session_id != null && codeSession.files.length > 0) {
+          /** Convert tracked files to CodeEnvFile format for the API */
           const fileRefs: t.CodeEnvFile[] = codeSession.files.map((file) => ({
-            session_id: file.session_id ?? codeSession.session_id,
+            session_id: codeSession.session_id,
             id: file.id,
             name: file.name,
           }));
-          /** Inject latest session_id and files - bypasses Zod, reaches config.toolCall */
+          /** Inject session_id and files directly - bypasses Zod, reaches config.toolCall */
           invokeParams = {
             ...invokeParams,
             session_id: codeSession.session_id,

package/src/types/tools.ts

@@ -74,8 +74,6 @@ export type FileRef = {
   id: string;
   name: string;
   path?: string;
-  /** Session ID this file belongs to (for multi-session file tracking) */
-  session_id?: string;
 };
 
 export type FileRefs = FileRef[];

package/dist/types/llm/bedrock/types.d.ts

@@ -1,27 +0,0 @@
-/**
- * Type definitions for Bedrock Converse utilities.
- */
-import type { Message as BedrockMessage, SystemContentBlock as BedrockSystemContentBlock, ContentBlock as BedrockContentBlock, ConverseResponse, ContentBlockDeltaEvent, ConverseStreamMetadataEvent, ContentBlockStartEvent, ReasoningContentBlock, ReasoningContentBlockDelta } from '@aws-sdk/client-bedrock-runtime';
-/**
- * Reasoning content block type for LangChain messages.
- */
-export interface MessageContentReasoningBlock {
-    type: 'reasoning_content';
-    reasoningText?: {
-        text?: string;
-        signature?: string;
-    };
-    redactedContent?: string;
-}
-export interface MessageContentReasoningBlockReasoningTextPartial {
-    type: 'reasoning_content';
-    reasoningText: {
-        text?: string;
-        signature?: string;
-    };
-}
-export interface MessageContentReasoningBlockRedacted {
-    type: 'reasoning_content';
-    redactedContent: string;
-}
-export type { BedrockMessage, BedrockSystemContentBlock, BedrockContentBlock, ConverseResponse, ContentBlockDeltaEvent, ConverseStreamMetadataEvent, ContentBlockStartEvent, ReasoningContentBlock, ReasoningContentBlockDelta, };

package/dist/types/llm/bedrock/utils/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * Bedrock Converse utility exports.
- */
-export { convertToConverseMessages, extractImageInfo, langchainReasoningBlockToBedrockReasoningBlock, concatenateLangchainReasoningBlocks, } from './message_inputs';
-export { convertConverseMessageToLangChainMessage, handleConverseStreamContentBlockStart, handleConverseStreamContentBlockDelta, handleConverseStreamMetadata, bedrockReasoningBlockToLangchainReasoningBlock, bedrockReasoningDeltaToLangchainPartialReasoningBlock, } from './message_outputs';

package/dist/types/llm/bedrock/utils/message_inputs.d.ts

@@ -1,31 +0,0 @@
-/**
- * Utility functions for converting LangChain messages to Bedrock Converse messages.
- * Ported from @langchain/aws common.js
- */
-import { type BaseMessage, MessageContentComplex } from '@langchain/core/messages';
-import type { BedrockMessage, BedrockSystemContentBlock, BedrockContentBlock, MessageContentReasoningBlock } from '../types';
-/**
- * Convert a LangChain reasoning block to a Bedrock reasoning block.
- */
-export declare function langchainReasoningBlockToBedrockReasoningBlock(content: MessageContentReasoningBlock): {
-    reasoningText?: {
-        text?: string;
-        signature?: string;
-    };
-    redactedContent?: Uint8Array;
-};
-/**
- * Concatenate consecutive reasoning blocks in content array.
- */
-export declare function concatenateLangchainReasoningBlocks(content: Array<MessageContentComplex | MessageContentReasoningBlock>): Array<MessageContentComplex | MessageContentReasoningBlock>;
-/**
- * Extract image info from a base64 string or URL.
- */
-export declare function extractImageInfo(base64: string): BedrockContentBlock;
-/**
- * Convert LangChain messages to Bedrock Converse messages.
- */
-export declare function convertToConverseMessages(messages: BaseMessage[]): {
-    converseMessages: BedrockMessage[];
-    converseSystem: BedrockSystemContentBlock[];
-};

package/dist/types/llm/bedrock/utils/message_outputs.d.ts

@@ -1,33 +0,0 @@
-/**
- * Utility functions for converting Bedrock Converse responses to LangChain messages.
- * Ported from @langchain/aws common.js
- */
-import { AIMessage } 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 declare function bedrockReasoningDeltaToLangchainPartialReasoningBlock(reasoningContent: ReasoningContentBlockDelta): MessageContentReasoningBlockReasoningTextPartial | MessageContentReasoningBlockRedacted;
-/**
- * Convert a Bedrock reasoning block to a LangChain reasoning block.
- */
-export declare function bedrockReasoningBlockToLangchainReasoningBlock(reasoningContent: ReasoningContentBlock): MessageContentReasoningBlock;
-/**
- * Convert a Bedrock Converse message to a LangChain message.
- */
-export declare function convertConverseMessageToLangChainMessage(message: BedrockMessage, responseMetadata: Omit<ConverseResponse, 'output'>): AIMessage;
-/**
- * Handle a content block delta event from Bedrock Converse stream.
- */
-export declare function handleConverseStreamContentBlockDelta(contentBlockDelta: ContentBlockDeltaEvent): ChatGenerationChunk;
-/**
- * Handle a content block start event from Bedrock Converse stream.
- */
-export declare function handleConverseStreamContentBlockStart(contentBlockStart: ContentBlockStartEvent): ChatGenerationChunk | null;
-/**
- * Handle a metadata event from Bedrock Converse stream.
- */
-export declare function handleConverseStreamMetadata(metadata: ConverseStreamMetadataEvent, extra: {
-    streamUsage: boolean;
-}): ChatGenerationChunk;