@librechat/agents 3.1.42 → 3.1.44

package/src/messages/ensureThinkingBlock.test.ts

@@ -89,6 +89,213 @@ describe('ensureThinkingBlockInMessages', () => {
       );
     });
 
+    test('should not modify AI message when reasoning_content is not the first block (Bedrock whitespace artifact)', () => {
+      // Bedrock emits a "\n\n" text chunk before the thinking block,
+      // pushing reasoning_content to content[1] instead of content[0].
+      const messages = [
+        new HumanMessage({ content: 'Do something' }),
+        new AIMessage({
+          content: [
+            { type: 'text', text: '\n\n' },
+            {
+              type: ContentTypes.REASONING_CONTENT,
+              reasoningText: { text: 'Let me think about this' },
+            },
+            { type: 'text', text: 'Let me help!' },
+          ],
+          tool_calls: [
+            {
+              id: 'call_bedrock',
+              name: 'some_tool',
+              args: { x: 1 },
+              type: 'tool_call' as const,
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: 'tool result',
+          tool_call_id: 'call_bedrock',
+        }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(messages, Providers.BEDROCK);
+
+      expect(result).toHaveLength(3);
+      expect(result[0]).toBeInstanceOf(HumanMessage);
+      expect(result[1]).toBeInstanceOf(AIMessage);
+      expect(result[2]).toBeInstanceOf(ToolMessage);
+      // The AI message should be preserved, not converted to a HumanMessage
+      expect(result[1].content).toEqual(messages[1].content);
+    });
+
+    test('should not convert follow-up tool calls in a thinking-enabled chain (Bedrock multi-step)', () => {
+      // Bedrock reasoning models produce reasoning on the first AI response,
+      // then subsequent tool calls in the same chain have content: "" with no
+      // reasoning block. These should NOT be converted because the chain
+      // already has a thinking block upstream.
+      const messages = [
+        new HumanMessage({ content: 'show me something cool' }),
+        new AIMessage({
+          content: [
+            { type: 'text', text: '\n\n' },
+            {
+              type: ContentTypes.REASONING_CONTENT,
+              reasoningText: { text: 'Let me navigate to a page' },
+            },
+            { type: 'text', text: 'Let me whip up something fun!' },
+          ],
+          tool_calls: [
+            {
+              id: 'call_nav',
+              name: 'navigate_page',
+              args: { url: 'about:blank' },
+              type: 'tool_call' as const,
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: 'Navigated to about:blank',
+          tool_call_id: 'call_nav',
+        }),
+        // Follow-up: content: "", tool calls, NO reasoning block
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_eval',
+              name: 'evaluate_script',
+              args: { script: 'document.title = "test"' },
+              type: 'tool_call' as const,
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: 'Script executed',
+          tool_call_id: 'call_eval',
+        }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(messages, Providers.BEDROCK);
+
+      // All 5 messages preserved — the follow-up AI message at index 3 is NOT converted
+      expect(result).toHaveLength(5);
+      expect(result[0]).toBeInstanceOf(HumanMessage);
+      expect(result[1]).toBeInstanceOf(AIMessage);
+      expect(result[2]).toBeInstanceOf(ToolMessage);
+      expect(result[3]).toBeInstanceOf(AIMessage);
+      expect(result[3].content).toBe('');
+      expect((result[3] as AIMessage).tool_calls).toHaveLength(1);
+      expect(result[4]).toBeInstanceOf(ToolMessage);
+    });
+
+    test('should not convert multiple follow-up tool calls in a long chain', () => {
+      // Three AI→Tool rounds: only the first has reasoning
+      const messages = [
+        new HumanMessage({ content: 'do stuff' }),
+        new AIMessage({
+          content: [
+            {
+              type: ContentTypes.REASONING_CONTENT,
+              reasoningText: { text: 'Planning...' },
+            },
+          ],
+          tool_calls: [
+            { id: 'c1', name: 'step1', args: {}, type: 'tool_call' as const },
+          ],
+        }),
+        new ToolMessage({ content: 'r1', tool_call_id: 'c1' }),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            { id: 'c2', name: 'step2', args: {}, type: 'tool_call' as const },
+          ],
+        }),
+        new ToolMessage({ content: 'r2', tool_call_id: 'c2' }),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            { id: 'c3', name: 'step3', args: {}, type: 'tool_call' as const },
+          ],
+        }),
+        new ToolMessage({ content: 'r3', tool_call_id: 'c3' }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(messages, Providers.BEDROCK);
+
+      expect(result).toHaveLength(7);
+      expect(result[1]).toBeInstanceOf(AIMessage);
+      expect(result[3]).toBeInstanceOf(AIMessage);
+      expect(result[5]).toBeInstanceOf(AIMessage);
+    });
+
+    test('should still convert non-thinking agent tool calls after a human message boundary', () => {
+      // A chain with thinking, then a new human message, then a chain WITHOUT thinking
+      const messages = [
+        new HumanMessage({ content: 'first request' }),
+        new AIMessage({
+          content: [
+            {
+              type: ContentTypes.REASONING_CONTENT,
+              reasoningText: { text: 'Thinking...' },
+            },
+          ],
+          tool_calls: [
+            { id: 'c1', name: 'tool1', args: {}, type: 'tool_call' as const },
+          ],
+        }),
+        new ToolMessage({ content: 'r1', tool_call_id: 'c1' }),
+        new HumanMessage({ content: 'second request' }),
+        // This chain has NO thinking blocks — should be converted
+        new AIMessage({
+          content: 'Using a tool',
+          tool_calls: [
+            { id: 'c2', name: 'tool2', args: {}, type: 'tool_call' as const },
+          ],
+        }),
+        new ToolMessage({ content: 'r2', tool_call_id: 'c2' }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(messages, Providers.BEDROCK);
+
+      // First chain preserved (3 msgs), human preserved, second chain converted (1 HumanMessage)
+      expect(result).toHaveLength(5);
+      expect(result[0]).toBeInstanceOf(HumanMessage);
+      expect(result[1]).toBeInstanceOf(AIMessage); // reasoning chain — kept
+      expect(result[2]).toBeInstanceOf(ToolMessage);
+      expect(result[3]).toBeInstanceOf(HumanMessage); // user message
+      expect(result[4]).toBeInstanceOf(HumanMessage); // converted — no thinking in this chain
+      expect(result[4].content).toContain('[Previous agent context]');
+    });
+
+    test('should detect thinking via additional_kwargs.reasoning_content in chain', () => {
+      const messages = [
+        new HumanMessage({ content: 'hello' }),
+        new AIMessage({
+          content: '',
+          additional_kwargs: {
+            reasoning_content: 'Some reasoning...',
+          },
+          tool_calls: [
+            { id: 'c1', name: 'tool1', args: {}, type: 'tool_call' as const },
+          ],
+        }),
+        new ToolMessage({ content: 'r1', tool_call_id: 'c1' }),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            { id: 'c2', name: 'tool2', args: {}, type: 'tool_call' as const },
+          ],
+        }),
+        new ToolMessage({ content: 'r2', tool_call_id: 'c2' }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(messages, Providers.BEDROCK);
+
+      // Index 3 should NOT be converted — index 1 has reasoning in additional_kwargs
+      expect(result).toHaveLength(5);
+      expect(result[3]).toBeInstanceOf(AIMessage);
+    });
+
     test('should not modify AI message with reasoning block and tool calls', () => {
       const messages = [
         new HumanMessage({ content: 'Calculate something' }),

package/src/messages/format.ts

@@ -1011,7 +1011,12 @@ export function ensureThinkingBlockInMessages(
 
   while (i < messages.length) {
     const msg = messages[i];
-    const isAI = msg instanceof AIMessage || msg instanceof AIMessageChunk;
+    /** Detect AI messages by instanceof OR by role, in case cache-control cloning
+     produced a plain object that lost the LangChain prototype. */
+    const isAI =
+      msg instanceof AIMessage ||
+      msg instanceof AIMessageChunk ||
+      ('role' in msg && (msg as any).role === 'assistant');
 
     if (!isAI) {
       result.push(msg);
@@ -1025,30 +1030,58 @@ export function ensureThinkingBlockInMessages(
 
     // Check if the message has tool calls or tool_use content
     let hasToolUse = hasToolCalls ?? false;
-    let firstContentType: string | undefined;
+    let hasThinkingBlock = false;
 
     if (contentIsArray && aiMsg.content.length > 0) {
       const content = aiMsg.content as ExtendedMessageContent[];
-      firstContentType = content[0]?.type;
       hasToolUse =
         hasToolUse ||
         content.some((c) => typeof c === 'object' && c.type === 'tool_use');
+      // Check ALL content blocks for thinking/reasoning, not just [0].
+      // Bedrock may emit a whitespace text chunk before the thinking block,
+      // pushing the reasoning_content to index 1+.
+      hasThinkingBlock = content.some(
+        (c) =>
+          typeof c === 'object' &&
+          (c.type === ContentTypes.THINKING ||
+            c.type === ContentTypes.REASONING_CONTENT ||
+            c.type === ContentTypes.REASONING ||
+            c.type === 'redacted_thinking')
+      );
     }
 
-    // If message has tool use but no thinking block, convert to buffer string
+    // Bedrock also stores reasoning in additional_kwargs (may not be in content array)
     if (
-      hasToolUse &&
-      firstContentType !== ContentTypes.THINKING &&
-      firstContentType !== ContentTypes.REASONING_CONTENT &&
-      firstContentType !== ContentTypes.REASONING &&
-      firstContentType !== 'redacted_thinking'
+      !hasThinkingBlock &&
+      aiMsg.additional_kwargs.reasoning_content != null
     ) {
+      hasThinkingBlock = true;
+    }
+
+    // If message has tool use but no thinking block, check whether this is a
+    // continuation of a thinking-enabled agent's chain before converting.
+    // Bedrock reasoning models can produce multiple AI→Tool rounds after an
+    // initial reasoning response: the first AI message has reasoning_content,
+    // but follow-ups have content: "" with only tool_calls. These are the
+    // same agent's turn and must NOT be converted to HumanMessages.
+    if (hasToolUse && !hasThinkingBlock) {
+      // Walk backwards — if an earlier AI message in the same chain (before
+      // the nearest HumanMessage) has a thinking/reasoning block, this is a
+      // continuation of a thinking-enabled turn, not a non-thinking handoff.
+      if (chainHasThinkingBlock(messages, i)) {
+        result.push(msg);
+        i++;
+        continue;
+      }
+
       // Collect the AI message and any following tool messages
       const toolSequence: BaseMessage[] = [msg];
       let j = i + 1;
 
       // Look ahead for tool messages that belong to this AI message
-      while (j < messages.length && messages[j] instanceof ToolMessage) {
+      const isToolMsg = (m: BaseMessage): boolean =>
+        m instanceof ToolMessage || ('role' in m && (m as any).role === 'tool');
+      while (j < messages.length && isToolMsg(messages[j])) {
         toolSequence.push(messages[j]);
         j++;
       }
@@ -1073,3 +1106,66 @@ export function ensureThinkingBlockInMessages(
 
   return result;
 }
+
+/**
+ * Walks backwards from `currentIndex` through the message array to check
+ * whether an earlier AI message in the same "chain" (no HumanMessage boundary)
+ * contains a thinking/reasoning block.
+ *
+ * A "chain" is a contiguous sequence of AI + Tool messages with no intervening
+ * HumanMessage. Bedrock reasoning models produce reasoning on the first AI
+ * response, then issue follow-up tool calls with `content: ""` and no
+ * reasoning block. These follow-ups are part of the same thinking-enabled
+ * turn and should not be converted.
+ */
+function chainHasThinkingBlock(
+  messages: BaseMessage[],
+  currentIndex: number
+): boolean {
+  for (let k = currentIndex - 1; k >= 0; k--) {
+    const prev = messages[k];
+
+    // HumanMessage = turn boundary — stop searching
+    if (
+      prev instanceof HumanMessage ||
+      ('role' in prev && (prev as any).role === 'user')
+    ) {
+      return false;
+    }
+
+    // Check AI messages for thinking/reasoning blocks
+    const isPrevAI =
+      prev instanceof AIMessage ||
+      prev instanceof AIMessageChunk ||
+      ('role' in prev && (prev as any).role === 'assistant');
+
+    if (isPrevAI) {
+      const prevAiMsg = prev as AIMessage | AIMessageChunk;
+
+      if (Array.isArray(prevAiMsg.content) && prevAiMsg.content.length > 0) {
+        const content = prevAiMsg.content as ExtendedMessageContent[];
+        if (
+          content.some(
+            (c) =>
+              typeof c === 'object' &&
+              (c.type === ContentTypes.THINKING ||
+                c.type === ContentTypes.REASONING_CONTENT ||
+                c.type === ContentTypes.REASONING ||
+                c.type === 'redacted_thinking')
+          )
+        ) {
+          return true;
+        }
+      }
+
+      // Bedrock also stores reasoning in additional_kwargs
+      if (prevAiMsg.additional_kwargs.reasoning_content != null) {
+        return true;
+      }
+    }
+
+    // ToolMessages are part of the chain — keep walking back
+  }
+
+  return false;
+}

package/src/tools/ToolSearch.ts

@@ -687,9 +687,23 @@ function getBaseToolName(toolName: string): string {
   return toolName.substring(0, delimiterIndex);
 }
 
+/**
+ * Checks whether a tool has any defined parameters in its JSON schema.
+ * @param parameters - The tool's JSON schema parameters
+ * @returns true if the tool has at least one parameter property
+ */
+function hasParams(parameters?: t.JsonSchemaType): boolean {
+  return (
+    parameters?.properties != null &&
+    Object.keys(parameters.properties).length > 0
+  );
+}
+
 /**
  * Generates a compact listing of deferred tools grouped by server.
- * Format: "server: tool1, tool2, tool3"
+ * Format: "server: tool1, tool2(\u2026), tool3"
+ * Tools with parameters are annotated with (\u2026) to signal
+ * that the LLM should discover the schema via tool_search before calling.
  * Non-MCP tools are grouped under "other".
  * @param toolRegistry - The tool registry
  * @param onlyDeferred - Whether to only include deferred tools
@@ -713,11 +727,14 @@ function getDeferredToolsListing(
     const toolName = lcTool.name;
     const serverName = extractMcpServerName(toolName) ?? 'other';
     const baseName = getBaseToolName(toolName);
+    const displayName = hasParams(lcTool.parameters)
+      ? `${baseName}(\u2026)`
+      : baseName;
 
     if (!(serverName in toolsByServer)) {
       toolsByServer[serverName] = [];
     }
-    toolsByServer[serverName].push(baseName);
+    toolsByServer[serverName].push(displayName);
   }
 
   const serverNames = Object.keys(toolsByServer).sort((a, b) => {
@@ -862,7 +879,7 @@ function createToolSearch(
     deferredToolsListing.length > 0
       ? `
 
-Deferred tools (search to load):
+Deferred tools (search to load; \u2026 = has params, search first):
 ${deferredToolsListing}`
       : '';
 

package/src/tools/__tests__/ToolSearch.test.ts

@@ -664,6 +664,11 @@ describe('ToolSearch', () => {
         name: 'get_weather_mcp_weather-api',
         description: 'Get weather',
         defer_loading: true,
+        parameters: {
+          type: 'object',
+          properties: { location: { type: 'string' } },
+          required: ['location'],
+        },
       });
       registry.set('get_forecast_mcp_weather-api', {
         name: 'get_forecast_mcp_weather-api',
@@ -674,6 +679,11 @@ describe('ToolSearch', () => {
         name: 'send_email_mcp_gmail',
         description: 'Send email',
         defer_loading: true,
+        parameters: {
+          type: 'object',
+          properties: { to: { type: 'string' }, body: { type: 'string' } },
+          required: ['to', 'body'],
+        },
       });
       registry.set('execute_code', {
         name: 'execute_code',
@@ -692,8 +702,10 @@ describe('ToolSearch', () => {
       const registry = createRegistry();
       const listing = getDeferredToolsListing(registry, true);
 
-      expect(listing).toContain('gmail: send_email');
-      expect(listing).toContain('weather-api: get_weather, get_forecast');
+      expect(listing).toContain('gmail: send_email(\u2026)');
+      expect(listing).toContain(
+        'weather-api: get_weather(\u2026), get_forecast'
+      );
       expect(listing).toContain('other: execute_code');
     });
 
@@ -715,6 +727,54 @@ describe('ToolSearch', () => {
       expect(listing).not.toContain('get_weather_mcp_weather-api');
     });
 
+    it('annotates tools with any params with ellipsis', () => {
+      const registry = createRegistry();
+      const listing = getDeferredToolsListing(registry, true);
+
+      // Tools with params get (…)
+      expect(listing).toContain('get_weather(\u2026)');
+      expect(listing).toContain('send_email(\u2026)');
+
+      // Tools without params stay clean
+      expect(listing).toContain('get_forecast');
+      expect(listing).not.toContain('get_forecast(\u2026)');
+      expect(listing).toContain('execute_code');
+      expect(listing).not.toContain('execute_code(\u2026)');
+    });
+
+    it('annotates tools with optional-only params', () => {
+      const registry: LCToolRegistry = new Map();
+      registry.set('list_items_mcp_api', {
+        name: 'list_items_mcp_api',
+        description: 'List items',
+        defer_loading: true,
+        parameters: {
+          type: 'object',
+          properties: { limit: { type: 'integer' } },
+          required: [],
+        },
+      });
+
+      const listing = getDeferredToolsListing(registry, true);
+      expect(listing).toBe('api: list_items(\u2026)');
+    });
+
+    it('does not annotate tools with empty properties', () => {
+      const registry: LCToolRegistry = new Map();
+      registry.set('ping_mcp_api', {
+        name: 'ping_mcp_api',
+        description: 'Ping',
+        defer_loading: true,
+        parameters: {
+          type: 'object',
+          properties: {},
+        },
+      });
+
+      const listing = getDeferredToolsListing(registry, true);
+      expect(listing).toBe('api: ping');
+    });
+
     it('respects onlyDeferred flag', () => {
       const registry = createRegistry();