@librechat/agents 3.1.78-dev.0 → 3.1.79

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/subagent-configurable-inheritance.ts

@@ -0,0 +1,252 @@
+import { config } from 'dotenv';
+config();
+
+import { HumanMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { ChatModelStreamHandler } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { Providers, GraphEvents } from '@/common';
+import { Run } from '@/run';
+
+/**
+ * Live verification that host-set fields on the parent's outer
+ * `configurable` (e.g. `requestBody`, `user`, `userMCPAuthMap`)
+ * propagate into the subagent's `ON_TOOL_EXECUTE` dispatches.
+ *
+ * Pass criteria: when the SUBAGENT calls the calculator tool, the
+ * `data.configurable` arriving at the parent's ON_TOOL_EXECUTE
+ * handler contains every key the parent put on its outer
+ * configurable (with `thread_id` overridden to a child run id).
+ */
+const apiKey = process.env.OPENAI_API_KEY!;
+if (!apiKey) {
+  console.error('Missing OPENAI_API_KEY');
+  process.exit(1);
+}
+
+const calculatorDef: t.LCTool = {
+  name: 'calculator',
+  description: 'Evaluate a math expression. Use for any arithmetic.',
+  parameters: {
+    type: 'object',
+    properties: {
+      expression: {
+        type: 'string',
+        description: "A JS math expression, e.g. '42 * 58'",
+      },
+    },
+    required: ['expression'],
+  },
+};
+
+type ConfigurableSnapshot = {
+  agentId: string | undefined;
+  configurable: Record<string, unknown> | undefined;
+  metadata: Record<string, unknown> | undefined;
+};
+
+async function main() {
+  console.log('=== Subagent parentConfigurable inheritance — live ===\n');
+
+  // Parent has NO tools — it can only delegate via the math subagent.
+  // The math subagent has the calculator. This forces the spawn-subagent
+  // path so we can observe the subagent's `ON_TOOL_EXECUTE` dispatch.
+  const mathSubagentInputs: t.AgentInputs = {
+    agentId: 'math-worker',
+    provider: Providers.OPENAI,
+    clientOptions: { modelName: 'gpt-4o', apiKey },
+    instructions:
+      'You compute arithmetic. Always use the calculator tool — never estimate. Return the final numeric result as plain text.',
+    maxContextTokens: 8000,
+    toolDefinitions: [calculatorDef],
+  };
+
+  const parentAgent: t.AgentInputs = {
+    agentId: 'supervisor',
+    provider: Providers.OPENAI,
+    clientOptions: { modelName: 'gpt-4o', apiKey },
+    instructions: `You delegate arithmetic to the "math" subagent. You have NO calculator yourself. For any math task, spawn the "math" subagent with the full task as its description, then echo the subagent's text result back to the user.`,
+    maxContextTokens: 8000,
+    // No toolDefinitions on the parent — only the subagent gets the calculator.
+    subagentConfigs: [
+      {
+        type: 'math',
+        name: 'math',
+        description:
+          'A focused arithmetic worker that uses the calculator tool to compute numerical results.',
+        agentInputs: mathSubagentInputs,
+      },
+    ],
+  };
+
+  const parentSnapshots: ConfigurableSnapshot[] = [];
+  const subagentSnapshots: ConfigurableSnapshot[] = [];
+
+  const customHandlers: Record<string, t.EventHandler> = {
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.ON_TOOL_EXECUTE]: {
+      handle: (_event, rawData): void => {
+        const data = rawData as t.ToolExecuteBatchRequest;
+        const snapshot: ConfigurableSnapshot = {
+          agentId: data.agentId,
+          configurable: data.configurable as Record<string, unknown> | undefined,
+          metadata: data.metadata as Record<string, unknown> | undefined,
+        };
+        const callsLabel = data.toolCalls.map((c) => c.name).join(',');
+        // Parent and subagent have different agent IDs in this script
+        // (parent: 'supervisor', subagent: 'math-worker'). With a self-spawn
+        // subagent both would be the same; this script uses a non-self
+        // subagent precisely so we can distinguish reliably.
+        const isSubagent = data.agentId !== 'supervisor';
+        const metadataRunId = (data.metadata as { run_id?: string } | undefined)
+          ?.run_id;
+        if (isSubagent) {
+          subagentSnapshots.push(snapshot);
+        } else {
+          parentSnapshots.push(snapshot);
+        }
+        console.log(
+          `[ON_TOOL_EXECUTE] origin=${isSubagent ? 'SUBAGENT' : 'PARENT'} agentId=${data.agentId} calls=${callsLabel}`
+        );
+        console.log(
+          `  metadata keys: ${Object.keys(data.metadata ?? {}).join(',') || '<none>'}`
+        );
+        console.log(
+          `  metadata.run_id="${metadataRunId ?? '<none>'}" configurable.run_id="${(data.configurable as { run_id?: string } | undefined)?.run_id ?? '<none>'}" configurable.thread_id="${(data.configurable as { thread_id?: string } | undefined)?.thread_id ?? '<none>'}"`
+        );
+        const results: t.ToolExecuteResult[] = data.toolCalls.map((call) => {
+          const args = call.args as { expression?: string };
+          const expression = args.expression ?? '';
+          let content: string;
+          try {
+            // eslint-disable-next-line no-eval
+            const result = eval(expression);
+            content = `${expression} = ${result}`;
+          } catch (err) {
+            content = `Error: ${String(err)}`;
+          }
+          return {
+            toolCallId: call.id!,
+            status: 'success',
+            content,
+          };
+        });
+        data.resolve(results);
+      },
+    },
+  };
+
+  const run = await Run.create<t.IState>({
+    runId: `sub-cfg-inherit-${Date.now()}`,
+    graphConfig: { type: 'standard', agents: [parentAgent] },
+    customHandlers,
+  });
+
+  const question = new HumanMessage(
+    'Compute (42 * 58) + (13 ** 3). Use the self subagent, and have it use the calculator.'
+  );
+
+  // Parent's outer configurable carries host-set fields AND explicit
+  // run-identity fields so we can verify whether LangGraph respects or
+  // overwrites parent's `run_id` / `parent_run_id` when we forward them
+  // into the child's `workflow.invoke`.
+  const outerConfigurable = {
+    thread_id: 'parent-thread-conv-xyz',
+    run_id: 'parent-run-id-001',
+    parent_run_id: 'grandparent-run-id-000',
+    user_id: 'user_abc',
+    user: { id: 'user_abc', email: 'a@b.c', role: 'USER' },
+    requestBody: {
+      messageId: 'msg-response-id-001',
+      conversationId: 'parent-thread-conv-xyz',
+      parentMessageId: 'user-message-id-000',
+    },
+    userMCPAuthMap: { 'mcp-github': { token: 'abc' } },
+  };
+
+  console.log('User:', question.content);
+  console.log('Parent outer configurable keys:', Object.keys(outerConfigurable));
+  console.log();
+
+  await run.processStream(
+    { messages: [question] },
+    {
+      configurable: outerConfigurable,
+      version: 'v2' as const,
+    }
+  );
+
+  console.log('\n=== Verification ===');
+  console.log(
+    `Parent ON_TOOL_EXECUTE dispatches captured: ${parentSnapshots.length}`
+  );
+  console.log(
+    `Subagent ON_TOOL_EXECUTE dispatches captured: ${subagentSnapshots.length}`
+  );
+
+  if (subagentSnapshots.length === 0) {
+    console.error(
+      '\n❌ FAIL: subagent never invoked a tool — model may not have spawned the subagent.'
+    );
+    process.exit(2);
+  }
+
+  const expectedHostKeys = ['user_id', 'user', 'requestBody', 'userMCPAuthMap'];
+  let allPassed = true;
+  subagentSnapshots.forEach((snap, idx) => {
+    const cfg = snap.configurable ?? {};
+    const meta = snap.metadata ?? {};
+    console.log(
+      `\nSubagent dispatch #${idx + 1} (agentId=${snap.agentId}, metadata.run_id=${(meta as { run_id?: string }).run_id ?? '-'}):`
+    );
+
+    // Host-set fields must propagate.
+    for (const key of expectedHostKeys) {
+      const present = key in cfg;
+      const value = cfg[key];
+      console.log(
+        `  ${present ? '✅' : '❌'} ${key} = ${JSON.stringify(value)}`
+      );
+      if (!present) allPassed = false;
+    }
+
+    // Run-identity fields: with full inheritance we expect parent's
+    // values to flow through. LangGraph runtime MAY overwrite them at
+    // child-invoke time — the script logs what actually arrived so we
+    // can see empirically what propagates.
+    console.log(`  ⓘ thread_id observed: "${cfg.thread_id as string}" (parent's: "${outerConfigurable.thread_id}")`);
+    console.log(`  ⓘ run_id observed:    "${cfg.run_id as string}" (parent's: "${outerConfigurable.run_id}")`);
+    console.log(`  ⓘ parent_run_id observed: "${cfg.parent_run_id as string}" (parent's: "${outerConfigurable.parent_run_id}")`);
+
+    const threadInherited = cfg.thread_id === outerConfigurable.thread_id;
+    const runInherited = cfg.run_id === outerConfigurable.run_id;
+    const parentRunInherited =
+      cfg.parent_run_id === outerConfigurable.parent_run_id;
+    console.log(
+      `  ${threadInherited ? '✅' : '⚠️ '} thread_id inherited from parent: ${threadInherited}`
+    );
+    console.log(
+      `  ${runInherited ? '✅' : '⚠️ '} run_id inherited from parent: ${runInherited}`
+    );
+    console.log(
+      `  ${parentRunInherited ? '✅' : '⚠️ '} parent_run_id inherited from parent: ${parentRunInherited}`
+    );
+  });
+
+  if (allPassed) {
+    console.log(
+      '\n✅ Host-set fields propagate. (Run-identity inheritance is informational — see ⚠️ markers above for any LangGraph-runtime overwrites.)'
+    );
+    process.exit(0);
+  } else {
+    console.log('\n❌ FAIL: at least one expected host-set key was missing.');
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('Script error:', err);
+  process.exit(1);
+});