@librechat/agents 3.2.34 → 3.2.36

package/src/llm/anthropic/utils/message_inputs.ts

@@ -429,6 +429,14 @@ function _formatContent(message: BaseMessage) {
     'web_search_result',
   ];
   const textTypes = ['text', 'text_delta'];
+  /**
+   * Reasoning blocks emitted by other providers — Bedrock's `reasoning_content`,
+   * Google's `reasoning`, and LibreChat's `think`. Their signatures are
+   * provider-specific and cannot be validated by Anthropic, so on a
+   * cross-provider handoff (e.g. Bedrock → Anthropic) we drop them rather than
+   * forwarding an unusable block. The receiving model produces its own thinking.
+   */
+  const foreignReasoningTypes = ['reasoning_content', 'reasoning', 'think'];
   const { content } = message;
 
   if (typeof content === 'string') {
@@ -568,6 +576,15 @@ function _formatContent(message: BaseMessage) {
         };
       } else if (contentPart.type === 'thinking') {
         const thinkingPart = contentPart as AnthropicThinkingBlockParam;
+        // Google thinking-enabled output reuses `type: 'thinking'` but carries
+        // no Anthropic signature. Anthropic rejects an unsigned thinking block,
+        // so on an assistant turn treat it as foreign reasoning and drop it
+        // rather than forward an unusable block. Signed (Anthropic-native)
+        // thinking is forwarded as before.
+        const signature = (thinkingPart as { signature?: string }).signature;
+        if (isAIMessage(message) && (signature == null || signature === '')) {
+          return null;
+        }
         const block: AnthropicThinkingBlockParam = {
           type: 'thinking' as const, // Explicitly setting the type as "thinking"
           thinking: thinkingPart.thinking,
@@ -651,7 +668,9 @@ function _formatContent(message: BaseMessage) {
           (contentPartCopy.input === '' || contentPartCopy.input == null)
         ) {
           const matchingToolCall = isAIMessage(message)
-            ? message.tool_calls?.find((toolCall) => toolCall.id === contentPartCopy.id)
+            ? message.tool_calls?.find(
+              (toolCall) => toolCall.id === contentPartCopy.id
+            )
             : undefined;
           if (matchingToolCall) {
             contentPartCopy.input = matchingToolCall.args;
@@ -666,7 +685,10 @@ function _formatContent(message: BaseMessage) {
                   typeof p.input === 'string'
                 );
               })
-              .reduce((acc, part) => acc + (part as Record<string, unknown>).input, '');
+              .reduce(
+                (acc, part) => acc + (part as Record<string, unknown>).input,
+                ''
+              );
             if (merged !== '') {
               contentPartCopy.input = merged;
             }
@@ -720,6 +742,18 @@ function _formatContent(message: BaseMessage) {
           name: correspondingToolCall.name,
           input: functionCallPart.functionCall.args,
         };
+      } else if (
+        isAIMessage(message) &&
+        foreignReasoningTypes.some((t) => t === contentPart.type)
+      ) {
+        // Foreign reasoning on an ASSISTANT turn (Bedrock `reasoning_content`,
+        // Google `reasoning`, LibreChat `think`) carries provider-specific
+        // signatures Anthropic cannot validate; drop it so a cross-provider
+        // handoff doesn't crash. The same types on a user/tool turn are real
+        // input and fall through to the throw below rather than being silently
+        // dropped — as does any other unknown block (user media, Google
+        // code-execution), which must be surfaced, not discarded.
+        return null;
       } else {
         console.error(
           'Unsupported content part:',
@@ -808,25 +842,53 @@ export function _convertMessagesToAnthropicPayload(
           };
         }
       } else {
-        const { content } = message;
-        const hasMismatchedToolCalls = !toolCalls.every(
-          (toolCall) =>
-            !!content.find(
-              (contentPart) =>
-                (contentPart.type === 'tool_use' ||
-                  contentPart.type === 'input_json_delta' ||
-                  contentPart.type === 'server_tool_use') &&
-                contentPart.id === toolCall.id
+        const formattedContent = _formatContent(message);
+        const formattedBlocks = Array.isArray(formattedContent)
+          ? formattedContent
+          : [];
+        // Tool calls already materialized as content blocks by `_formatContent`.
+        // Derived from the FORMATTED output (not the raw content by type) so
+        // that Google `functionCall` parts — which `_formatContent` converts
+        // into `tool_use` — count as represented and are not appended twice.
+        const representedToolIds = new Set(
+          formattedBlocks
+            .filter(
+              (block) =>
+                block != null &&
+                (block.type === 'tool_use' || block.type === 'server_tool_use')
             )
+            .map((block) => (block as { id?: string }).id)
         );
-        if (hasMismatchedToolCalls) {
-          console.warn(
-            'The "tool_calls" field on a message is only respected if content is a string.'
-          );
+        // Client tool calls present in `tool_calls` but absent from the
+        // formatted content — e.g. a Bedrock extended-thinking turn records the
+        // tool only on `tool_calls` and leaves `content` as just the reasoning
+        // block. Without materializing them, dropping that reasoning block
+        // silently loses the (handoff) tool call instead of forwarding it.
+        const unrepresentedToolCalls = toolCalls.filter(
+          (toolCall) =>
+            !(
+              toolCall.id?.startsWith(Constants.ANTHROPIC_SERVER_TOOL_PREFIX) ??
+              false
+            ) && !representedToolIds.has(toolCall.id)
+        );
+        if (unrepresentedToolCalls.length === 0) {
+          return { role, content: formattedContent };
         }
+        const existingBlocks = formattedBlocks.filter(
+          (block) =>
+            !(
+              block != null &&
+              block.type === 'text' &&
+              'text' in block &&
+              block.text === ANTHROPIC_EMPTY_TEXT_PLACEHOLDER
+            )
+        );
         return {
           role,
-          content: _formatContent(message),
+          content: [
+            ...existingBlocks,
+            ...unrepresentedToolCalls.map(_convertLangChainToolCallToAnthropic),
+          ],
         };
       }
     } else {

package/src/llm/bedrock/utils/cross-provider-reasoning.test.ts

@@ -0,0 +1,131 @@
+import { AIMessage, HumanMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import { convertToConverseMessages } from './message_inputs';
+
+/**
+ * Mirror of the Anthropic-side cross-provider reasoning fix, for the reverse
+ * handoff (Anthropic → Bedrock). An Anthropic extended-thinking turn leaves
+ * `thinking`/`redacted_thinking` blocks in history; the Bedrock Converse
+ * converter has no branch for them and previously threw
+ * "Unsupported content block type: thinking", crashing the handoff. Bedrock's
+ * native reasoning is `reasoning_content` (still converted); foreign reasoning
+ * (`thinking`/`redacted_thinking`/`reasoning`/`think`) is dropped on assistant
+ * turns, while any other unknown block still throws rather than being silently
+ * omitted.
+ */
+type ConverseResult = ReturnType<typeof convertToConverseMessages>;
+
+/** Minimal view of a converted Bedrock Converse content block the assertions read. */
+interface ConverseBlock {
+  text?: string;
+  reasoningContent?: { reasoningText?: { text?: string; signature?: string } };
+  toolUse?: {
+    toolUseId?: string;
+    name?: string;
+    input?: Record<string, string>;
+  };
+}
+
+const assistantContent = (result: ConverseResult): ConverseBlock[] => {
+  const msg = result.converseMessages.find((m) => m.role === 'assistant');
+  return (msg?.content ?? []) as ConverseBlock[];
+};
+
+describe('convertToConverseMessages — cross-provider reasoning (Anthropic → Bedrock)', () => {
+  it('drops Anthropic thinking/redacted_thinking on an assistant turn, keeping text and tool calls', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('research Assort Health'),
+      new AIMessage({
+        content: [
+          {
+            type: 'thinking',
+            thinking: 'Let me hand off to the data agent.',
+            signature: 'anthropic-signature-not-valid-for-bedrock',
+          },
+          { type: 'redacted_thinking', data: 'redacted-blob' },
+          { type: 'text', text: 'Handing off now.' },
+        ],
+        tool_calls: [
+          {
+            id: 'tooluse_transfer',
+            name: 'lc_transfer_to_data_agent',
+            args: { reason: 'need consumption data' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+    ];
+
+    expect(() => convertToConverseMessages(messages)).not.toThrow();
+    const content = assistantContent(convertToConverseMessages(messages));
+
+    expect(content.find((b) => b.reasoningContent != null)).toBeUndefined();
+    expect(JSON.stringify(content)).not.toContain(
+      'anthropic-signature-not-valid-for-bedrock'
+    );
+    expect(JSON.stringify(content)).not.toContain('redacted-blob');
+
+    expect(content.some((b) => b.text === 'Handing off now.')).toBe(true);
+    const toolUse = content.find((b) => b.toolUse != null);
+    expect(toolUse?.toolUse).toMatchObject({
+      toolUseId: 'tooluse_transfer',
+      name: 'lc_transfer_to_data_agent',
+      input: { reason: 'need consumption data' },
+    });
+  });
+
+  it('emits a placeholder (not empty content) when a reasoning-only turn is fully dropped', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          { type: 'thinking', thinking: 'only thinking, no other content' },
+        ],
+      }),
+    ];
+    expect(() => convertToConverseMessages(messages)).not.toThrow();
+    const content = assistantContent(convertToConverseMessages(messages));
+    expect(content.length).toBeGreaterThan(0);
+    expect(content.find((b) => b.reasoningContent != null)).toBeUndefined();
+    expect(content.every((b) => typeof b.text === 'string')).toBe(true);
+  });
+
+  it('still throws on a genuinely unknown assistant block', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('run code'),
+      new AIMessage({
+        content: [
+          { type: 'some_future_block_type', foo: 'bar' },
+          { type: 'text', text: 'done' },
+        ],
+      }),
+    ];
+    expect(() => convertToConverseMessages(messages)).toThrow(
+      'Unsupported content block type'
+    );
+  });
+
+  it('still converts Bedrock-native reasoning_content (not dropped)', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          {
+            type: 'reasoning_content',
+            reasoningText: {
+              text: 'native bedrock reasoning',
+              signature: 'sig',
+            },
+          },
+          { type: 'text', text: 'answer' },
+        ],
+      }),
+    ];
+    const content = assistantContent(convertToConverseMessages(messages));
+    const reasoning = content.find((b) => b.reasoningContent != null);
+    expect(reasoning).toBeDefined();
+    expect(reasoning?.reasoningContent?.reasoningText?.text).toBe(
+      'native bedrock reasoning'
+    );
+  });
+});

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

