@librechat/agents 3.2.35 → 3.2.37

package/src/llm/anthropic/utils/stripPrefillCache.test.ts

@@ -0,0 +1,111 @@
+import type { AnthropicMessageCreateParams } from '../types';
+import { stripUnsupportedAssistantPrefill } from './message_inputs';
+
+/**
+ * When a model disallows assistant prefill (Claude 4.6+), the trailing
+ * assistant message is stripped right before the API call. If the single tail
+ * prompt-cache breakpoint rode that assistant prefill, the survivors would lose
+ * their only message-level `cache_control` — so the strip must re-anchor the
+ * breakpoint onto the new tail.
+ */
+
+type Msgs = AnthropicMessageCreateParams['messages'];
+
+function cacheControlBlocks(messages: Msgs): number {
+  let n = 0;
+  for (const m of messages) {
+    if (!Array.isArray(m.content)) continue;
+    for (const b of m.content) {
+      if ('cache_control' in b) n++;
+    }
+  }
+  return n;
+}
+
+describe('stripUnsupportedAssistantPrefill — cache re-anchoring', () => {
+  test('re-anchors the breakpoint onto the new tail when the prefill carried it', () => {
+    const request = {
+      model: 'claude-opus-4-6',
+      max_tokens: 100,
+      messages: [
+        {
+          role: 'user' as const,
+          content: [{ type: 'text' as const, text: 'q' }],
+        },
+        {
+          role: 'assistant' as const,
+          content: [
+            {
+              type: 'text' as const,
+              text: 'prefill',
+              cache_control: { type: 'ephemeral' as const },
+            },
+          ],
+        },
+      ],
+    };
+
+    const out = stripUnsupportedAssistantPrefill(request);
+
+    // Prefill removed, and exactly one breakpoint survives — on the new tail.
+    expect(out.messages).toHaveLength(1);
+    expect(out.messages[0].role).toBe('user');
+    expect(cacheControlBlocks(out.messages)).toBe(1);
+    const tail = out.messages[0].content as Array<{ cache_control?: unknown }>;
+    expect(tail[tail.length - 1].cache_control).toEqual({ type: 'ephemeral' });
+  });
+
+  test('does not add a breakpoint when caching was off (no marker present)', () => {
+    const request = {
+      model: 'claude-opus-4-6',
+      max_tokens: 100,
+      messages: [
+        { role: 'user' as const, content: 'q' },
+        { role: 'assistant' as const, content: 'prefill' },
+      ],
+    };
+
+    const out = stripUnsupportedAssistantPrefill(request);
+
+    expect(out.messages).toHaveLength(1);
+    expect(cacheControlBlocks(out.messages)).toBe(0);
+  });
+
+  test('leaves a surviving breakpoint untouched (no double-anchor)', () => {
+    const request = {
+      model: 'claude-opus-4-6',
+      max_tokens: 100,
+      messages: [
+        {
+          role: 'user' as const,
+          content: [
+            {
+              type: 'text' as const,
+              text: 'q',
+              cache_control: { type: 'ephemeral' as const },
+            },
+          ],
+        },
+        { role: 'assistant' as const, content: 'prefill' },
+      ],
+    };
+
+    const out = stripUnsupportedAssistantPrefill(request);
+
+    expect(out.messages).toHaveLength(1);
+    expect(cacheControlBlocks(out.messages)).toBe(1);
+  });
+
+  test('older models keep the assistant prefill (no strip, no re-anchor)', () => {
+    const request = {
+      model: 'claude-sonnet-4-5-20250929',
+      max_tokens: 100,
+      messages: [
+        { role: 'user' as const, content: 'q' },
+        { role: 'assistant' as const, content: '{' },
+      ],
+    };
+
+    expect(stripUnsupportedAssistantPrefill(request)).toBe(request);
+  });
+});

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.test.ts

