@librechat/agents 3.0.81 → 3.0.772

package/src/llm/bedrock/index.ts

@@ -1,9 +1,5 @@
 /**
  * Optimized ChatBedrockConverse wrapper that fixes contentBlockIndex conflicts
- * and adds support for latest @langchain/aws features:
- *
- * - Application Inference Profiles (PR #9129)
- * - Service Tiers (Priority/Standard/Flex) (PR #9785) - requires AWS SDK 3.966.0+
  *
  * Bedrock sends the same contentBlockIndex for both text and tool_use content blocks,
  * causing LangChain's merge logic to fail with "field[contentBlockIndex] already exists"
@@ -16,74 +12,15 @@
  */
 
 import { ChatBedrockConverse } from '@langchain/aws';
-import { AIMessageChunk } from '@langchain/core/messages';
-import { ChatGenerationChunk, ChatResult } from '@langchain/core/outputs';
-import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
+import { AIMessageChunk } from '@langchain/core/messages';
 import type { BaseMessage } from '@langchain/core/messages';
-
-/**
- * Service tier type for Bedrock invocations.
- * Requires AWS SDK >= 3.966.0 to actually work.
- * @see https://docs.aws.amazon.com/bedrock/latest/userguide/service-tiers-inference.html
- */
-export type ServiceTierType = 'priority' | 'default' | 'flex' | 'reserved';
-
-/**
- * Extended input interface with additional features:
- * - applicationInferenceProfile: Use an inference profile ARN instead of model ID
- * - serviceTier: Specify service tier (Priority, Standard, Flex, Reserved)
- */
-export interface CustomChatBedrockConverseInput
-  extends ChatBedrockConverseInput {
-  /**
-   * Application Inference Profile ARN to use for the model.
-   * For example, "arn:aws:bedrock:eu-west-1:123456789102:application-inference-profile/fm16bt65tzgx"
-   * When provided, this ARN will be used for the actual inference calls instead of the model ID.
-   * Must still provide `model` as normal modelId to benefit from all the metadata.
-   * @see https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-create.html
-   */
-  applicationInferenceProfile?: string;
-
-  /**
-   * Service tier for model invocation.
-   * Specifies the processing tier type used for serving the request.
-   * Supported values are 'priority', 'default', 'flex', and 'reserved'.
-   *
-   * - 'priority': Prioritized processing for lower latency
-   * - 'default': Standard processing tier
-   * - 'flex': Flexible processing tier with lower cost
-   * - 'reserved': Reserved capacity for consistent performance
-   *
-   * If not provided, AWS uses the default tier.
-   * Note: Requires AWS SDK >= 3.966.0 to work.
-   * @see https://docs.aws.amazon.com/bedrock/latest/userguide/service-tiers-inference.html
-   */
-  serviceTier?: ServiceTierType;
-}
-
-/**
- * Extended call options with serviceTier override support.
- */
-export interface CustomChatBedrockConverseCallOptions {
-  serviceTier?: ServiceTierType;
-}
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 
 export class CustomChatBedrockConverse extends ChatBedrockConverse {
-  /**
-   * Application Inference Profile ARN to use instead of model ID.
-   */
-  applicationInferenceProfile?: string;
-
-  /**
-   * Service tier for model invocation.
-   */
-  serviceTier?: ServiceTierType;
-
-  constructor(fields?: CustomChatBedrockConverseInput) {
+  constructor(fields?: ChatBedrockConverseInput) {
     super(fields);
-    this.applicationInferenceProfile = fields?.applicationInferenceProfile;
-    this.serviceTier = fields?.serviceTier;
   }
 
   static lc_name(): string {
@@ -91,126 +28,52 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
   }
 
   /**
-   * Get the model ID to use for API calls.
-   * Returns applicationInferenceProfile if set, otherwise returns this.model.
-   */
-  protected getModelId(): string {
-    return this.applicationInferenceProfile ?? this.model;
-  }
-
-  /**
-   * Override invocationParams to add serviceTier support.
-   */
-  override invocationParams(
-    options?: this['ParsedCallOptions'] & CustomChatBedrockConverseCallOptions
-  ): ReturnType<ChatBedrockConverse['invocationParams']> & {
-    serviceTier?: { type: ServiceTierType };
-  } {
-    const baseParams = super.invocationParams(options);
-
-    /** Service tier from options or fall back to class-level setting */
-    const serviceTierType = options?.serviceTier ?? this.serviceTier;
-
-    return {
-      ...baseParams,
-      serviceTier: serviceTierType ? { type: serviceTierType } : undefined,
-    };
-  }
-
-  /**
-   * Override _generateNonStreaming to use applicationInferenceProfile as modelId.
-   * Uses the same model-swapping pattern as streaming for consistency.
+   * Override _streamResponseChunks to strip contentBlockIndex from response_metadata
+   * This prevents LangChain's merge conflicts when the same index is used for
+   * different content types (text vs tool calls)
    */
-  override async _generateNonStreaming(
+  async *_streamResponseChunks(
     messages: BaseMessage[],
-    options: this['ParsedCallOptions'] & CustomChatBedrockConverseCallOptions,
-    runManager?: CallbackManagerForLLMRun
-  ): Promise<ChatResult> {
-    // Temporarily swap model for applicationInferenceProfile support
-    const originalModel = this.model;
-    if (
-      this.applicationInferenceProfile != null &&
-      this.applicationInferenceProfile !== ''
-    ) {
-      this.model = this.applicationInferenceProfile;
-    }
-
-    try {
-      return await super._generateNonStreaming(messages, options, runManager);
-    } finally {
-      // Restore original model
-      this.model = originalModel;
-    }
-  }
-
-  /**
-   * Override _streamResponseChunks to:
-   * 1. Use applicationInferenceProfile as modelId (by temporarily swapping this.model)
-   * 2. Strip contentBlockIndex from response_metadata to prevent merge conflicts
-   *
-   * Note: We delegate to super._streamResponseChunks() to preserve @langchain/aws's
-   * internal chunk handling which correctly preserves array content for reasoning blocks.
-   */
-  override async *_streamResponseChunks(
-    messages: BaseMessage[],
-    options: this['ParsedCallOptions'] & CustomChatBedrockConverseCallOptions,
+    options: this['ParsedCallOptions'],
     runManager?: CallbackManagerForLLMRun
   ): AsyncGenerator<ChatGenerationChunk> {
-    // Temporarily swap model for applicationInferenceProfile support
-    const originalModel = this.model;
-    if (
-      this.applicationInferenceProfile != null &&
-      this.applicationInferenceProfile !== ''
-    ) {
-      this.model = this.applicationInferenceProfile;
-    }
-
-    try {
-      // Use parent's streaming logic which correctly handles reasoning content
-      const baseStream = super._streamResponseChunks(
-        messages,
-        options,
-        runManager
-      );
-
-      for await (const chunk of baseStream) {
-        // Clean contentBlockIndex from response_metadata to prevent merge conflicts
-        yield this.cleanChunk(chunk);
+    const baseStream = super._streamResponseChunks(
+      messages,
+      options,
+      runManager
+    );
+
+    for await (const chunk of baseStream) {
+      // Only process if we have response_metadata
+      if (
+        chunk.message instanceof AIMessageChunk &&
+        (chunk.message as Partial<AIMessageChunk>).response_metadata &&
+        typeof chunk.message.response_metadata === 'object'
+      ) {
+        // Check if contentBlockIndex exists anywhere in response_metadata (top level or nested)
+        const hasContentBlockIndex = this.hasContentBlockIndex(
+          chunk.message.response_metadata
+        );
+
+        if (hasContentBlockIndex) {
+          const cleanedMetadata = this.removeContentBlockIndex(
+            chunk.message.response_metadata
+          ) as Record<string, unknown>;
+
+          yield new ChatGenerationChunk({
+            text: chunk.text,
+            message: new AIMessageChunk({
+              ...chunk.message,
+              response_metadata: cleanedMetadata,
+            }),
+            generationInfo: chunk.generationInfo,
+          });
+          continue;
+        }
       }
-    } finally {
-      // Restore original model
-      this.model = originalModel;
-    }
-  }
 
-  /**
-   * Clean a chunk by removing contentBlockIndex from response_metadata.
-   */
-  private cleanChunk(chunk: ChatGenerationChunk): ChatGenerationChunk {
-    const message = chunk.message;
-    if (!(message instanceof AIMessageChunk)) {
-      return chunk;
+      yield chunk;
     }
-
-    const metadata = message.response_metadata as Record<string, unknown>;
-    const hasContentBlockIndex = this.hasContentBlockIndex(metadata);
-    if (!hasContentBlockIndex) {
-      return chunk;
-    }
-
-    const cleanedMetadata = this.removeContentBlockIndex(metadata) as Record<
-      string,
-      unknown
-    >;
-
-    return new ChatGenerationChunk({
-      text: chunk.text,
-      message: new AIMessageChunk({
-        ...message,
-        response_metadata: cleanedMetadata,
-      }),
-      generationInfo: chunk.generationInfo,
-    });
   }
 
   /**

package/src/messages/cache.test.ts

@@ -1048,6 +1048,50 @@ describe('Immutability - addBedrockCacheControl does not mutate original message
     expect(anthropicFirstContent.some((b) => 'cachePoint' in b)).toBe(false);
     expect('cache_control' in anthropicFirstContent[0]).toBe(true);
   });
+
+  it('should keep lc_kwargs.content in sync with content for LangChain messages', () => {
+    type LangChainLikeMsg = TestMsg & {
+      lc_kwargs?: { content?: MessageContentComplex[] };
+    };
+
+    const messagesWithLcKwargs: LangChainLikeMsg[] = [
+      {
+        role: 'user',
+        content: [{ type: ContentTypes.TEXT, text: 'User message' }],
+        lc_kwargs: {
+          content: [{ type: ContentTypes.TEXT, text: 'User message' }],
+        },
+      },
+      {
+        role: 'assistant',
+        content: [{ type: ContentTypes.TEXT, text: 'Assistant response' }],
+        lc_kwargs: {
+          content: [{ type: ContentTypes.TEXT, text: 'Assistant response' }],
+        },
+      },
+    ];
+
+    const bedrockResult = addBedrockCacheControl(messagesWithLcKwargs);
+
+    const resultFirst = bedrockResult[0] as LangChainLikeMsg;
+    const resultSecond = bedrockResult[1] as LangChainLikeMsg;
+
+    expect(resultFirst.content).toEqual(resultFirst.lc_kwargs?.content);
+    expect(resultSecond.content).toEqual(resultSecond.lc_kwargs?.content);
+
+    const firstContent = resultFirst.content as MessageContentComplex[];
+    const firstLcContent = resultFirst.lc_kwargs
+      ?.content as MessageContentComplex[];
+    expect(firstContent.some((b) => 'cachePoint' in b)).toBe(true);
+    expect(firstLcContent.some((b) => 'cachePoint' in b)).toBe(true);
+
+    const originalFirst = messagesWithLcKwargs[0];
+    const originalContent = originalFirst.content as MessageContentComplex[];
+    const originalLcContent = originalFirst.lc_kwargs
+      ?.content as MessageContentComplex[];
+    expect(originalContent.some((b) => 'cachePoint' in b)).toBe(false);
+    expect(originalLcContent.some((b) => 'cachePoint' in b)).toBe(false);
+  });
 });
 
 describe('Multi-turn cache cleanup', () => {

package/src/messages/cache.ts

@@ -31,10 +31,34 @@ function cloneMessageWithContent<T extends MessageWithContent>(message: T): T {
   if (message.content === undefined) {
     return { ...message };
   }
-  return {
+
+  const clonedContent = deepCloneContent(message.content);
+  const cloned = {
     ...message,
-    content: deepCloneContent(message.content),
+    content: clonedContent,
   };
+
+  /**
+   * LangChain messages store internal state in lc_kwargs.
+   * Clone it but don't sync content yet - that happens after all modifications.
+   */
+  const lcKwargs = (message as Record<string, unknown>).lc_kwargs;
+  if (lcKwargs != null && typeof lcKwargs === 'object') {
+    (cloned as Record<string, unknown>).lc_kwargs = { ...lcKwargs };
+  }
+
+  return cloned;
+}
+
+/**
+ * Syncs lc_kwargs.content with the message's content property.
+ * Call this after all modifications to ensure LangChain serialization works correctly.
+ */
+function syncLcKwargsContent<T extends MessageWithContent>(message: T): void {
+  const lcKwargs = (message as Record<string, unknown>).lc_kwargs;
+  if (lcKwargs != null && typeof lcKwargs === 'object') {
+    (lcKwargs as Record<string, unknown>).content = message.content;
+  }
 }
 
 /**
@@ -114,6 +138,7 @@ export function addCacheControl<T extends AnthropicMessage | BaseMessage>(
     }
 
     if (userMessagesModified >= 2 || !isUserMessage) {
+      syncLcKwargsContent(message);
       continue;
     }
 
@@ -138,6 +163,8 @@ export function addCacheControl<T extends AnthropicMessage | BaseMessage>(
         }
       }
     }
+
+    syncLcKwargsContent(message);
   }
 
   return updatedMessages;
@@ -314,6 +341,7 @@ export function addBedrockCacheControl<
     }
 
     if (messagesModified >= 2 || isToolMessage || isEmptyString) {
+      syncLcKwargsContent(message);
       continue;
     }
 
@@ -323,6 +351,7 @@ export function addBedrockCacheControl<
         { cachePoint: { type: 'default' } },
       ] as MessageContentComplex[];
       messagesModified++;
+      syncLcKwargsContent(message);
       continue;
     }
 
@@ -338,6 +367,7 @@ export function addBedrockCacheControl<
       }
 
       if (!hasCacheableContent) {
+        syncLcKwargsContent(message);
         continue;
       }
 
@@ -364,6 +394,8 @@ export function addBedrockCacheControl<
       }
       messagesModified++;
     }
+
+    syncLcKwargsContent(message);
   }
 
   return updatedMessages;

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