@librechat/agents 3.1.78 → 3.1.80-dev.0

package/src/messages/format.ts

@@ -285,6 +285,7 @@ export const formatFromLangChain = (
 
 interface FormatAssistantMessageOptions {
   preserveReasoningContent?: boolean;
+  provider?: Providers;
 }
 
 interface FormatAgentMessagesOptions {
@@ -316,6 +317,60 @@ function extractReasoningContent(
   return '';
 }
 
+type ServerToolInput = Exclude<NonNullable<ToolCallPart['args']>, string>;
+
+function parseServerToolInput(args: ToolCallPart['args']): ServerToolInput {
+  if (typeof args === 'string') {
+    try {
+      const parsed = JSON.parse(args) as unknown;
+      return parsed != null &&
+        typeof parsed === 'object' &&
+        !Array.isArray(parsed)
+        ? (parsed as ServerToolInput)
+        : {};
+    } catch {
+      return {};
+    }
+  }
+  return args != null && typeof args === 'object' ? args : {};
+}
+
+function getTextContent(part: MessageContentComplex): string {
+  const { text } = part as { text?: unknown };
+  return typeof text === 'string' ? text : '';
+}
+
+function hasMeaningfulAssistantContent(part: MessageContentComplex): boolean {
+  if (part.type === ContentTypes.TEXT) {
+    return getTextContent(part).trim().length > 0;
+  }
+  if (
+    part.type === ContentTypes.TOOL_CALL ||
+    part.type === ContentTypes.ERROR ||
+    part.type === ContentTypes.AGENT_UPDATE ||
+    part.type === ContentTypes.SUMMARY
+  ) {
+    return false;
+  }
+  if (
+    part.type === ContentTypes.THINK ||
+    part.type === ContentTypes.THINKING ||
+    part.type === ContentTypes.REASONING ||
+    part.type === ContentTypes.REASONING_CONTENT ||
+    part.type === 'redacted_thinking'
+  ) {
+    return extractReasoningContent(part).trim().length > 0;
+  }
+  return part.type != null && part.type !== '';
+}
+
+function getToolUseId(part: MessageContentComplex): string | undefined {
+  if (!('tool_use_id' in part) || typeof part.tool_use_id !== 'string') {
+    return undefined;
+  }
+  return part.tool_use_id;
+}
+
 /**
  * Helper function to format an assistant message
  * @param message The message to format
@@ -331,6 +386,8 @@ function formatAssistantMessage(
   let lastAIMessage: AIMessage | null = null;
   let hasReasoning = false;
   let pendingReasoningContent = '';
+  const emittedServerToolUseIds = new Set<string>();
+  const pendingServerToolUses = new Map<string, MessageContentComplex>();
   const shouldPreserveReasoningContent =
     options?.preserveReasoningContent === true;
 
@@ -364,13 +421,32 @@ function formatAssistantMessage(
         : reasoningContent;
   };
 
+  const flushPendingServerToolUse = (toolUseId: string): void => {
+    for (const [id, content] of pendingServerToolUses) {
+      pendingServerToolUses.delete(id);
+      if (id === toolUseId) {
+        currentContent.push(content);
+        emittedServerToolUseIds.add(id);
+        return;
+      }
+    }
+  };
+
   if (Array.isArray(message.content)) {
-    for (const part of message.content as Array<
+    const contentParts = message.content as Array<
       MessageContentComplex | undefined | null
-    >) {
+    >;
+
+    for (const part of contentParts) {
       if (part == null) {
         continue;
       }
+      const toolUseId = getToolUseId(part);
+      if (toolUseId != null) {
+        flushPendingServerToolUse(toolUseId);
+      } else if (hasMeaningfulAssistantContent(part)) {
+        pendingServerToolUses.clear();
+      }
       if (part.type === ContentTypes.TEXT && part.tool_call_ids) {
         /*
         If there's pending content, it needs to be aggregated as a single string to prepare for tool calls.
@@ -379,19 +455,18 @@ function formatAssistantMessage(
         if (currentContent.length > 0) {
           let content = currentContent.reduce((acc, curr) => {
             if (curr.type === ContentTypes.TEXT) {
-              return `${acc}${String(curr[ContentTypes.TEXT] ?? '')}\n`;
+              return `${acc}${getTextContent(curr)}\n`;
             }
             return acc;
           }, '');
-          content =
-            `${content}\n${part[ContentTypes.TEXT] ?? part.text ?? ''}`.trim();
+          content = `${content}\n${getTextContent(part)}`.trim();
           lastAIMessage = createAIMessage(content);
           formattedMessages.push(lastAIMessage);
           currentContent = [];
           continue;
         }
         // Create a new AIMessage with this text and prepare for tool calls
-        lastAIMessage = createAIMessage(part.text != null ? part.text : '');
+        lastAIMessage = createAIMessage(getTextContent(part));
         formattedMessages.push(lastAIMessage);
       } else if (part.type === ContentTypes.TOOL_CALL) {
         // Skip malformed tool call entries without tool_call property
@@ -414,6 +489,26 @@ function formatAssistantMessage(
           continue;
         }
 
+        if (
+          options?.provider === Providers.ANTHROPIC &&
+          typeof _tool_call.id === 'string' &&
+          _tool_call.id.startsWith(Constants.ANTHROPIC_SERVER_TOOL_PREFIX)
+        ) {
+          if (
+            emittedServerToolUseIds.has(_tool_call.id) ||
+            pendingServerToolUses.has(_tool_call.id)
+          ) {
+            continue;
+          }
+          pendingServerToolUses.set(_tool_call.id, {
+            type: 'server_tool_use',
+            id: _tool_call.id,
+            name: _tool_call.name,
+            input: parseServerToolInput(_args),
+          } as MessageContentComplex);
+          continue;
+        }
+
         if (!lastAIMessage) {
           // "Heal" the payload by creating an AIMessage to precede the tool call
           lastAIMessage = createAIMessage('');
@@ -465,26 +560,29 @@ function formatAssistantMessage(
       ) {
         continue;
       } else {
-        if (
-          part.type === ContentTypes.TEXT &&
-          !String(part.text ?? '').trim()
-        ) {
+        if (part.type === ContentTypes.TEXT && !getTextContent(part).trim()) {
           continue;
         }
         currentContent.push(part);
       }
     }
+    for (const content of pendingServerToolUses.values()) {
+      currentContent.push(content);
+    }
   }
 
   if (hasReasoning && currentContent.length > 0) {
-    const content = currentContent
-      .reduce((acc, curr) => {
-        if (curr.type === ContentTypes.TEXT) {
-          return `${acc}${String(curr[ContentTypes.TEXT] ?? '')}\n`;
-        }
-        return acc;
-      }, '')
-      .trim();
+    let content = '';
+    for (const part of currentContent) {
+      if (part.type !== ContentTypes.TEXT) {
+        formattedMessages.push(
+          createAIMessage(toLangChainContent(currentContent))
+        );
+        return formattedMessages;
+      }
+      content += `${getTextContent(part)}\n`;
+    }
+    content = content.trim();
 
     if (content) {
       formattedMessages.push(createAIMessage(content));
@@ -1157,6 +1255,7 @@ export const formatAgentMessages = (
 
     const formattedMessages = formatAssistantMessage(processedMessage, {
       preserveReasoningContent: options?.provider === Providers.DEEPSEEK,
+      provider: options?.provider,
     });
     if (sourceMessageId != null && sourceMessageId !== '') {
       for (const formattedMessage of formattedMessages) {

package/src/messages/formatAgentMessages.test.ts

@@ -6,7 +6,8 @@ import {
 } from '@langchain/core/messages';
 import type { MessageContentComplex, TPayload } from '@/types';
 import { formatAgentMessages } from './format';
-import { ContentTypes, Providers } from '@/common';
+import { _convertMessagesToAnthropicPayload } from '@/llm/anthropic/utils/message_inputs';
+import { Constants, ContentTypes, Providers } from '@/common';
 
 describe('formatAgentMessages', () => {
   it('should format simple user and AI messages', () => {
@@ -183,6 +184,206 @@ describe('formatAgentMessages', () => {
     expect((result.messages[1] as ToolMessage).tool_call_id).toBe('123');
   });
 
+  it('skips persisted Anthropic server tool calls from web search turns', () => {
+    const payload: TPayload = [
+      {
+        role: 'user',
+        content:
+          'who is the lowest seed survived in 2026 nba playoffs, only the team name, nothing else',
+      },
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: `${Constants.ANTHROPIC_SERVER_TOOL_PREFIX}web_search`,
+              name: 'web_search',
+              args: '{"query":"2026 NBA playoffs lowest seed survived"}',
+            },
+          },
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Philadelphia 76ers',
+          },
+        ],
+      },
+      {
+        role: 'user',
+        content: 'who are 76ers\' opponents in current series?',
+      },
+    ];
+
+    const result = formatAgentMessages(
+      payload,
+      undefined,
+      new Set(['web_search']),
+      undefined,
+      { provider: Providers.ANTHROPIC }
+    );
+
+    expect(result.messages).toHaveLength(3);
+    expect(result.messages[1]).toBeInstanceOf(AIMessage);
+    expect(
+      result.messages.some((message) => message instanceof ToolMessage)
+    ).toBe(false);
+    expect((result.messages[1] as AIMessage).tool_calls).toHaveLength(0);
+    expect(result.messages[1].content).toEqual([
+      {
+        type: ContentTypes.TEXT,
+        [ContentTypes.TEXT]: 'Philadelphia 76ers',
+      },
+    ]);
+  });
+
+  it('preserves paused Anthropic server tool calls without creating ToolMessages', () => {
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: `${Constants.ANTHROPIC_SERVER_TOOL_PREFIX}paused`,
+              name: 'web_search',
+              args: '{"query":"latest Anthropic server tools"}',
+            },
+          },
+        ],
+      },
+    ];
+
+    const result = formatAgentMessages(
+      payload,
+      undefined,
+      new Set(['web_search']),
+      undefined,
+      { provider: Providers.ANTHROPIC }
+    );
+    const anthropicPayload = _convertMessagesToAnthropicPayload(
+      result.messages
+    );
+
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0]).toBeInstanceOf(AIMessage);
+    expect(result.messages.some((message) => message instanceof ToolMessage))
+      .toBe(false);
+    expect((result.messages[0] as AIMessage).tool_calls).toHaveLength(0);
+    expect(result.messages[0].content).toEqual([
+      {
+        type: 'server_tool_use',
+        id: `${Constants.ANTHROPIC_SERVER_TOOL_PREFIX}paused`,
+        name: 'web_search',
+        input: { query: 'latest Anthropic server tools' },
+      },
+    ]);
+    expect(anthropicPayload.messages[0].content).toEqual([
+      {
+        type: 'server_tool_use',
+        id: `${Constants.ANTHROPIC_SERVER_TOOL_PREFIX}paused`,
+        name: 'web_search',
+        input: { query: 'latest Anthropic server tools' },
+      },
+    ]);
+  });
+
+  it('keeps srvtoolu tool calls portable for non-Anthropic providers', () => {
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: `${Constants.ANTHROPIC_SERVER_TOOL_PREFIX}paused`,
+              name: 'web_search',
+              args: '{"query":"latest Anthropic server tools"}',
+            },
+          },
+        ],
+      },
+    ];
+
+    const result = formatAgentMessages(
+      payload,
+      undefined,
+      new Set(['web_search']),
+      undefined,
+      { provider: Providers.OPENAI }
+    );
+
+    expect(result.messages).toHaveLength(2);
+    expect(result.messages[0]).toBeInstanceOf(AIMessage);
+    expect(result.messages[1]).toBeInstanceOf(ToolMessage);
+    expect(result.messages[0].content).toBe('');
+    expect((result.messages[0] as AIMessage).tool_calls).toEqual([
+      {
+        id: `${Constants.ANTHROPIC_SERVER_TOOL_PREFIX}paused`,
+        name: 'web_search',
+        args: { query: 'latest Anthropic server tools' },
+      },
+    ]);
+    expect((result.messages[1] as ToolMessage).tool_call_id).toBe(
+      `${Constants.ANTHROPIC_SERVER_TOOL_PREFIX}paused`
+    );
+  });
+
+  it('does not emit empty Anthropic payload content for persisted web search turns', () => {
+    const payload: TPayload = [
+      {
+        role: 'user',
+        content:
+          'who is the lowest seed survived in 2026 nba playoffs, only the team name, nothing else',
+      },
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: `${Constants.ANTHROPIC_SERVER_TOOL_PREFIX}web_search`,
+              name: 'web_search',
+              args: '{"query":"2026 NBA playoffs lowest seed survived"}',
+            },
+          },
+          {
+            type: ContentTypes.TEXT,
+            text: 'Philadelphia 76ers',
+          },
+        ],
+      },
+      {
+        role: 'user',
+        content: 'who are 76ers\' opponents in current series?',
+      },
+    ];
+
+    const { messages } = formatAgentMessages(
+      payload,
+      undefined,
+      new Set(['web_search']),
+      undefined,
+      { provider: Providers.ANTHROPIC }
+    );
+    const anthropicPayload = _convertMessagesToAnthropicPayload(messages);
+
+    expect(anthropicPayload.messages).toHaveLength(3);
+    for (const message of anthropicPayload.messages) {
+      expect(Array.isArray(message.content)).toBe(true);
+      const content = message.content as Array<{
+        text?: unknown;
+        type: string;
+      }>;
+      expect(content.length).toBeGreaterThan(0);
+      for (const block of content) {
+        if (block.type === ContentTypes.TEXT) {
+          expect(typeof block.text).toBe('string');
+          expect((block.text as string).trim().length).toBeGreaterThan(0);
+        }
+      }
+    }
+  });
+
   it('should handle malformed tool call entries with missing tool_call property', () => {
     const tools = new Set(['search']);
     const payload = [

package/src/scripts/code_exec_multi_session.ts

@@ -46,7 +46,7 @@ function printSessionContext(run: Run<t.IState>, label: string): void {
   console.log(`  Latest session_id: ${session.session_id}`);
   console.log(`  Files tracked: ${session.files?.length ?? 0}`);
   for (const file of session.files ?? []) {
-    console.log(`    - ${file.name} (session: ${file.session_id})`);
+    console.log(`    - ${file.name} (storage: ${file.storage_session_id})`);
   }
 }
 
@@ -200,13 +200,13 @@ Tell me what version it shows.
 
   if (finalSession) {
     const files = finalSession.files ?? [];
-    const uniqueSessionIds = new Set(files.map((f) => f.session_id));
+    const uniqueSessionIds = new Set(files.map((f) => f.storage_session_id));
     console.log(`\nTotal files tracked: ${files.length}`);
-    console.log(`Unique session_ids: ${uniqueSessionIds.size}`);
+    console.log(`Unique storage_session_ids: ${uniqueSessionIds.size}`);
     console.log('\nFiles:');
     for (const file of files) {
       console.log(
-        `  - ${file.name} (session: ${file.session_id?.slice(0, 20)}...)`
+        `  - ${file.name} (storage: ${file.storage_session_id?.slice(0, 20)}...)`
       );
     }
 

package/src/specs/summarization.test.ts

@@ -428,7 +428,7 @@ const hasAnthropic = process.env.ANTHROPIC_API_KEY != null;
 
     // Turn 7: absolute minimum context if still nothing
     if (spies.onSummarizeStartSpy.mock.calls.length === 0) {
-      ({ run, contentParts } = await createRun(3100));
+      ({ run, contentParts } = await createRun(2200));
       await runTurn({ run, conversationHistory }, 'What is 1+1?', streamConfig);
       logTurn('T7', conversationHistory);
     }
@@ -722,7 +722,7 @@ const hasAnthropic = process.env.ANTHROPIC_API_KEY != null;
     }
 
     if (spies.onSummarizeStartSpy.mock.calls.length === 0) {
-      run = await createRun(2800);
+      run = await createRun(1000);
       await runTurn(
         { run, conversationHistory },
         'What is 9 * 9? Calculator.',
@@ -876,7 +876,7 @@ const hasAnthropic = process.env.ANTHROPIC_API_KEY != null;
 
     // Turn 6: squeeze harder if needed
     if (spies.onSummarizeStartSpy.mock.calls.length === 0) {
-      ({ run, contentParts } = await createRun(2000));
+      ({ run, contentParts } = await createRun(1000));
       await runTurn(
         { run, conversationHistory },
         'What is 42 * 42? Use the calculator.',

package/src/tools/BashExecutor.ts

@@ -163,7 +163,10 @@ function createBashExecutionTool(
               const id = nameParts.length > 1 ? nameParts[1].split('.')[0] : '';
 
               return {
-                session_id,
+                storage_session_id: session_id,
+                /* `/files` fallback returns code-output files belonging
+                 * to the user; tag them user-private. */
+                kind: 'user' as const,
                 id,
                 name: file.metadata['original-filename'],
               };
@@ -241,11 +244,16 @@ function createBashExecutionTool(
             {
               session_id: result.session_id,
               files: result.files,
-            },
+            } satisfies t.CodeExecutionArtifact,
           ];
         }
 
