@librechat/agents 3.2.63 → 3.2.65

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/message_inputs.ts

@@ -482,8 +482,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 +496,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 +549,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 +719,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;

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,