@@ -0,0 +1,129 @@
+import { AIMessage, HumanMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import { convertToConverseMessages } from './message_inputs';
+
+/**
+ * Native-Bedrock reasoning serialization. A `reasoning_content` block whose
+ * `reasoningText.text` is null/empty (e.g. a signature-only block that never
+ * merged with its text) is invalid for Bedrock Converse — it rejects with
+ * `...reasoningContent.reasoningText.text ... Member must not be null`. Such a
+ * block must be dropped on replay rather than sent; a block carrying real text
+ * is still converted.
+ */
+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 — native Bedrock reasoning serialization', () => {
+  it('drops a signature-only reasoning block, keeping text and tool calls', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('what data do you have?'),
+      new AIMessage({
+        content: [
+          {
+            type: 'reasoning_content',
+            reasoningText: { signature: 'sig-abc' },
+          },
+          { type: 'text', text: 'Let me check your databases.' },
+        ],
+        tool_calls: [
+          {
+            id: 'tooluse_list',
+            name: 'list_databases',
+            args: {},
+            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('sig-abc');
+    expect(content.some((b) => b.text === 'Let me check your databases.')).toBe(
+      true
+    );
+    const toolUse = content.find((b) => b.toolUse != null);
+    expect(toolUse?.toolUse).toMatchObject({
+      toolUseId: 'tooluse_list',
+      name: 'list_databases',
+    });
+  });
+
+  it('drops a reasoning block whose text is empty', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          {
+            type: 'reasoning_content',
+            reasoningText: { text: '', signature: 'sig' },
+          },
+          { type: 'text', text: 'answer' },
+        ],
+      }),
+    ];
+
+    const content = assistantContent(convertToConverseMessages(messages));
+    expect(content.find((b) => b.reasoningContent != null)).toBeUndefined();
+    expect(content.some((b) => b.text === 'answer')).toBe(true);
+  });
+
+  it('emits a placeholder (not empty content) when the only block is a signature-only reasoning block', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          { type: 'reasoning_content', reasoningText: { signature: 'sig' } },
+        ],
+      }),
+    ];
+
+    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 converts a reasoning block that carries text (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.
  */
@@ -52,6 +72,22 @@ export function langchainReasoningBlockToBedrockReasoningBlock(
   throw new Error('Invalid reasoning content');
 }
 
+/**
+ * Whether a reasoning block can be serialized to a valid Bedrock
+ * `reasoningContent`. Bedrock Converse rejects `reasoningText` with a null/empty
+ * `text` (e.g. a signature-only block that never merged with its text), so such
+ * blocks must be dropped rather than sent.
+ */
+function isSerializableBedrockReasoningBlock(
+  content: MessageContentReasoningBlock
+): boolean {
+  if (content.reasoningText != null) {
+    const text = content.reasoningText.text;
+    return text != null && text !== '';
+  }
+  return content.redactedContent != null && content.redactedContent !== '';
+}
+
 /**
  * Concatenate consecutive reasoning blocks in content array.
  */
@@ -633,10 +669,17 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
           contentBlocks.push({ text });
         }
       } else if (block.type === 'reasoning_content') {
+        const reasoningBlock = block as MessageContentReasoningBlock;
+        // Bedrock Converse rejects reasoningContent whose reasoningText.text is
+        // null/empty (a signature-only block that never merged with its text).
+        // Drop it rather than emit an invalid request; the empty-turn
+        // placeholder below covers a turn left with no content.
+        if (!isSerializableBedrockReasoningBlock(reasoningBlock)) {
+          return;
+        }
         contentBlocks.push({
-          reasoningContent: langchainReasoningBlockToBedrockReasoningBlock(
-            block as MessageContentReasoningBlock
-          ),
+          reasoningContent:
+            langchainReasoningBlockToBedrockReasoningBlock(reasoningBlock),
         } as BedrockContentBlock);
       } else if (isDefaultCachePoint(block)) {
         contentBlocks.push({
@@ -644,6 +687,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 +724,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;
 }
 
@@ -797,15 +855,34 @@ function convertToolMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
     content = [{ text: String(msg.content) }];
   }
 
+  // A `cachePoint` is a message-level ContentBlock — it is NOT a valid
+  // ToolResultContentBlock. A tail prompt-cache breakpoint that anchors on a
+  // tool result therefore ends up nested inside `toolResult.content`, which
+  // Bedrock silently ignores (no cache write, no cache read). Hoist any
+  // cachePoint(s) out of the tool result body so they sit as siblings after
+  // it, which is the only position Bedrock honors.
+  const toolResultContent: BedrockContentBlock[] = [];
+  const trailingCachePoints: BedrockContentBlock[] = [];
+  for (const block of content) {
+    if (isDefaultCachePoint(block)) {
+      trailingCachePoints.push({
+        cachePoint: { type: 'default' },
+      } as BedrockContentBlock);
+    } else {
+      toolResultContent.push(block);
+    }
+  }
+
   return {
     role: 'user',
     content: [
       {
         toolResult: {
           toolUseId: toolCallId,
-          content: content as { text: string }[],
+          content: toolResultContent as { text: string }[],
         },
       },
+      ...trailingCachePoints,
     ],
   };
 }

