@librechat/agents 3.2.64 → 3.2.66

package/src/llm/anthropic/llm.spec.ts

@@ -961,7 +961,7 @@ class RecordingStreamingAnthropic extends ChatAnthropic {
   }
 }
 
-test('Anthropic message_delta usage emits only output token totals', () => {
+test('Anthropic message_delta usage preserves cumulative input totals', () => {
   const event: AnthropicStreamEvent = {
     type: 'message_delta',
     context_management: null,
@@ -978,6 +978,7 @@ test('Anthropic message_delta usage emits only output token totals', () => {
       cache_read_input_tokens: 13,
       server_tool_use: null,
       iterations: null,
+      output_tokens_details: null,
     },
   };
 
@@ -987,9 +988,13 @@ test('Anthropic message_delta usage emits only output token totals', () => {
   });
 
   expect(result?.chunk.usage_metadata).toEqual({
-    input_tokens: 0,
+    input_tokens: 267,
     output_tokens: 375,
-    total_tokens: 375,
+    total_tokens: 642,
+    input_token_details: {
+      cache_creation: 11,
+      cache_read: 13,
+    },
   });
 });
 
@@ -1002,6 +1007,7 @@ test('Anthropic stream usage does not double-count cumulative input tokens', asy
         container: null,
         context_management: null,
         content: [],
+        diagnostics: null,
         model: modelName,
         role: 'assistant',
         stop_details: null,
@@ -1010,15 +1016,16 @@ test('Anthropic stream usage does not double-count cumulative input tokens', asy
         type: 'message',
         usage: {
           cache_creation: null,
-          cache_creation_input_tokens: 0,
-          cache_read_input_tokens: 0,
+          cache_creation_input_tokens: 20,
+          cache_read_input_tokens: 30,
           inference_geo: null,
           input_tokens: 243,
           iterations: null,
-          output_tokens: 0,
+          output_tokens: 7,
           server_tool_use: null,
           service_tier: null,
           speed: null,
+          output_tokens_details: null,
         },
       },
     },
@@ -1034,10 +1041,11 @@ test('Anthropic stream usage does not double-count cumulative input tokens', asy
       usage: {
         input_tokens: 243,
         output_tokens: 375,
-        cache_creation_input_tokens: 0,
-        cache_read_input_tokens: 0,
+        cache_creation_input_tokens: 20,
+        cache_read_input_tokens: 30,
         server_tool_use: null,
         iterations: null,
+        output_tokens_details: null,
       },
     },
     { type: 'message_stop' },
@@ -1050,12 +1058,83 @@ test('Anthropic stream usage does not double-count cumulative input tokens', asy
   }
 
   expect(full?.usage_metadata).toEqual({
-    input_tokens: 243,
+    input_tokens: 293,
     output_tokens: 375,
-    total_tokens: 618,
+    total_tokens: 668,
     input_token_details: {
-      cache_creation: 0,
-      cache_read: 0,
+      cache_creation: 20,
+      cache_read: 30,
+    },
+    output_token_details: {},
+  });
+});
+
+test('Anthropic stream usage accepts input first reported at message_delta', async () => {
+  const events: AnthropicStreamEvent[] = [
+    {
+      type: 'message_start',
+      message: {
+        id: 'msg_late_input_usage',
+        container: null,
+        context_management: null,
+        content: [],
+        diagnostics: null,
+        model: modelName,
+        role: 'assistant',
+        stop_details: null,
+        stop_reason: null,
+        stop_sequence: null,
+        type: 'message',
+        usage: {
+          cache_creation: null,
+          cache_creation_input_tokens: 0,
+          cache_read_input_tokens: 0,
+          inference_geo: null,
+          input_tokens: 0,
+          iterations: null,
+          output_tokens: 0,
+          server_tool_use: null,
+          service_tier: null,
+          speed: null,
+          output_tokens_details: null,
+        },
+      },
+    },
+    {
+      type: 'message_delta',
+      context_management: null,
+      delta: {
+        container: null,
+        stop_details: null,
+        stop_reason: 'end_turn',
+        stop_sequence: null,
+      },
+      usage: {
+        input_tokens: 100,
+        output_tokens: 42,
+        cache_creation_input_tokens: 500,
+        cache_read_input_tokens: 200,
+        server_tool_use: null,
+        iterations: null,
+        output_tokens_details: null,
+      },
+    },
+    { type: 'message_stop' },
+  ];
+  const model = new MockStreamingAnthropic(events);
+
+  let full: AIMessageChunk | undefined;
+  for await (const chunk of await model.stream('hello')) {
+    full = !full ? chunk : concat(full, chunk);
+  }
+
+  expect(full?.usage_metadata).toEqual({
+    input_tokens: 800,
+    output_tokens: 42,
+    total_tokens: 842,
+    input_token_details: {
+      cache_creation: 500,
+      cache_read: 200,
     },
     output_token_details: {},
   });
@@ -1070,6 +1149,7 @@ test('Anthropic stream usage handles multiple cumulative message_delta events',
         container: null,
         context_management: null,
         content: [],
+        diagnostics: null,
         model: modelName,
         role: 'assistant',
         stop_details: null,
@@ -1083,10 +1163,11 @@ test('Anthropic stream usage handles multiple cumulative message_delta events',
           inference_geo: null,
           input_tokens: 243,
           iterations: null,
-          output_tokens: 0,
+          output_tokens: 7,
           server_tool_use: null,
           service_tier: null,
           speed: null,
+          output_tokens_details: null,
         },
       },
     },
@@ -1106,6 +1187,7 @@ test('Anthropic stream usage handles multiple cumulative message_delta events',
         cache_read_input_tokens: 0,
         server_tool_use: null,
         iterations: null,
+        output_tokens_details: null,
       },
     },
     {
@@ -1124,6 +1206,7 @@ test('Anthropic stream usage handles multiple cumulative message_delta events',
         cache_read_input_tokens: 0,
         server_tool_use: null,
         iterations: null,
+        output_tokens_details: null,
       },
     },
     { type: 'message_stop' },
@@ -1230,9 +1313,10 @@ test('Anthropic live stream usage matches raw cumulative output snapshots', asyn
   expect(model.messageDeltaOutputTokens.length).toBeGreaterThan(0);
   const rawOutputTokens =
     model.messageDeltaOutputTokens[model.messageDeltaOutputTokens.length - 1];
-  expect(full?.usage_metadata?.output_tokens).toBe(
-    model.messageStartOutputTokens + rawOutputTokens
+  expect(rawOutputTokens).toBeGreaterThanOrEqual(
+    model.messageStartOutputTokens
   );
+  expect(full?.usage_metadata?.output_tokens).toBe(rawOutputTokens);
   expect(full?.usage_metadata?.total_tokens).toBe(
     (full?.usage_metadata?.input_tokens ?? 0) +
       (full?.usage_metadata?.output_tokens ?? 0)
@@ -1244,7 +1328,7 @@ test('Anthropic live stream usage matches raw cumulative output snapshots', asyn
       0
     );
     expect(full?.usage_metadata?.output_tokens).toBeLessThan(
-      model.messageStartOutputTokens + summedOutputTokens
+      summedOutputTokens
     );
   }
 });

package/src/llm/anthropic/types.ts

@@ -61,6 +61,9 @@ export type AnthropicSearchResultBlockParam =
   Anthropic.Beta.BetaSearchResultBlockParam;
 export type AnthropicCompactionBlockParam =
   Anthropic.Beta.BetaCompactionBlockParam;
+export type AnthropicCompactionBlock = Anthropic.Beta.BetaCompactionBlock;
+export type AnthropicCompactionContentBlockDelta =
+  Anthropic.Beta.BetaCompactionContentBlockDelta;
 export type AnthropicOutputConfig = Anthropic.Messages.OutputConfig;
 export type ChatAnthropicOutputFormat = Anthropic.Messages.JSONOutputFormat;
 

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

@@ -0,0 +1,110 @@
+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 (Google → Anthropic): a Gemini
+ * turn that used a server-side tool (URL context, Google Search) leaves
+ * `toolCall`/`toolResponse` content blocks in history. The Anthropic converter
+ * has no branch for them and previously threw
+ * "Unsupported message content format", crashing the handoff. Only Google can
+ * execute these blocks or validate their thought signatures, so they are
+ * dropped on assistant turns; any other unknown block still throws.
+ */
+type AnthropicPayload = ReturnType<typeof _convertMessagesToAnthropicPayload>;
+
+/** Minimal view of a converted Anthropic content block the assertions read. */
+interface TestBlock {
+  type?: string;
+  text?: string;
+}
+
+const assistantBlocks = (payload: AnthropicPayload): TestBlock[] => {
+  const content = payload.messages.find((m) => m.role === 'assistant')?.content;
+  return Array.isArray(content) ? (content as TestBlock[]) : [];
+};
+
+describe('_convertMessagesToAnthropicPayload — Google server-side tool blocks', () => {
+  it('drops toolCall/toolResponse on an assistant turn, keeping text', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('summarize this article'),
+      new AIMessage({
+        content: [
+          {
+            type: 'toolCall',
+            thoughtSignature: 'google-signature-not-valid-for-anthropic',
+            toolCall: {
+              toolType: 'URL_CONTEXT',
+              args: { urls: ['https://example.com/report'] },
+              id: 'j7pfyr6k',
+            },
+          },
+          {
+            type: 'toolResponse',
+            toolResponse: {
+              toolType: 'URL_CONTEXT',
+              id: 'j7pfyr6k',
+              result: { status: 'SUCCESS' },
+            },
+          },
+          {
+            type: 'text',
+            text: 'The article argues for dollar-cost averaging.',
+          },
+        ],
+      }),
+    ];
+
+    expect(() => _convertMessagesToAnthropicPayload(messages)).not.toThrow();
+    const blocks = assistantBlocks(
+      _convertMessagesToAnthropicPayload(messages)
+    );
+
+    const serialized = JSON.stringify(blocks);
+    expect(serialized).not.toContain('URL_CONTEXT');
+    expect(serialized).not.toContain(
+      'google-signature-not-valid-for-anthropic'
+    );
+    expect(
+      blocks.some(
+        (b) =>
+          b.type === 'text' &&
+          b.text === 'The article argues for dollar-cost averaging.'
+      )
+    ).toBe(true);
+  });
+
+  it('emits a placeholder (not empty content) when a server-tool-only turn is fully dropped', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          {
+            type: 'toolCall',
+            toolCall: { toolType: 'URL_CONTEXT', args: { urls: [] }, id: 'x1' },
+          },
+        ],
+      }),
+    ];
+    expect(() => _convertMessagesToAnthropicPayload(messages)).not.toThrow();
+    const blocks = assistantBlocks(
+      _convertMessagesToAnthropicPayload(messages)
+    );
+    expect(blocks.length).toBeGreaterThan(0);
+  });
+
+  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(() => _convertMessagesToAnthropicPayload(messages)).toThrow(
+      'Unsupported message content format'
+    );
+  });
+});

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