-        return [formattedOutput.trim(), { session_id: result.session_id }];
+        return [
+          formattedOutput.trim(),
+          {
+            session_id: result.session_id,
+          } satisfies t.CodeExecutionArtifact,
+        ];
       } catch (error) {
         throw new Error(
           `Execution error:\n\n${(error as Error | undefined)?.message}`

package/src/tools/BashProgrammaticToolCalling.ts

@@ -252,12 +252,12 @@ export function createBashProgrammaticToolCallingTool(
       const params = rawParams as { code: string; timeout?: number };
       const { code, timeout = DEFAULT_TIMEOUT } = params;
 
-      const { toolMap, toolDefs, session_id, _injected_files } =
-        (config.toolCall ?? {}) as ToolCall &
-          Partial<t.ProgrammaticCache> & {
-            session_id?: string;
-            _injected_files?: t.CodeEnvFile[];
-          };
+      const toolCall = (config.toolCall ?? {}) as ToolCall &
+        Partial<t.ProgrammaticCache> & {
+          session_id?: string;
+          _injected_files?: t.CodeEnvFile[];
+        };
+      const { toolMap, toolDefs, session_id, _injected_files } = toolCall;
 
       if (toolMap == null || toolMap.size === 0) {
         throw new Error(

package/src/tools/CodeExecutor.ts

@@ -135,8 +135,8 @@ function createCodeExecutionTool(
       };
       /**
        * Extract session context from config.toolCall (injected by ToolNode).
-       * - session_id: For API to associate with previous session
-       * - _injected_files: File refs to pass directly (avoids /files endpoint race condition)
+       * - session_id: associates with the previous run.
+       * - _injected_files: File refs to pass directly (avoids /files endpoint race condition).
        */
       const { session_id, _injected_files } = (config.toolCall ?? {}) as {
         session_id?: string;
@@ -153,7 +153,10 @@ function createCodeExecutionTool(
       /**
        * File injection priority:
        * 1. Use _injected_files from ToolNode (avoids /files endpoint race condition)
-       * 2. Fall back to fetching from /files endpoint if session_id provided but no injected files
+       * 2. Fall back to fetching from /files endpoint if session_id
+       *    provided but no injected files. The /files lookup still uses the
+       *    same id value — codeapi stores output files under the exec id as
+       *    their storage prefix, so the two values coincide here.
        */
       if (_injected_files && _injected_files.length > 0) {
         postData.files = _injected_files;
@@ -186,7 +189,10 @@ function createCodeExecutionTool(
               const id = nameParts.length > 1 ? nameParts[1].split('.')[0] : '';
 
               return {
-                session_id,
+                storage_session_id: session_id,
+                /* `/files` fallback returns code-output files belonging
+                 * to the user; tag them user-private. */
+                kind: 'user' as const,
                 id,
                 name: file.metadata['original-filename'],
               };
@@ -259,11 +265,16 @@ function createCodeExecutionTool(
             {
               session_id: result.session_id,
               files: result.files,
-            },
+            } satisfies t.CodeExecutionArtifact,
           ];
         }
 
-        return [formattedOutput.trim(), { session_id: result.session_id }];
+        return [
+          formattedOutput.trim(),
+          {
+            session_id: result.session_id,
+          } satisfies t.CodeExecutionArtifact,
+        ];
       } catch (error) {
         throw new Error(
           `Execution error:\n\n${(error as Error | undefined)?.message}`

package/src/tools/ProgrammaticToolCalling.ts

@@ -304,7 +304,10 @@ export async function fetchSessionFiles(
       const id = nameParts.length > 1 ? nameParts[1].split('.')[0] : '';
 
       return {
-        session_id: sessionId,
+        storage_session_id: sessionId,
+        /* `/files` fallback returns code-output files belonging to
+         * the user; tag them user-private. */
+        kind: 'user' as const,
         id,
         name: (file.metadata as Record<string, unknown>)[
           'original-filename'
@@ -588,7 +591,7 @@ export function formatCompletedResponse(
     {
       session_id: response.session_id,
       files: response.files,
-    },
+    } satisfies t.ProgrammaticExecutionArtifact,
   ];
 }
 
@@ -629,13 +632,13 @@ export function createProgrammaticToolCallingTool(
       const params = rawParams as { code: string; timeout?: number };
       const { code, timeout = DEFAULT_TIMEOUT } = params;
 
-      // Extra params injected by ToolNode (follows web_search pattern)
-      const { toolMap, toolDefs, session_id, _injected_files } =
-        (config.toolCall ?? {}) as ToolCall &
-          Partial<t.ProgrammaticCache> & {
-            session_id?: string;
-            _injected_files?: t.CodeEnvFile[];
-          };
+      // Extra params injected by ToolNode (follows web_search pattern).
+      const toolCall = (config.toolCall ?? {}) as ToolCall &
+        Partial<t.ProgrammaticCache> & {
+          session_id?: string;
+          _injected_files?: t.CodeEnvFile[];
+        };
+      const { toolMap, toolDefs, session_id, _injected_files } = toolCall;
 
       if (toolMap == null || toolMap.size === 0) {
         throw new Error(
@@ -671,7 +674,8 @@ export function createProgrammaticToolCallingTool(
         /**
          * File injection priority:
          * 1. Use _injected_files from ToolNode (avoids /files endpoint race condition)
-         * 2. Fall back to fetching from /files endpoint if session_id provided but no injected files
+         * 2. Fall back to fetching from /files endpoint if session_id
+         *    provided but no injected files.
          */
         let files: t.CodeEnvFile[] | undefined;
         if (_injected_files && _injected_files.length > 0) {