@@ -28,6 +28,26 @@ import type {
   MessageContentReasoningBlock,
 } from '../types';
 
+/**
+ * Reasoning blocks from other providers, relative to Bedrock. Bedrock's native
+ * reasoning format is `reasoning_content`; these carry provider-specific
+ * signatures Bedrock cannot validate, so they are dropped on a cross-provider
+ * handoff (e.g. Anthropic → Bedrock) rather than crashing the conversion.
+ */
+const FOREIGN_REASONING_TYPES = [
+  'thinking',
+  'redacted_thinking',
+  'reasoning',
+  'think',
+];
+
+/**
+ * Bedrock Converse rejects assistant messages with no content blocks. When
+ * filtering (e.g. dropping foreign reasoning) empties an assistant turn that
+ * also has no tool calls, fall back to this placeholder text.
+ */
+const BEDROCK_EMPTY_TEXT_PLACEHOLDER = '_';
+
 /**
  * Convert a LangChain reasoning block to a Bedrock reasoning block.
  */
@@ -644,6 +664,15 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
             type: 'default',
           },
         } as BedrockContentBlock);
+      } else if (FOREIGN_REASONING_TYPES.some((t) => t === block.type)) {
+        // Reasoning from another provider (Anthropic `thinking`/
+        // `redacted_thinking`, Google `reasoning`, LibreChat `think`). Bedrock's
+        // native reasoning is `reasoning_content` (handled above); a foreign
+        // block carries a signature Bedrock cannot validate, so drop it on a
+        // cross-provider handoff (e.g. Anthropic → Bedrock) rather than crash.
+        // The Bedrock model produces its own reasoning. Anything else unknown
+        // still throws below — real content must be surfaced, not dropped.
+        return;
       } else {
         const blockValues = Object.fromEntries(
           Object.entries(block).filter(([key]) => key !== 'type')
@@ -672,6 +701,12 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
     ] as BedrockContentBlock[];
   }
 