@@ -473,6 +473,13 @@ function _formatContent(message: BaseMessage) {
    * forwarding an unusable block. The receiving model produces its own thinking.
    */
   const foreignReasoningTypes = ['reasoning_content', 'reasoning', 'think'];
+  /**
+   * Google server-side tool blocks (`toolCall`/`toolResponse` parts from e.g.
+   * URL context or Google Search). Only Google can execute these and validate
+   * their thought signatures, so they are dropped on a cross-provider handoff
+   * (e.g. Google → Anthropic); the assistant's answer text is kept.
+   */
+  const foreignServerToolTypes = ['toolCall', 'toolResponse'];
   const { content } = message;
 
   if (typeof content === 'string') {
@@ -482,8 +489,8 @@ function _formatContent(message: BaseMessage) {
     const contentBlocks = contentParts.map((contentPart) => {
       /**
        * Normalize server_tool_use blocks into a clean shape the API accepts.
-       * These blocks may arrive with the correct type (server_tool_use) or mislabeled
-       * as text/tool_use after chunk concatenation or state serialization.
+       * These blocks may arrive with the correct type (server_tool_use), as a
+       * standardized server_tool_call, or mislabeled after state serialization.
        * Regardless of current type, if the id starts with 'srvtoolu_' we rebuild
        * a clean block with only the properties the API expects.
        */
@@ -496,7 +503,7 @@ function _formatContent(message: BaseMessage) {
         'name' in contentPart
       ) {
         const rawPart = contentPart as Record<string, unknown>;
-        let input = rawPart.input;
+        let input = rawPart.input ?? rawPart.args;
         if (typeof input === 'string') {
           try {
             input = JSON.parse(input);
@@ -549,6 +556,60 @@ function _formatContent(message: BaseMessage) {
         return null;
       }
 
+      /**
+       * Native ChatModelStream output standardizes client tool uses as
+       * `tool_call` blocks. Convert those blocks back to Anthropic's wire shape
+       * before the generic content formatter sees them.
+       */
+      if (
+        contentPart.type === 'tool_call' &&
+        'id' in contentPart &&
+        typeof contentPart.id === 'string' &&
+        'name' in contentPart &&
+        typeof contentPart.name === 'string' &&
+        'args' in contentPart
+      ) {
+        let args = contentPart.args;
+        if (typeof args === 'string') {
+          try {
+            args = JSON.parse(args);
+          } catch {
+            args = {};
+          }
+        }
+        if (args == null || typeof args !== 'object' || Array.isArray(args)) {
+          args = {};
+        }
+        return _convertLangChainToolCallToAnthropic({
+          id: contentPart.id,
+          name: contentPart.name,
+          args: args as Record<string, unknown>,
+        });
+      }
+
+      /**
+       * Native Anthropic thinking is exposed through the standard reasoning
+       * stream, but its signature makes it safe and necessary to round-trip.
+       * Keep unsigned or cross-provider reasoning on the existing drop path.
+       */
+      if (
+        contentPart.type === 'reasoning' &&
+        isAIMessage(message) &&
+        message.response_metadata.model_provider === 'anthropic' &&
+        'reasoning' in contentPart &&
+        typeof contentPart.reasoning === 'string' &&
+        'signature' in contentPart &&
+        typeof contentPart.signature === 'string' &&
+        contentPart.signature !== ''
+      ) {
+        const block: AnthropicThinkingBlockParam = {
+          type: 'thinking',
+          thinking: contentPart.reasoning,
+          signature: contentPart.signature,
+        };
+        return block;
+      }
+
       /**
        * Skip non-server malformed blocks that have tool fields mixed with text type.
        */
@@ -665,6 +726,9 @@ function _formatContent(message: BaseMessage) {
         const block: AnthropicCompactionBlockParam = {
           type: 'compaction' as const,
           content: compactionPart.content,
+          ...('encrypted_content' in compactionPart
+            ? { encrypted_content: compactionPart.encrypted_content }
+            : {}),
           ...(cacheControl != null ? { cache_control: cacheControl } : {}),
         };
         return block;
@@ -798,6 +862,14 @@ function _formatContent(message: BaseMessage) {
         // dropped — as does any other unknown block (user media, Google
         // code-execution), which must be surfaced, not discarded.
         return null;
+      } else if (
+        isAIMessage(message) &&
+        foreignServerToolTypes.some((t) => t === contentPart.type)
+      ) {
+        // Google server-side tool call/response (e.g. URL context) — only
+        // Google can execute it or validate its thought signature; drop it
+        // on a cross-provider handoff rather than crash.
+        return null;
       } else {
         console.error(
           'Unsupported content part:',

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

@@ -9,7 +9,7 @@ import type { MessageContentComplex } from '@/types';
 import { toLangChainContent } from '@/messages/langchain';
 import { extractToolCalls } from './output_parsers';
 
-interface AnthropicUsageData {
+export interface AnthropicUsageData {
   input_tokens?: number | null;
   output_tokens?: number | null;
   cache_creation_input_tokens?: number | null;
@@ -92,7 +92,15 @@ export function _makeMessageChunkFromAnthropicEvent(
         context_management: data.delta.context_management,
       });
     }
-    const usageMetadata: UsageMetadata = {
+    const deltaUsage: AnthropicUsageData = data.usage;
+    const hasInputUsage =
+      deltaUsage.input_tokens != null ||
+      deltaUsage.cache_creation_input_tokens != null ||
+      deltaUsage.cache_read_input_tokens != null;
+    const cumulativeUsageMetadata = hasInputUsage
+      ? getAnthropicUsageMetadata(deltaUsage)
+      : undefined;
+    const usageMetadata: UsageMetadata = cumulativeUsageMetadata ?? {
       input_tokens: 0,
       output_tokens: data.usage.output_tokens,
       total_tokens: data.usage.output_tokens,