@librechat/agents 3.1.64 → 3.1.66-dev.0

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

@@ -0,0 +1,349 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import { _convertMessagesToAnthropicPayload } from './message_inputs';
+
+describe('_convertMessagesToAnthropicPayload — server tool use (web search) multi-turn', () => {
+  it('corrects tool_use blocks with srvtoolu_ IDs to server_tool_use', () => {
+    const messageHistory: BaseMessage[] = [
+      new HumanMessage('search for X and Y'),
+      new AIMessage({
+        content: [
+          { type: 'text', text: 'I will search for that.' },
+          {
+            type: 'tool_use',
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            input: { query: 'X' },
+          },
+          {
+            type: 'web_search_tool_result',
+            tool_use_id: 'srvtoolu_1',
+            content: [
+              {
+                type: 'web_search_result',
+                url: 'https://example.com',
+                title: 'Result',
+                encrypted_content: 'abc',
+                page_age: '1d',
+              },
+            ],
+          },
+          {
+            type: 'tool_use',
+            id: 'srvtoolu_2',
+            name: 'web_search',
+            input: { query: 'Y' },
+          },
+          {
+            type: 'web_search_tool_result',
+            tool_use_id: 'srvtoolu_2',
+            content: [
+              {
+                type: 'web_search_result',
+                url: 'https://example2.com',
+                title: 'Result 2',
+                encrypted_content: 'def',
+                page_age: '2d',
+              },
+            ],
+          },
+          { type: 'text', text: 'Here are the results.' },
+        ],
+        tool_calls: [
+          {
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            args: { query: 'X' },
+            type: 'tool_call',
+          },
+          {
+            id: 'srvtoolu_2',
+            name: 'web_search',
+            args: { query: 'Y' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new HumanMessage('follow up question'),
+    ];
+
+    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
+    expect(messages).toHaveLength(3);
+
+    const assistantContent = messages[1].content as any[];
+    const serverToolBlocks = assistantContent.filter(
+      (b: any) => b.type === 'server_tool_use'
+    );
+    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_')
+    );
+
+    expect(serverToolBlocks).toHaveLength(2);
+    expect(searchResultBlocks).toHaveLength(2);
+    expect(regularToolUseBlocks).toHaveLength(0);
+
+    // Verify blocks are clean (no extra streaming properties)
+    for (const b of serverToolBlocks) {
+      expect(Object.keys(b).sort()).toEqual(
+        ['id', 'input', 'name', 'type'].sort()
+      );
+    }
+    for (const b of searchResultBlocks) {
+      expect(Object.keys(b).sort()).toEqual(
+        ['content', 'tool_use_id', 'type'].sort()
+      );
+    }
+  });
+
+  it('corrects text-typed server tool blocks back to correct types', () => {
+    const messageHistory: BaseMessage[] = [
+      new HumanMessage('search for X'),
+      new AIMessage({
+        content: [
+          {
+            type: 'text',
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            input: '{"query":"X"}',
+          },
+          {
+            type: 'text',
+            tool_use_id: 'srvtoolu_1',
+            content: [
+              {
+                type: 'web_search_result',
+                url: 'https://example.com',
+                title: 'Result',
+                encrypted_content: 'abc',
+                page_age: '1d',
+              },
+            ],
+          },
+          { type: 'text', text: 'Found results.' },
+        ],
+        tool_calls: [
+          {
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            args: { query: 'X' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new HumanMessage('follow up'),
+    ];
+
+    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
+    const assistantContent = messages[1].content as any[];
+
+    expect(assistantContent[0]).toEqual({
+      type: 'server_tool_use',
+      id: 'srvtoolu_1',
+      name: 'web_search',
+      input: { query: 'X' },
+    });
+    expect(assistantContent[1].type).toBe('web_search_tool_result');
+    expect(assistantContent[1].tool_use_id).toBe('srvtoolu_1');
+    expect(assistantContent[2]).toEqual({
+      type: 'text',
+      text: 'Found results.',
+    });
+  });
+
+  it('filters server tool calls when content is a string', () => {
+    const messageHistory: BaseMessage[] = [
+      new HumanMessage('search for X'),
+      new AIMessage({
+        content: 'I searched and found results.',
+        tool_calls: [
+          {
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            args: { query: 'X' },
+            type: 'tool_call',
+          },
+          {
+            id: 'toolu_regular',
+            name: 'calculator',
+            args: { expr: '2+2' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new ToolMessage({
+        content: '4',
+        tool_call_id: 'toolu_regular',
+      }),
+      new HumanMessage('follow up'),
+    ];
+
+    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
+    const assistantContent = messages[1].content as any[];
+
+    const toolUseBlocks = assistantContent.filter(
+      (b: any) => b.type === 'tool_use'
+    );
+    expect(toolUseBlocks).toHaveLength(1);
+    expect(toolUseBlocks[0].id).toBe('toolu_regular');
+
+    const serverToolBlocks = assistantContent.filter((b: any) =>
+      b.id?.startsWith('srvtoolu_')
+    );
+    expect(serverToolBlocks).toHaveLength(0);
+  });
+
+  it('handles empty string content with only server tool calls', () => {
+    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 HumanMessage('follow up'),
+    ];
+
+    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
+    const assistantContent = messages[1].content as any[];
+    expect(assistantContent).toHaveLength(1);
+    expect(assistantContent[0].type).toBe('text');
+    expect(assistantContent[0].text).toBe(' ');
+  });
+
+  it('preserves regular tool_use blocks alongside corrected server tool blocks', () => {
+    const messageHistory: BaseMessage[] = [
+      new HumanMessage('search for X and calculate 2+2'),
+      new AIMessage({
+        content: [
+          { type: 'text', text: 'Let me help.' },
+          {
+            type: 'tool_use',
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            input: { query: 'X' },
+          },
+          {
+            type: 'web_search_tool_result',
+            tool_use_id: 'srvtoolu_1',
+            content: [
+              {
+                type: 'web_search_result',
+                url: 'https://example.com',
+                title: 'Result',
+                encrypted_content: 'abc',
+                page_age: '1d',
+              },
+            ],
+          },
+          {
+            type: 'tool_use',
+            id: 'toolu_calc',
+            name: 'calculator',
+            input: { expr: '2+2' },
+          },
+        ],
+        tool_calls: [
+          {
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            args: { query: 'X' },
+            type: 'tool_call',
+          },
+          {
+            id: 'toolu_calc',
+            name: 'calculator',
+            args: { expr: '2+2' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new ToolMessage({
+        content: '4',
+        tool_call_id: 'toolu_calc',
+      }),
+      new HumanMessage('follow up'),
+    ];
+
+    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
+    const assistantContent = messages[1].content as any[];
+
+    const serverToolUse = assistantContent.filter(
+      (b: any) => b.type === 'server_tool_use'
+    );
+    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_')
+    );
+
+    expect(serverToolUse).toHaveLength(1);
+    expect(serverToolUse[0].id).toBe('srvtoolu_1');
+    expect(webSearchResult).toHaveLength(1);
+    expect(regularToolUse).toHaveLength(1);
+    expect(regularToolUse[0].id).toBe('toolu_calc');
+  });
+
+  it('filters out empty text blocks from array content', () => {
+    const messageHistory: BaseMessage[] = [
+      new HumanMessage('search for X'),
+      new AIMessage({
+        content: [
+          { type: 'text', text: '' },
+          {
+            type: 'server_tool_use',
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            input: { query: 'X' },
+          },
+          {
+            type: 'web_search_tool_result',
+            tool_use_id: 'srvtoolu_1',
+            content: [
+              {
+                type: 'web_search_result',
+                url: 'https://example.com',
+                title: 'Result',
+                encrypted_content: 'abc',
+                page_age: '1d',
+              },
+            ],
+          },
+          { type: 'text', text: '' },
+          { type: 'text', text: 'Here are the results.' },
+        ],
+        tool_calls: [
+          {
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            args: { query: 'X' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new HumanMessage('follow up'),
+    ];
+
+    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
+    const assistantContent = messages[1].content as any[];
+
+    const emptyTextBlocks = assistantContent.filter(
+      (b: any) => b.type === 'text' && b.text === ''
+    );
+    expect(emptyTextBlocks).toHaveLength(0);
+
+    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/core.ts

@@ -41,7 +41,14 @@ User: ${userMessage[1]}
 const _allowedTypes = ['image_url', 'text', 'tool_use', 'tool_result'];
 const allowedTypesByProvider: Record<string, string[]> = {
   default: _allowedTypes,
-  [Providers.ANTHROPIC]: [..._allowedTypes, 'thinking', 'redacted_thinking'],
+  [Providers.ANTHROPIC]: [
+    ..._allowedTypes,
+    'thinking',
+    'redacted_thinking',
+    'server_tool_use',
+    'web_search_tool_result',
+    'web_search_result',
+  ],
   [Providers.BEDROCK]: [..._allowedTypes, 'reasoning_content'],
   [Providers.OPENAI]: _allowedTypes,
 };

package/src/messages/format.ts

@@ -797,18 +797,39 @@ function contentPartCharLength(part: MessageContentComplex): number {
   return len;
 }
 
+/** Extracts the skillName from a skill tool_call's args (string or object). */
+function extractSkillName(args: unknown): string | undefined {
+  let parsed: Record<string, unknown> | undefined;
+  if (typeof args === 'string') {
+    try {
+      parsed = JSON.parse(args) as Record<string, unknown>;
+    } catch {
+      /* malformed args — skip */
+    }
+  } else {
+    parsed = args as Record<string, unknown> | undefined;
+  }
+  const name = parsed?.skillName;
+  return typeof name === 'string' && name !== '' ? name : undefined;
+}
+
 /**
  * Formats an array of messages for LangChain, handling tool calls and creating ToolMessage instances.
  *
  * @param payload - The array of messages to format.
  * @param indexTokenCountMap - Optional map of message indices to token counts.
  * @param tools - Optional set of tool names that are allowed in the request.
+ * @param skills - Optional map of skill name to body for reconstructing skill HumanMessages.
  * @returns - Object containing formatted messages and updated indexTokenCountMap if provided.
  */
 export const formatAgentMessages = (
   payload: TPayload,
   indexTokenCountMap?: Record<number, number | undefined>,
-  tools?: Set<string>
+  tools?: Set<string>,
+  /** Pre-resolved skill bodies keyed by skill name. When present, HumanMessages
+   *  are reconstructed after skill ToolMessages to restore skill instructions
+   *  that were only in LangGraph state during the original run. */
+  skills?: Map<string, string>
 ): {
   messages: Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>;
   indexTokenCountMap?: Record<number, number>;
@@ -902,6 +923,7 @@ export const formatAgentMessages = (
      * - Dynamically expand the set when tool_search results are encountered
      */
     let processedMessage = message;
+    let pendingSkillNames: Set<string> | undefined;
     if (discoveredTools) {
       const content = message.content;
       if (content != null && Array.isArray(content)) {
@@ -950,8 +972,17 @@ export const formatAgentMessages = (
           }
 
           if (discoveredTools.has(toolName)) {
-            /** Valid tool - keep it */
             filteredContent.push(part);
+            if (
+              toolName === Constants.SKILL_TOOL &&
+              skills?.size != null &&
+              skills.size > 0
+            ) {
+              const skillName = extractSkillName(part.tool_call.args) ?? '';
+              if (skillName) {
+                (pendingSkillNames ??= new Set()).add(skillName);
+              }
+            }
           } else {
             /** Invalid tool - convert to string for context preservation */
             if (
@@ -1027,6 +1058,25 @@ export const formatAgentMessages = (
       }
     }
 
+    /** When tools filtering is off, still detect skill tool_calls for body reconstruction */
+    if (!discoveredTools && skills?.size != null && skills.size > 0) {
+      const content = processedMessage.content;
+      if (Array.isArray(content)) {
+        for (const part of content) {
+          if (
+            part.type !== ContentTypes.TOOL_CALL ||
+            part.tool_call?.name !== Constants.SKILL_TOOL
+          ) {
+            continue;
+          }
+          const skillName = extractSkillName(part.tool_call.args) ?? '';
+          if (skillName) {
+            (pendingSkillNames ??= new Set()).add(skillName);
+          }
+        }
+      }
+    }
+
     const formattedMessages = formatAssistantMessage(processedMessage);
     if (sourceMessageId != null && sourceMessageId !== '') {
       for (const formattedMessage of formattedMessages) {
@@ -1035,9 +1085,29 @@ export const formatAgentMessages = (
     }
     messages.push(...formattedMessages);
 
-    // Update the index mapping for this assistant message
-    // Store all indices that were created from this original message
+    // Capture index range BEFORE skill body injection so injected
+    // HumanMessages are excluded from the assistant's token distribution.
     const endMessageIndex = messages.length;
+
+    if (pendingSkillNames?.size != null && pendingSkillNames.size > 0) {
+      for (const skillName of pendingSkillNames) {
+        const body = skills?.get(skillName) ?? '';
+        if (body) {
+          messages.push(
+            new HumanMessage({
+              content: body,
+              additional_kwargs: {
+                role: 'user',
+                isMeta: true,
+                source: 'skill',
+                skillName,
+              },
+            })
+          );
+        }
+      }
+    }
+
     const resultIndices = [];
     for (let j = startMessageIndex; j < endMessageIndex; j++) {
       resultIndices.push(j);