+  // Bedrock rejects an assistant message with no content blocks; if filtering
+  // (e.g. dropping foreign reasoning) left it empty, emit a placeholder.
+  if (assistantMsg.content == null || assistantMsg.content.length === 0) {
+    assistantMsg.content = [{ text: BEDROCK_EMPTY_TEXT_PLACEHOLDER }];
+  }
+
   return assistantMsg;
 }
 

package/src/llm/invoke.test.ts

@@ -12,8 +12,8 @@ import type { BaseMessage } from '@langchain/core/messages';
 import type * as t from '@/types';
 import { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
 import { attemptInvoke, tryFallbackProviders } from '@/llm/invoke';
+import { Constants, Providers } from '@/common';
 import { ToolNode } from '@/tools/ToolNode';
-import { Providers } from '@/common';
 
 /**
  * Minimal stub model shape `attemptInvoke` reads. Either `invoke` or
@@ -341,6 +341,84 @@ describe('tryFallbackProviders applies the same lazy annotation transform', () =
   });
 });
 
+describe('invocation attribution metadata', () => {
+  it('stamps INVOKED_PROVIDER on the config passed to the model', async () => {
+    const capturedConfigs: unknown[] = [];
+    const model: StubModel = {
+      invoke: jest.fn(
+        async (_m: BaseMessage[], config?: unknown): Promise<AIMessage> => {
+          capturedConfigs.push(config);
+          return new AIMessage({ content: 'ok' });
+        }
+      ),
+    };
+
+    await attemptInvoke(
+      {
+        model: model as t.ChatModel,
+        messages: [new HumanMessage('hi')],
+        /** A ChatOpenAI-derived provider — `ls_provider` would lie here. */
+        provider: Providers.DEEPSEEK,
+      },
+      { configurable: { run_id: 'run-attr' }, metadata: { existing: true } }
+    );
+
+    const config = capturedConfigs[0] as {
+      metadata?: Record<string, unknown>;
+    };
+    expect(config.metadata?.[Constants.INVOKED_PROVIDER]).toBe(
+      Providers.DEEPSEEK
+    );
+    /** Pre-existing metadata is preserved, not replaced. */
+    expect(config.metadata?.existing).toBe(true);
+  });
+
+  it('stamps INVOKED_MODEL from the fallback clientOptions in tryFallbackProviders', async () => {
+    const capturedConfigs: unknown[] = [];
+    const model: StubModel = {
+      invoke: jest.fn(
+        async (_m: BaseMessage[], config?: unknown): Promise<AIMessage> => {
+          capturedConfigs.push(config);
+          return new AIMessage({ content: 'ok' });
+        }
+      ),
+    };
+
+    jest.doMock('@/llm/init', () => ({
+      initializeModel: (): unknown => model,
+    }));
+    jest.resetModules();
+    const { tryFallbackProviders: freshTry } = (await import(
+      '@/llm/invoke'
+    )) as { tryFallbackProviders: typeof tryFallbackProviders };
+
+    await freshTry({
+      fallbacks: [
+        {
+          provider: Providers.ANTHROPIC,
+          clientOptions: { model: 'claude-fallback-1' },
+        },
+      ],
+      messages: [new HumanMessage('hi')],
+      primaryError: new Error('primary failed'),
+      config: { configurable: { run_id: 'run-attr-fb' } },
+    });
+
+    const config = capturedConfigs[0] as {
+      metadata?: Record<string, unknown>;
+    };
+    expect(config.metadata?.[Constants.INVOKED_MODEL]).toBe(
+      'claude-fallback-1'
+    );
+    expect(config.metadata?.[Constants.INVOKED_PROVIDER]).toBe(
+      Providers.ANTHROPIC
+    );
+
+    jest.dontMock('@/llm/init');
+    jest.resetModules();
+  });
+});
+
 describe('cross-run hydration through ToolNode + attemptInvoke', () => {
   it('annotates run 2 refs but leaves hydrated run 1 ToolMessages untouched', async () => {
     /**

package/src/llm/invoke.ts

@@ -6,10 +6,10 @@ import type { BaseMessage } from '@langchain/core/messages';
 import type { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
 import type * as t from '@/types';
 import { annotateMessagesForLLM } from '@/tools/toolOutputReferences';
+import { Constants, GraphEvents, Providers } from '@/common';
 import { manualToolStreamProviders } from '@/llm/providers';
 import { modifyDeltaProperties } from '@/messages';
 import { ChatModelStreamHandler } from '@/stream';
-import { GraphEvents, Providers } from '@/common';
 import { initializeModel } from '@/llm/init';
 
 /**
@@ -208,6 +208,23 @@ export async function attemptInvoke(
   const runId = config?.configurable?.run_id as string | undefined;
   const messagesForProvider = annotateMessagesForLLM(messages, registry, runId);
 
+  /**
+   * Stamp the provider that is ACTUALLY serving this invocation onto the
+   * callback metadata. `attemptInvoke` is the single funnel for primary,
+   * fallback, and summarization model calls, so consumers that need
+   * provider attribution per call (the subagent usage-capture handler)
+   * read this key instead of trusting static agent config — which is
+   * wrong for fallback-served calls — or `ls_provider` — which derived
+   * providers inherit from their base class.
+   */
+  config = {
+    ...config,
+    metadata: {
+      ...(config?.metadata ?? {}),
+      [Constants.INVOKED_PROVIDER]: provider,
+    },
+  };
+
   if (model.stream) {
     const stream = await model.stream(messagesForProvider, config);
     let finalChunk: AIMessageChunk | undefined;
@@ -224,7 +241,7 @@ export async function attemptInvoke(
         });
       }
     } else if (registeredStreamHandler == null) {
-      const metadata = config?.metadata as Record<string, unknown> | undefined;
+      const metadata = config.metadata as Record<string, unknown> | undefined;
       const streamHandler = new ChatModelStreamHandler();
       for await (const chunk of stream) {
         const handlingChunk = getStreamHandlingChunk({
@@ -247,7 +264,7 @@ export async function attemptInvoke(
         });
       }
     } else {
-      const metadata = config?.metadata as Record<string, unknown> | undefined;
+      const metadata = config.metadata as Record<string, unknown> | undefined;
       for await (const chunk of stream) {
         const handlingChunk = getStreamHandlingChunk({
           current: finalChunk,
@@ -292,6 +309,25 @@ export async function attemptInvoke(
   return { messages: [finalMessage] };
 }
 
+/**
+ * Best-effort read of the configured model name from client options.
+ * Providers disagree on the key (`model` vs `modelName`).
+ */
+function extractClientOptionsModel(
+  clientOptions: t.ClientOptions | undefined
+): string | undefined {
+  const options = clientOptions as
+    | { model?: unknown; modelName?: unknown }
+    | undefined;
+  if (typeof options?.model === 'string' && options.model !== '') {
+    return options.model;
+  }
+  if (typeof options?.modelName === 'string' && options.modelName !== '') {
+    return options.modelName;
+  }
+  return undefined;
+}
+
 /**
  * Attempts each fallback provider in order until one succeeds.
  * Throws the last error if all fallbacks fail.
@@ -321,6 +357,24 @@ export async function tryFallbackProviders({
         clientOptions: fb.clientOptions,
         tools,
       });
+      /**
+       * Stamp the fallback's configured model onto callback metadata so
+       * per-call attribution (subagent usage capture) doesn't fall back to
+       * the PRIMARY config's model when the provider reports no
+       * `ls_model_name`. The serving provider is stamped uniformly by
+       * `attemptInvoke` (`INVOKED_PROVIDER`).
+       */
+      const fbModelName = extractClientOptionsModel(fb.clientOptions);
+      const fbConfig: RunnableConfig | undefined =
+        fbModelName == null
+          ? config
+          : {
+            ...config,
+            metadata: {
+              ...(config?.metadata ?? {}),
+              [Constants.INVOKED_MODEL]: fbModelName,
+            },
+          };
       const result = await attemptInvoke(
         {
           model: fbModel as t.ChatModel,
@@ -329,7 +383,7 @@ export async function tryFallbackProviders({
           context,
           onChunk,
         },
-        config
+        fbConfig
       );
       return result;
     } catch (e) {

package/src/messages/budget.ts

@@ -0,0 +1,32 @@
+import type * as t from '@/types';
+
+/**
+ * Reconciles a context-usage breakdown's instruction/available/message fields
+ * from the pruner's budget metrics. `messageTokens` and `availableForMessages`
+ * are DERIVED from `contextBudget` / `effectiveInstructionTokens` /
+ * `remainingContextTokens` rather than summed from the index map — that map is
+ * keyed by pre-prune indices, so summing it over the kept context would missum.
+ * Shared by the live snapshot path (`Graph.createCallModel`) and the pre-send
+ * projection (`AgentContext.projectContextUsage`) so both yield identical numbers.
+ */
+export function syncBudgetDerivedFields(usage: t.ContextUsageEvent): void {
+  const { breakdown, contextBudget, effectiveInstructionTokens } = usage;
+  if (effectiveInstructionTokens == null) {
+    return;
+  }
+  breakdown.instructionTokens = effectiveInstructionTokens;
+  if (contextBudget == null) {
+    return;
+  }
+  breakdown.availableForMessages = Math.max(
+    0,
+    contextBudget - effectiveInstructionTokens
+  );
+  if (usage.remainingContextTokens == null) {
+    return;
+  }
+  breakdown.messageTokens = Math.max(
+    0,
+    contextBudget - effectiveInstructionTokens - usage.remainingContextTokens
+  );
+}

package/src/messages/cache.ts

@@ -41,7 +41,7 @@ function deepCloneContent<T extends string | MessageContentComplex[]>(
  * in downstream code (e.g., ensureThinkingBlockInMessages).
  * For plain objects (AnthropicMessage), uses object spread.
  */
-function cloneMessage<T extends MessageWithContent>(
+export function cloneMessage<T extends MessageWithContent>(
   message: T,
   content: string | MessageContentComplex[]
 ): T {

package/src/messages/content.ts

@@ -1,6 +1,26 @@
-import type { BaseMessage } from '@langchain/core/messages';
+import type {
+  BaseMessage,
+  MessageContentComplex,
+} from '@langchain/core/messages';
 import { ContentTypes } from '@/common';
 
+/**
+ * Whether {@link formatContentStrings} will flatten this message's content:
+ * a human/ai/system message whose content is an array of text-only blocks.
+ */
+export const isLegacyConvertible = (message: BaseMessage): boolean => {
+  const messageType = message.getType();
+  const isValidMessage =
+    messageType === 'human' || messageType === 'ai' || messageType === 'system';
+  if (!isValidMessage) {
+    return false;
+  }
+  if (!Array.isArray(message.content)) {
+    return false;
+  }
+  return message.content.every((block) => block.type === ContentTypes.TEXT);
+};
+
 /**
  * Formats an array of messages for LangChain, making sure all content fields are strings
  * @param {Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>} payload - The array of messages to format.
@@ -13,42 +33,14 @@ export const formatContentStrings = (
   const result: Array<BaseMessage> = [];
 
   for (const message of payload) {
-    const messageType = message.getType();
-    const isValidMessage =
-      messageType === 'human' ||
-      messageType === 'ai' ||
-      messageType === 'system';
-
-    if (!isValidMessage) {
-      result.push(message);
-      continue;
-    }
-
-    // If content is already a string, add as-is
-    if (typeof message.content === 'string') {
-      result.push(message);
-      continue;
-    }
-
-    // If content is not an array, add as-is
-    if (!Array.isArray(message.content)) {
-      result.push(message);
-      continue;
-    }
-
-    // Check if all content blocks are text type
-    const allTextBlocks = message.content.every(
-      (block) => block.type === ContentTypes.TEXT
-    );
-
-    // Only convert to string if all blocks are text type
-    if (!allTextBlocks) {
+    if (!isLegacyConvertible(message)) {
       result.push(message);
       continue;
     }
 
     // Reduce text types to a single string
-    const content = message.content.reduce((acc, curr) => {
+    const blocks = message.content as MessageContentComplex[];
+    const content = blocks.reduce((acc, curr) => {
       if (curr.type === ContentTypes.TEXT) {
         return `${acc}${curr[ContentTypes.TEXT] || ''}\n`;
       }

package/src/messages/index.ts

@@ -1,6 +1,7 @@
 export * from './core';
 export * from './ids';
 export * from './prune';
+export * from './budget';
 export * from './format';
 export * from './cache';
 export * from './anthropicToolCache';