@librechat/agents 3.1.78-dev.0 → 3.1.79

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

@@ -47,6 +47,8 @@ type GoogleFunctionCallBlock = MessageContentComplex & {
   };
 };
 
+const ANTHROPIC_EMPTY_TEXT_PLACEHOLDER = '_';
+
 function _formatImage(imageUrl: string) {
   const parsed = parseBase64DataUrl({ dataUrl: imageUrl });
   if (parsed) {
@@ -126,13 +128,15 @@ function _ensureMessageContents(
           );
         }
       } else {
+        const toolMessageContent = (
+          message as { content?: BaseMessage['content'] | null }
+        ).content;
         updatedMsgs.push(
           new HumanMessage({
             content: [
               {
                 type: 'tool_result',
-                // rare case: message.content could be undefined
-                ...(message.content != null
+                ...(toolMessageContent != null
                   ? { content: _formatContent(message) }
                   : {}),
                 tool_use_id: (message as ToolMessage).tool_call_id,
@@ -486,7 +490,7 @@ function _formatContent(message: BaseMessage) {
         return {
           type: 'image' as const, // Explicitly setting the type as "image"
           source,
-          ...(cacheControl ? { cache_control: cacheControl } : {}),
+          ...(cacheControl != null ? { cache_control: cacheControl } : {}),
         };
       } else if (isAnthropicImageBlockParam(contentPart)) {
         return contentPart;
@@ -494,7 +498,7 @@ function _formatContent(message: BaseMessage) {
         // PDF
         return {
           ...contentPart,
-          ...(cacheControl ? { cache_control: cacheControl } : {}),
+          ...(cacheControl != null ? { cache_control: cacheControl } : {}),
         };
       } else if (contentPart.type === 'thinking') {
         const thinkingPart = contentPart as AnthropicThinkingBlockParam;
@@ -502,7 +506,7 @@ function _formatContent(message: BaseMessage) {
           type: 'thinking' as const, // Explicitly setting the type as "thinking"
           thinking: thinkingPart.thinking,
           signature: thinkingPart.signature,
-          ...(cacheControl ? { cache_control: cacheControl } : {}),
+          ...(cacheControl != null ? { cache_control: cacheControl } : {}),
         };
         return block;
       } else if (contentPart.type === 'redacted_thinking') {
@@ -510,7 +514,7 @@ function _formatContent(message: BaseMessage) {
         const block: AnthropicRedactedThinkingBlockParam = {
           type: 'redacted_thinking' as const, // Explicitly setting the type as "redacted_thinking"
           data: redactedPart.data,
-          ...(cacheControl ? { cache_control: cacheControl } : {}),
+          ...(cacheControl != null ? { cache_control: cacheControl } : {}),
         };
         return block;
       } else if (contentPart.type === 'search_result') {
@@ -519,10 +523,11 @@ function _formatContent(message: BaseMessage) {
           type: 'search_result' as const,
           title: searchResultPart.title,
           source: searchResultPart.source,
-          ...('cache_control' in contentPart && contentPart.cache_control
+          ...('cache_control' in contentPart &&
+          contentPart.cache_control != null
             ? { cache_control: contentPart.cache_control }
             : {}),
-          ...('citations' in contentPart && contentPart.citations
+          ...('citations' in contentPart && contentPart.citations != null
             ? { citations: contentPart.citations }
             : {}),
           content: searchResultPart.content,
@@ -533,23 +538,23 @@ function _formatContent(message: BaseMessage) {
         const block: AnthropicCompactionBlockParam = {
           type: 'compaction' as const,
           content: compactionPart.content,
-          ...(cacheControl ? { cache_control: cacheControl } : {}),
+          ...(cacheControl != null ? { cache_control: cacheControl } : {}),
         };
         return block;
       } else if (
-        textTypes.find((t) => t === contentPart.type) &&
+        textTypes.some((t) => t === contentPart.type) &&
         'text' in contentPart
       ) {
         // Assuming contentPart is of type MessageContentText here
         return {
           type: 'text' as const, // Explicitly setting the type as "text"
           text: contentPart.text,
-          ...(cacheControl ? { cache_control: cacheControl } : {}),
-          ...('citations' in contentPart && contentPart.citations
+          ...(cacheControl != null ? { cache_control: cacheControl } : {}),
+          ...('citations' in contentPart && contentPart.citations != null
             ? { citations: contentPart.citations }
             : {}),
         };
-      } else if (toolTypes.find((t) => t === contentPart.type)) {
+      } else if (toolTypes.some((t) => t === contentPart.type)) {
         const contentPartCopy = { ...contentPart };
         if ('index' in contentPartCopy) {
           // Anthropic does not support passing the index field here, so we remove it.
@@ -593,12 +598,12 @@ function _formatContent(message: BaseMessage) {
         // TODO: Fix when SDK types are fixed
         return {
           ...contentPartCopy,
-          ...(cacheControl ? { cache_control: cacheControl } : {}),
+          ...(cacheControl != null ? { cache_control: cacheControl } : {}),
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
         } as any;
       } else if (
         'functionCall' in contentPart &&
-        contentPart.functionCall &&
+        contentPart.functionCall != null &&
         typeof contentPart.functionCall === 'object' &&
         isAIMessage(message)
       ) {
@@ -626,7 +631,7 @@ function _formatContent(message: BaseMessage) {
         throw new Error('Unsupported message content format');
       }
     });
-    return contentBlocks.filter(
+    const filteredContentBlocks = contentBlocks.filter(
       (block) =>
         block !== null &&
         !(
@@ -636,6 +641,9 @@ function _formatContent(message: BaseMessage) {
           block.text.trim() === ''
         )
     );
+    return filteredContentBlocks.length > 0
+      ? filteredContentBlocks
+      : [{ type: 'text' as const, text: ANTHROPIC_EMPTY_TEXT_PLACEHOLDER }];
   }
 }
 
@@ -670,9 +678,11 @@ export function _convertMessagesToAnthropicPayload(
     } else {
       throw new Error(`Message type "${message._getType()}" is not supported.`);
     }
-    if (isAIMessage(message) && !!message.tool_calls?.length) {
+    const isAI = isAIMessage(message);
+    const toolCalls = isAI ? (message.tool_calls ?? []) : [];
+    if (isAI && toolCalls.length > 0) {
       if (typeof message.content === 'string') {
-        const clientToolCalls = message.tool_calls.filter(
+        const clientToolCalls = toolCalls.filter(
           (tc) =>
             !(
               tc.id?.startsWith(Constants.ANTHROPIC_SERVER_TOOL_PREFIX) ?? false
@@ -684,7 +694,12 @@ export function _convertMessagesToAnthropicPayload(
             content:
               clientToolCalls.length > 0
                 ? clientToolCalls.map(_convertLangChainToolCallToAnthropic)
-                : [{ type: 'text' as const, text: ' ' }],
+                : [
+                  {
+                    type: 'text' as const,
+                    text: ANTHROPIC_EMPTY_TEXT_PLACEHOLDER,
+                  },
+                ],
           };
         } else {
           return {
@@ -697,7 +712,7 @@ export function _convertMessagesToAnthropicPayload(
         }
       } else {
         const { content } = message;
-        const hasMismatchedToolCalls = !message.tool_calls.every(
+        const hasMismatchedToolCalls = !toolCalls.every(
           (toolCall) =>
             !!content.find(
               (contentPart) =>
@@ -731,7 +746,7 @@ export function _convertMessagesToAnthropicPayload(
 }
 
 function mergeMessages(messages: AnthropicMessageCreateParams['messages']) {
-  if (!messages || messages.length <= 1) {
+  if (messages.length <= 1) {
     return messages;
   }
 

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

@@ -98,10 +98,6 @@ export function _makeMessageChunkFromAnthropicEvent(
       input_tokens: 0,
       output_tokens: data.usage.output_tokens,
       total_tokens: data.usage.output_tokens,
-      input_token_details: {
-        cache_creation: data.usage.cache_creation_input_tokens ?? undefined,
-        cache_read: data.usage.cache_read_input_tokens ?? undefined,
-      },
     };
     return {
       chunk: new AIMessageChunk({

package/src/llm/anthropic/utils/server-tool-inputs.test.ts

@@ -3,6 +3,14 @@ import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
 import type { BaseMessage } from '@langchain/core/messages';
 import { _convertMessagesToAnthropicPayload } from './message_inputs';
 
+type AnthropicTestBlock = {
+  id?: unknown;
+  type?: unknown;
+};
+
+const isServerToolId = (id: unknown): id is string =>
+  typeof id === 'string' && id.startsWith('srvtoolu_');
+
 describe('_convertMessagesToAnthropicPayload — server tool use (web search) multi-turn', () => {
   it('corrects tool_use blocks with srvtoolu_ IDs to server_tool_use', () => {
     const messageHistory: BaseMessage[] = [
@@ -78,9 +86,10 @@ describe('_convertMessagesToAnthropicPayload — server tool use (web search) mu
     const searchResultBlocks = assistantContent.filter(
       (b: any) => b.type === 'web_search_tool_result'
     );
-    const regularToolUseBlocks = assistantContent.filter(
-      (b: any) => b.type === 'tool_use' && b.id?.startsWith('srvtoolu_')
-    );
+    const regularToolUseBlocks = assistantContent.filter((block: unknown) => {
+      const b = block as AnthropicTestBlock;
+      return b.type === 'tool_use' && isServerToolId(b.id);
+    });
 
     expect(serverToolBlocks).toHaveLength(2);
     expect(searchResultBlocks).toHaveLength(2);
@@ -190,9 +199,10 @@ describe('_convertMessagesToAnthropicPayload — server tool use (web search) mu
     expect(toolUseBlocks).toHaveLength(1);
     expect(toolUseBlocks[0].id).toBe('toolu_regular');
 
-    const serverToolBlocks = assistantContent.filter((b: any) =>
-      b.id?.startsWith('srvtoolu_')
-    );
+    const serverToolBlocks = assistantContent.filter((block: unknown) => {
+      const b = block as AnthropicTestBlock;
+      return isServerToolId(b.id);
+    });
     expect(serverToolBlocks).toHaveLength(0);
   });
 
@@ -217,7 +227,80 @@ describe('_convertMessagesToAnthropicPayload — server tool use (web search) mu
     const assistantContent = messages[1].content as any[];
     expect(assistantContent).toHaveLength(1);
     expect(assistantContent[0].type).toBe('text');
-    expect(assistantContent[0].text).toBe(' ');
+    expect(assistantContent[0].text).toBe('_');
+    expect(assistantContent[0].text.trim()).toBe('_');
+  });
+
+  it('uses non-whitespace fallback content after filtering empty array text', () => {
+    const messageHistory: BaseMessage[] = [
+      new HumanMessage({
+        content: [
+          { type: 'text', text: ' ' },
+          { type: 'text', text: '\n' },
+        ],
+      }),
+    ];
+
+    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
+    expect(messages[0].content).toEqual([{ type: 'text', text: '_' }]);
+  });
+
+  it('uses non-whitespace fallback content for empty server tool result artifacts', () => {
+    const messageHistory: BaseMessage[] = [
+      new HumanMessage('search for X'),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            args: { query: 'X' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new ToolMessage({
+        content: '',
+        tool_call_id: 'srvtoolu_1',
+      }),
+      new HumanMessage('follow up'),
+    ];
+
+    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
+
+    expect(messages[1].content).toEqual([{ type: 'text', text: '_' }]);
+    expect(messages[2].content).toEqual([{ type: 'text', text: '_' }]);
+  });
+
+  it('does not throw when a non-string ToolMessage has undefined content', () => {
+    const undefinedContentToolMessage = {
+      _getType: (): 'tool' => 'tool',
+      content: undefined,
+      tool_call_id: 'toolu_calc',
+    } as unknown as ToolMessage;
+    const messageHistory: BaseMessage[] = [
+      new HumanMessage('call the calculator'),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'toolu_calc',
+            name: 'calculator',
+            args: { expr: '2+2' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      undefinedContentToolMessage,
+    ];
+
+    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
+    expect(messages[2].content).toEqual([
+      {
+        type: 'tool_result',
+        tool_use_id: 'toolu_calc',
+      },
+    ]);
   });
 
   it('preserves regular tool_use blocks alongside corrected server tool blocks', () => {
@@ -283,9 +366,10 @@ describe('_convertMessagesToAnthropicPayload — server tool use (web search) mu
     const webSearchResult = assistantContent.filter(
       (b: any) => b.type === 'web_search_tool_result'
     );
-    const regularToolUse = assistantContent.filter(
-      (b: any) => b.type === 'tool_use' && !b.id?.startsWith('srvtoolu_')
-    );
+    const regularToolUse = assistantContent.filter((block: unknown) => {
+      const b = block as AnthropicTestBlock;
+      return b.type === 'tool_use' && !isServerToolId(b.id);
+    });
 
     expect(serverToolUse).toHaveLength(1);
     expect(serverToolUse[0].id).toBe('srvtoolu_1');
@@ -416,9 +500,7 @@ describe('_convertMessagesToAnthropicPayload — server tool use (web search) mu
       );
       expect(whitespaceTextBlocks).toHaveLength(0);
 
-      const textBlocks = assistantContent.filter(
-        (b: any) => b.type === 'text'
-      );
+      const textBlocks = assistantContent.filter((b: any) => b.type === 'text');
       expect(textBlocks).toHaveLength(1);
       expect(textBlocks[0].text).toBe('Here are the results.');
     }

package/src/messages/__tests__/anthropicToolCache.test.ts

@@ -5,6 +5,7 @@ import {
   makeIsDeferred,
   partitionAndMarkAnthropicToolCache,
 } from '../anthropicToolCache';
+import { CustomAnthropic } from '@/llm/anthropic';
 
 function fakeTool(name: string): unknown {
   return tool(async () => 'ok', {
@@ -86,6 +87,51 @@ describe('partitionAndMarkAnthropicToolCache', () => {
     expect(out[0].extras?.cache_control).toEqual({ type: 'ephemeral' });
   });
 
+  it('stamps Anthropic built-in tools with direct cache_control', () => {
+    const webSearch = {
+      type: 'web_search_20250305',
+      name: 'web_search',
+      max_uses: 3,
+    };
+    const out = partitionAndMarkAnthropicToolCache(
+      [webSearch] as never,
+      () => false
+    ) as Array<{
+      cache_control?: { type: string };
+      extras?: { cache_control?: { type: string } };
+    }>;
+
+    expect(out[0]).not.toBe(webSearch);
+    expect(out[0].cache_control).toEqual({ type: 'ephemeral' });
+    expect(out[0].extras).toBeUndefined();
+  });
+
+  it('does not serialize extras on Anthropic built-in tools', () => {
+    const model = new CustomAnthropic({
+      model: 'claude-haiku-4-5',
+      apiKey: 'testing',
+    });
+    const webSearch = {
+      type: 'web_search_20250305',
+      name: 'web_search',
+      max_uses: 3,
+    };
+    const tools = partitionAndMarkAnthropicToolCache(
+      [webSearch] as never,
+      () => false
+    );
+    const formattedTools = model.formatStructuredToolToAnthropic(tools);
+    const formatted = formattedTools?.[0];
+
+    expect(formatted).toEqual({
+      type: 'web_search_20250305',
+      name: 'web_search',
+      max_uses: 3,
+      cache_control: { type: 'ephemeral' },
+    });
+    expect(formatted).not.toHaveProperty('extras');
+  });
+
   it('is idempotent when re-marking a tool that already has the marker', () => {
     const a = fakeTool('a-static') as { extras?: Record<string, unknown> };
     a.extras = { cache_control: { type: 'ephemeral' } };

package/src/messages/anthropicToolCache.ts

@@ -19,14 +19,74 @@
  * the breakpoint.
  *
  * LangChain's Anthropic adapter passes the marker through via
- * `tool.extras.cache_control` (`AnthropicToolExtrasSchema`), so we set
- * it as an `extras` field on a fresh wrapper around the tool — never
- * mutating the original tool instance, since callers may share them
+ * `tool.extras.cache_control` for custom tools, while Anthropic built-ins
+ * require direct `cache_control`. Either way, we stamp a fresh wrapper —
+ * never mutating the original tool instance, since callers may share them
  * across runs.
  */
 
 import type { GraphTools } from '@/types';
 
+const ANTHROPIC_BUILT_IN_TOOL_PREFIXES = [
+  'text_editor_',
+  'computer_',
+  'bash_',
+  'web_search_',
+  'web_fetch_',
+  'str_replace_editor_',
+  'str_replace_based_edit_tool_',
+  'code_execution_',
+  'memory_',
+  'tool_search_',
+  'mcp_toolset',
+] as const;
+
+const CACHE_CONTROL = { type: 'ephemeral' as const };
+
+type AnthropicToolCacheCandidate = {
+  name?: unknown;
+  type?: unknown;
+  extras?: Record<string, unknown>;
+  cache_control?: unknown;
+};
+
+function isAnthropicBuiltInTool(
+  tool: AnthropicToolCacheCandidate
+): tool is AnthropicToolCacheCandidate & { type: string } {
+  const { type } = tool;
+  return (
+    typeof type === 'string' &&
+    ANTHROPIC_BUILT_IN_TOOL_PREFIXES.some((prefix) => type.startsWith(prefix))
+  );
+}
+
+function hasCacheControl(tool: AnthropicToolCacheCandidate): boolean {
+  if (isAnthropicBuiltInTool(tool)) {
+    return tool.cache_control != null;
+  }
+  return tool.extras?.cache_control != null;
+}
+
+function markCacheControl(
+  tool: AnthropicToolCacheCandidate
+): AnthropicToolCacheCandidate {
+  const prototype = Object.getPrototypeOf(tool) ?? Object.prototype;
+  if (isAnthropicBuiltInTool(tool)) {
+    const wrapped = { ...tool };
+    delete wrapped.extras;
+    return Object.assign(Object.create(prototype), wrapped, {
+      cache_control: CACHE_CONTROL,
+    });
+  }
+
+  return Object.assign(Object.create(prototype), tool, {
+    extras: {
+      ...(tool.extras ?? {}),
+      cache_control: CACHE_CONTROL,
+    },
+  });
+}
+
 /**
  * Returns a callable that reports whether a given tool *name* is deferred
  * according to the supplied registry of tool definitions. Tools without
@@ -59,8 +119,8 @@ export function makeIsDeferred(
  *
  * The original tool instances are never mutated. The marked entry is a
  * shallow wrapper that preserves the prototype chain so downstream
- * `instanceof` checks still pass. `extras` is merged so any existing
- * `providerToolDefinition` / other extras the host attached are kept.
+ * `instanceof` checks still pass. For custom tools, `extras` is merged
+ * so any existing `providerToolDefinition` / other extras are kept.
  */
 export function partitionAndMarkAnthropicToolCache(
   tools: GraphTools | undefined,
@@ -87,30 +147,15 @@ export function partitionAndMarkAnthropicToolCache(
     return tools;
   }
 
-  const last = staticTools[staticTools.length - 1] as {
-    extras?: Record<string, unknown>;
-  };
+  const last = staticTools[
+    staticTools.length - 1
+  ] as AnthropicToolCacheCandidate;
   // Already marked? Don't double-clone.
-  if (
-    last.extras != null &&
-    'cache_control' in last.extras &&
-    (last.extras as { cache_control?: unknown }).cache_control != null
-  ) {
+  if (hasCacheControl(last)) {
     if (deferredTools.length === 0) return tools;
     return [...staticTools, ...deferredTools] as GraphTools;
   }
 
-  const wrapped = Object.assign(
-    Object.create(Object.getPrototypeOf(last) ?? Object.prototype),
-    last,
-    {
-      extras: {
-        ...((last.extras as Record<string, unknown> | undefined) ?? {}),
-        cache_control: { type: 'ephemeral' as const },
-      },
-    }
-  );
-
-  staticTools[staticTools.length - 1] = wrapped;
+  staticTools[staticTools.length - 1] = markCacheControl(last);
   return [...staticTools, ...deferredTools] as GraphTools;
 }