@librechat/agents 3.2.35 → 3.2.36

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

@@ -0,0 +1,317 @@
+import { AIMessage, HumanMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import { _convertMessagesToAnthropicPayload } from './message_inputs';
+
+/**
+ * Regression for cross-provider agent handoffs (e.g. Bedrock → Anthropic): a
+ * Bedrock turn that used extended thinking leaves a `reasoning_content` content
+ * block ({ reasoningText: { text, signature } }) in the history. The official
+ * Anthropic converter has no branch for it and previously threw
+ * "Unsupported message content format", crashing the handoff. Only known
+ * foreign reasoning (Bedrock `reasoning_content`, Google `reasoning`, LibreChat
+ * `think`) is dropped; any other unknown block still throws rather than being
+ * silently omitted (real content — user media, Google code-execution — must be
+ * surfaced); and a tool call carried only on `tool_calls` survives dropping its
+ * reasoning sibling without being duplicated.
+ */
+type AnthropicPayload = ReturnType<typeof _convertMessagesToAnthropicPayload>;
+
+/** Minimal view of a converted Anthropic content block the assertions read. */
+interface TestBlock {
+  type?: string;
+  text?: string;
+}
+
+const findAssistant = (payload: AnthropicPayload) =>
+  payload.messages.find((m) => m.role === 'assistant');
+
+const assistantBlocks = (payload: AnthropicPayload): TestBlock[] => {
+  const content = findAssistant(payload)?.content;
+  return Array.isArray(content) ? (content as TestBlock[]) : [];
+};
+
+describe('_convertMessagesToAnthropicPayload — cross-provider reasoning blocks', () => {
+  const bedrockHandoffHistory = (): BaseMessage[] => [
+    new HumanMessage('research Assort Health'),
+    new AIMessage({
+      content: [
+        {
+          type: 'reasoning_content',
+          index: 0,
+          reasoningText: {
+            text: 'Let me search Notion then hand off to the data agent.',
+            signature: 'bedrock-signature-not-valid-for-anthropic',
+          },
+        },
+        { type: 'text', text: 'Kicking off the searches now.' },
+        {
+          type: 'tool_use',
+          id: 'tooluse_abc',
+          name: 'notion-search',
+          input: { query: 'Assort Health' },
+        },
+      ],
+      tool_calls: [
+        {
+          id: 'tooluse_abc',
+          name: 'notion-search',
+          args: { query: 'Assort Health' },
+          type: 'tool_call',
+        },
+      ],
+    }),
+  ];
+
+  it('does not throw on a Bedrock reasoning_content block', () => {
+    expect(() =>
+      _convertMessagesToAnthropicPayload(bedrockHandoffHistory())
+    ).not.toThrow();
+  });
+
+  it('drops reasoning_content (incl. its foreign signature) but keeps text and tool_use', () => {
+    const payload = _convertMessagesToAnthropicPayload(bedrockHandoffHistory());
+    expect(findAssistant(payload)).toBeDefined();
+    const blocks = assistantBlocks(payload);
+
+    expect(blocks.find((b) => b.type === 'reasoning_content')).toBeUndefined();
+    expect(
+      blocks.find(
+        (b) => b.type === 'thinking' || b.type === 'redacted_thinking'
+      )
+    ).toBeUndefined();
+    expect(JSON.stringify(blocks)).not.toContain(
+      'bedrock-signature-not-valid-for-anthropic'
+    );
+
+    expect(
+      blocks.some(
+        (b) => b.type === 'text' && b.text === 'Kicking off the searches now.'
+      )
+    ).toBe(true);
+    expect(blocks.find((b) => b.type === 'tool_use')).toMatchObject({
+      type: 'tool_use',
+      id: 'tooluse_abc',
+      name: 'notion-search',
+      input: { query: 'Assort Health' },
+    });
+  });
+
+  it('drops a Google `reasoning` block without throwing', () => {
+    const history: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          { type: 'reasoning', reasoning: 'internal google chain of thought' },
+          { type: 'text', text: 'Hello!' },
+        ],
+      }),
+    ];
+    expect(() => _convertMessagesToAnthropicPayload(history)).not.toThrow();
+    const blocks = assistantBlocks(_convertMessagesToAnthropicPayload(history));
+    expect(blocks.find((b) => b.type === 'reasoning')).toBeUndefined();
+    expect(blocks.some((b) => b.type === 'text' && b.text === 'Hello!')).toBe(
+      true
+    );
+  });
+
+  it('drops a LibreChat `think` block without throwing', () => {
+    const history: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          { type: 'think', think: 'librechat serialized reasoning' },
+          { type: 'text', text: 'Done.' },
+        ],
+      }),
+    ];
+    expect(() => _convertMessagesToAnthropicPayload(history)).not.toThrow();
+    const blocks = assistantBlocks(_convertMessagesToAnthropicPayload(history));
+    expect(blocks.find((b) => b.type === 'think')).toBeUndefined();
+    expect(blocks.some((b) => b.type === 'text' && b.text === 'Done.')).toBe(
+      true
+    );
+  });
+
+  it('drops an unsigned `thinking` block (Google thinking-enabled output) on an assistant turn', () => {
+    const history: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          {
+            type: 'thinking',
+            thinking: 'google chain of thought, no signature',
+          },
+          { type: 'text', text: 'Answer.' },
+        ],
+      }),
+    ];
+    expect(() => _convertMessagesToAnthropicPayload(history)).not.toThrow();
+    const blocks = assistantBlocks(_convertMessagesToAnthropicPayload(history));
+    expect(blocks.find((b) => b.type === 'thinking')).toBeUndefined();
+    expect(blocks.some((b) => b.type === 'text' && b.text === 'Answer.')).toBe(
+      true
+    );
+  });
+
+  it('forwards a signed `thinking` block (Anthropic-native) unchanged', () => {
+    const history: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          {
+            type: 'thinking',
+            thinking: 'native reasoning',
+            signature: 'valid-sig',
+          },
+          { type: 'text', text: 'Answer.' },
+        ],
+      }),
+    ];
+    const blocks = assistantBlocks(_convertMessagesToAnthropicPayload(history));
+    expect(blocks.find((b) => b.type === 'thinking')).toMatchObject({
+      type: 'thinking',
+      thinking: 'native reasoning',
+      signature: 'valid-sig',
+    });
+  });
+
+  it('throws (not silently drops) on an unknown assistant block such as Google code execution', () => {
+    // executableCode/codeExecutionResult carry real visible content; silently
+    // dropping them on a Google → Anthropic handoff would lose evidence.
+    const history: BaseMessage[] = [
+      new HumanMessage('run some code'),
+      new AIMessage({
+        content: [
+          {
+            type: 'executableCode',
+            executableCode: { language: 'PYTHON', code: 'print(2+2)' },
+          },
+          { type: 'text', text: 'Here is the result.' },
+        ],
+      }),
+    ];
+    expect(() => _convertMessagesToAnthropicPayload(history)).toThrow(
+      'Unsupported message content format'
+    );
+  });
+
+  it('throws (not silently drops) on an unsupported user block such as media', () => {
+    const history: BaseMessage[] = [
+      new HumanMessage({
+        content: [
+          {
+            type: 'video_url',
+            video_url: { url: 'https://example.com/v.mp4' },
+          },
+          { type: 'text', text: 'what is in this video?' },
+        ],
+      }),
+    ];
+    expect(() => _convertMessagesToAnthropicPayload(history)).toThrow(
+      'Unsupported message content format'
+    );
+  });
+
+  it('does not drop a reasoning-typed block on a user turn (only assistant reasoning is dropped)', () => {
+    const history: BaseMessage[] = [
+      new HumanMessage({
+        content: [
+          { type: 'reasoning_content', reasoningText: { text: 'user text' } },
+          { type: 'text', text: 'hello' },
+        ],
+      }),
+    ];
+    expect(() => _convertMessagesToAnthropicPayload(history)).toThrow(
+      'Unsupported message content format'
+    );
+  });
+
+  it('preserves a tool call carried only on tool_calls when its reasoning sibling is dropped', () => {
+    // Mirrors a Bedrock extended-thinking turn: the tool lives only on
+    // `tool_calls`; `content` holds just the reasoning block (no tool_use).
+    const history: BaseMessage[] = [
+      new HumanMessage('research Assort Health'),
+      new AIMessage({
+        content: [
+          {
+            type: 'reasoning_content',
+            reasoningText: { text: 'I should hand off now.', signature: 'sig' },
+          },
+        ],
+        tool_calls: [
+          {
+            id: 'tooluse_transfer',
+            name: 'lc_transfer_to_data_agent',
+            args: { reason: 'need consumption data' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+    ];
+    expect(() => _convertMessagesToAnthropicPayload(history)).not.toThrow();
+    const blocks = assistantBlocks(_convertMessagesToAnthropicPayload(history));
+    expect(blocks.find((b) => b.type === 'reasoning_content')).toBeUndefined();
+    expect(blocks.find((b) => b.type === 'tool_use')).toMatchObject({
+      type: 'tool_use',
+      id: 'tooluse_transfer',
+      name: 'lc_transfer_to_data_agent',
+      input: { reason: 'need consumption data' },
+    });
+    // The `_` placeholder must not linger once a real tool_use block is present.
+    expect(blocks.some((b) => b.type === 'text' && b.text === '_')).toBe(false);
+  });
+
+  it('does not duplicate a Google functionCall tool call already materialized by _formatContent', () => {
+    // _formatContent converts the `functionCall` part into a tool_use; the
+    // materialization must recognize it as represented and not append a second.
+    const history: BaseMessage[] = [
+      new HumanMessage('weather in SF?'),
+      new AIMessage({
+        content: [
+          {
+            type: 'functionCall',
+            functionCall: { name: 'get_weather', args: { city: 'SF' } },
+          },
+        ],
+        tool_calls: [
+          {
+            id: 'call_weather_1',
+            name: 'get_weather',
+            args: { city: 'SF' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+    ];
+    const blocks = assistantBlocks(_convertMessagesToAnthropicPayload(history));
+    const toolUses = blocks.filter((b) => b.type === 'tool_use');
+    expect(toolUses).toHaveLength(1);
+    expect(toolUses[0]).toMatchObject({
+      type: 'tool_use',
+      id: 'call_weather_1',
+      name: 'get_weather',
+    });
+  });
+
+  it('falls back to placeholder text when reasoning was the only content', () => {
+    const history: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          {
+            type: 'reasoning_content',
+            reasoningText: {
+              text: 'only thinking, no visible text',
+              signature: 'sig',
+            },
+          },
+        ],
+      }),
+    ];
+    expect(() => _convertMessagesToAnthropicPayload(history)).not.toThrow();
+    const blocks = assistantBlocks(_convertMessagesToAnthropicPayload(history));
+    expect(blocks.find((b) => b.type === 'reasoning_content')).toBeUndefined();
+    expect(blocks.length).toBeGreaterThan(0);
+    expect(blocks.every((b) => b.type === 'text')).toBe(true);
+  });
+});

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/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 {