@librechat/agents 3.1.97 → 3.1.99

package/src/specs/prune.test.ts

@@ -2382,3 +2382,196 @@ describe('thinking enabled — tail tool_use without a thinking block (issue #11
     expect(result.thinkingStartIndex).toBeGreaterThanOrEqual(0);
   });
 });
+
+describe('thinking enabled — non-Anthropic reasoning_content blocks (issue #191)', () => {
+  it('locates a trailing reasoning_content block even when reasoningType defaults to THINKING (DeepSeek/Qwen)', () => {
+    // DeepSeek-R1 and DashScope/Qwen-thinking route through the non-Bedrock
+    // branch, so the caller passes reasoningType: THINKING — but their blocks
+    // are tagged `reasoning_content` and are not normalized upstream. With a
+    // system prompt at index 0 and an all-AI/tool tail, the consume loop never
+    // pops a human to clear thinkingEndIndex (the issue #116 escape hatch), so
+    // searching only for `thinking` missed the present block and threw a fatal
+    // that permanently bricked the thread. The pruner must find the block by
+    // its actual shape instead.
+    const tokenCounter = createTestTokenCounter();
+    const messages: BaseMessage[] = [
+      new SystemMessage('you are a helpful assistant'),
+      new AIMessage({
+        content: [
+          {
+            type: ContentTypes.REASONING_CONTENT,
+            reasoningText: {
+              text: 'I will fetch the doc',
+              signature: 'sig-new',
+            },
+          },
+          {
+            type: 'tool_use',
+            id: 'tc_get_doc',
+            name: 'get_doc_content',
+            input: { docId: 'abc' },
+          },
+        ],
+        tool_calls: [
+          {
+            id: 'tc_get_doc',
+            name: 'get_doc_content',
+            args: { docId: 'abc' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new ToolMessage({
+        content: 'c'.repeat(6000),
+        tool_call_id: 'tc_get_doc',
+        name: 'get_doc_content',
+      }),
+    ];
+
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = tokenCounter(messages[i]);
+    }
+
+    let result: ReturnType<typeof realGetMessagesWithinTokenLimit> | undefined;
+    expect(() => {
+      result = realGetMessagesWithinTokenLimit({
+        messages,
+        maxContextTokens: 200,
+        indexTokenCountMap,
+        thinkingEnabled: true,
+        tokenCounter,
+        reasoningType: ContentTypes.THINKING,
+      });
+    }).not.toThrow();
+
+    // thinkingStartIndex is only set when the reasoning block is actually
+    // located — isolating the find fix (B) from the graceful-degradation
+    // safety net (C), which would swallow the throw without finding anything.
+    expect(result!.thinkingStartIndex).toBeGreaterThanOrEqual(0);
+  });
+
+  it('does not throw when a carried-over thinking sequence has no locatable block', () => {
+    // Models a stale runThinkingStartIndex carry-over pointing at an assistant
+    // message that has no reasoning block. The pruner cannot find a block, but
+    // a trailing AI/tool sequence keeps thinkingEndIndex set, so it used to
+    // reach the fatal "no thinking block found" throw. Defense in depth: a
+    // misconfiguration upstream of the pruner must not be able to brick the
+    // thread — degrade to the partially-pruned context instead.
+    const tokenCounter = createTestTokenCounter();
+    const messages: BaseMessage[] = [
+      new HumanMessage('h'.repeat(100)),
+      new AIMessage({
+        content: [{ type: 'text', text: 'a reply with no reasoning block' }],
+      }),
+      new HumanMessage('please read the doc'),
+      new AIMessage({
+        content: [
+          {
+            type: 'tool_use',
+            id: 'tc_get_doc',
+            name: 'get_doc_content',
+            input: { docId: 'abc' },
+          },
+        ],
+        tool_calls: [
+          {
+            id: 'tc_get_doc',
+            name: 'get_doc_content',
+            args: { docId: 'abc' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new ToolMessage({
+        content: 'x'.repeat(150),
+        tool_call_id: 'tc_get_doc',
+        name: 'get_doc_content',
+      }),
+    ];
+
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = tokenCounter(messages[i]);
+    }
+
+    let result: ReturnType<typeof realGetMessagesWithinTokenLimit> | undefined;
+    expect(() => {
+      result = realGetMessagesWithinTokenLimit({
+        messages,
+        maxContextTokens: 200,
+        indexTokenCountMap,
+        thinkingEnabled: true,
+        tokenCounter,
+        thinkingStartIndex: 1,
+        reasoningType: ContentTypes.THINKING,
+      });
+    }).not.toThrow();
+
+    expect(result!.context.length).toBeGreaterThan(0);
+    expect(result!.messagesToRefine.length).toBeGreaterThan(0);
+    // The stale carried-over index must NOT be propagated: createPruneMessages
+    // persists it as runThinkingStartIndex, and a stale value would suppress
+    // the trailing scan on later turns and miss a real reasoning block.
+    expect(result!.thinkingStartIndex).toBeUndefined();
+  });
+
+  it('does not match an Anthropic thinking block for a Bedrock (reasoning_content) run', () => {
+    // The cross-type fallback is one-directional: REASONING_CONTENT (Bedrock)
+    // must not match a `thinking` block, since the Bedrock input converter
+    // rejects `thinking` blocks and reattaching one would break the request.
+    const tokenCounter = createTestTokenCounter();
+    const messages: BaseMessage[] = [
+      new SystemMessage('you are a helpful assistant'),
+      new AIMessage({
+        content: [
+          {
+            type: ContentTypes.THINKING,
+            thinking: 'inherited Anthropic-style reasoning',
+            signature: 'sig-anthropic',
+          },
+          {
+            type: 'tool_use',
+            id: 'tc_get_doc',
+            name: 'get_doc_content',
+            input: { docId: 'abc' },
+          },
+        ],
+        tool_calls: [
+          {
+            id: 'tc_get_doc',
+            name: 'get_doc_content',
+            args: { docId: 'abc' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new ToolMessage({
+        content: 'c'.repeat(6000),
+        tool_call_id: 'tc_get_doc',
+        name: 'get_doc_content',
+      }),
+    ];
+
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = tokenCounter(messages[i]);
+    }
+
+    let result: ReturnType<typeof realGetMessagesWithinTokenLimit> | undefined;
+    expect(() => {
+      result = realGetMessagesWithinTokenLimit({
+        messages,
+        maxContextTokens: 200,
+        indexTokenCountMap,
+        thinkingEnabled: true,
+        tokenCounter,
+        reasoningType: ContentTypes.REASONING_CONTENT,
+      });
+    }).not.toThrow();
+
+    // The thinking block is intentionally not located for a Bedrock run, so no
+    // index is reported and nothing gets reattached.
+    expect(result!.thinkingStartIndex).toBeUndefined();
+  });
+});

package/src/tools/ToolNode.ts

@@ -103,6 +103,8 @@ type RunToolBatchContext = {
   additionalContextsSink?: string[];
 };
 
+const TOOL_NODE_RUN_NAME = 'tool_batch';
+
 /**
  * Per-batch context for `dispatchToolEvents` / `executeViaEvent`.
  * Mirrors {@link RunToolBatchContext} for the event-driven path,
@@ -500,7 +502,11 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     toolExecution,
     fileCheckpointer,
   }: t.ToolNodeConstructorParams) {
-    super({ name, tags, func: (input, config) => this.run(input, config) });
+    super({
+      name: name ?? TOOL_NODE_RUN_NAME,
+      tags,
+      func: (input, config) => this.run(input, config),
+    });
     this.trace = trace ?? this.trace;
     this.runLangfuse = runLangfuse;
     this.agentLangfuse = agentLangfuse;

package/src/tools/__tests__/ToolNode.langfuse.test.ts

@@ -15,6 +15,12 @@ describe('ToolNode Langfuse redaction context', () => {
     mockWithLangfuseToolOutputTracingConfig.mockClear();
   });
 
+  it('uses a stable default run name for tracing', () => {
+    const node = new ToolNode({ tools: [] });
+
+    expect(node.name).toBe('tool_batch');
+  });
+
   it('scopes ToolNode invocation with run and agent Langfuse config', async () => {
     const runLangfuse = {
       toolOutputTracing: { enabled: true },

package/src/types/llm.ts

@@ -87,7 +87,7 @@ export type BedrockAnthropicInput = ChatBedrockConverseInput & {
     AnthropicReasoning;
   promptCache?: boolean;
 };
-export type BedrockConverseClientOptions = ChatBedrockConverseInput;
+export type BedrockConverseClientOptions = BedrockAnthropicInput;
 export type BedrockAnthropicClientOptions = BedrockAnthropicInput;
 export type GoogleClientOptions = GoogleGenerativeAIChatInput & {
   customHeaders?: RequestOptions['customHeaders'];
@@ -128,7 +128,7 @@ export type ProviderOptionsMap = {
   [Providers.MISTRALAI]: MistralAIClientOptions;
   [Providers.MISTRAL]: MistralAIClientOptions;
   [Providers.OPENROUTER]: ChatOpenRouterCallOptions;
-  [Providers.BEDROCK]: BedrockConverseClientOptions;
+  [Providers.BEDROCK]: BedrockAnthropicClientOptions;
   [Providers.XAI]: XAIClientOptions;
   [Providers.MOONSHOT]: OpenAIClientOptions;
 };