package/src/llm/bedrock/utils/toolResultCachePoint.test.ts

@@ -0,0 +1,103 @@
+import { HumanMessage, AIMessage, ToolMessage } from '@langchain/core/messages';
+import type {
+  BaseMessage,
+  MessageContentComplex,
+} from '@langchain/core/messages';
+import { addBedrockTailCacheControl } from '@/messages/cache';
+import { convertToConverseMessages } from './message_inputs';
+import { toLangChainContent } from '@/messages/langchain';
+
+/**
+ * A Bedrock `cachePoint` is a message-level ContentBlock and is NOT a valid
+ * `ToolResultContentBlock`. When the single tail prompt-cache breakpoint
+ * anchors on a tool result (the common agent-loop shape), the cachePoint must
+ * be hoisted out of `toolResult.content` to a message-level sibling — otherwise
+ * Bedrock silently drops the breakpoint (no cache write, no cache read),
+ * verified live against Bedrock Converse.
+ */
+
+interface ConverseBlock {
+  text?: string;
+  cachePoint?: { type?: string };
+  toolResult?: {
+    toolUseId?: string;
+    content?: Array<{ text?: string; cachePoint?: { type?: string } }>;
+  };
+}
+
+function toolUserMessage(
+  result: ReturnType<typeof convertToConverseMessages>
+): ConverseBlock[] {
+  const msg = result.converseMessages.find(
+    (m) =>
+      m.role === 'user' && m.content?.some((c) => 'toolResult' in c) === true
+  );
+  return (msg?.content ?? []) as ConverseBlock[];
+}
+
+describe('convertToConverseMessages — tool-result cachePoint hoisting', () => {
+  it('hoists a cachePoint out of toolResult.content to a message-level sibling', () => {
+    const toolMsg = new ToolMessage({
+      tool_call_id: 't1',
+      content: toLangChainContent([
+        { type: 'text', text: 'result body' },
+        { cachePoint: { type: 'default' } },
+      ] as MessageContentComplex[]),
+    });
+
+    const { converseMessages } = convertToConverseMessages([
+      new HumanMessage('go'),
+      toolMsg,
+    ]);
+
+    const content = toolUserMessage({ converseMessages, converseSystem: [] });
+
+    // toolResult body must NOT contain the cachePoint
+    const toolResult = content.find((c) => 'toolResult' in c)?.toolResult;
+    expect(toolResult?.content?.some((b) => 'cachePoint' in b)).toBe(false);
+    expect(toolResult?.content).toEqual([{ text: 'result body' }]);
+
+    // cachePoint must be a sibling AFTER the toolResult block
+    expect(content[content.length - 1]).toEqual({
+      cachePoint: { type: 'default' },
+    });
+  });
+
+  it('leaves tool results without a cachePoint untouched', () => {
+    const { converseMessages } = convertToConverseMessages([
+      new HumanMessage('go'),
+      new ToolMessage({ tool_call_id: 't1', content: 'plain result' }),
+    ]);
+
+    const content = toolUserMessage({ converseMessages, converseSystem: [] });
+    expect(content).toEqual([
+      { toolResult: { toolUseId: 't1', content: [{ text: 'plain result' }] } },
+    ]);
+  });
+
+  it('end-to-end: tail breakpoint on a string tool result renders as a valid sibling cachePoint', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('What is 15 * 23? Use the calculator.'),
+      new AIMessage({
+        content: 'Calculating.',
+        tool_calls: [
+          { id: 't1', name: 'calculator', args: { expression: '15 * 23' } },
+        ],
+      }),
+      new ToolMessage({ tool_call_id: 't1', content: '345' }),
+    ];
+
+    const cached = addBedrockTailCacheControl(messages);
+    const { converseMessages } = convertToConverseMessages(cached);
+
+    const content = toolUserMessage({ converseMessages, converseSystem: [] });
+    const toolResult = content.find((c) => 'toolResult' in c)?.toolResult;
+
+    // Exactly one cachePoint, at the message level, never nested in the body.
+    expect(toolResult?.content?.some((b) => 'cachePoint' in b)).toBe(false);
+    expect(content.filter((c) => 'cachePoint' in c)).toHaveLength(1);
+    expect(content[content.length - 1]).toEqual({
+      cachePoint: { type: 'default' },
+    });
+  });
+});

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