@librechat/agents 3.2.46 → 3.2.52

package/dist/types/llm/anthropic/utils/tools.d.ts

@@ -1,3 +1,3 @@
 import type { Anthropic } from '@anthropic-ai/sdk';
 import { AnthropicToolChoice } from '../types.js';
-export declare function handleToolChoice(toolChoice?: AnthropicToolChoice): Anthropic.Messages.ToolChoiceAuto | Anthropic.Messages.ToolChoiceAny | Anthropic.Messages.ToolChoiceTool | undefined;
+export declare function handleToolChoice(toolChoice?: AnthropicToolChoice): Anthropic.Messages.ToolChoiceAuto | Anthropic.Messages.ToolChoiceAny | Anthropic.Messages.ToolChoiceTool | Anthropic.Messages.ToolChoiceNone | undefined;

package/dist/types/llm/bedrock/cachePoints.d.ts

@@ -0,0 +1,9 @@
+import type { BedrockPromptCacheControl, ConverseCommandParams } from '@langchain/aws';
+import type * as Bedrock from '@aws-sdk/client-bedrock-runtime';
+export declare function applyCachePointsToConversePayload(fields: {
+    cacheControl?: BedrockPromptCacheControl;
+    system: Bedrock.SystemContentBlock[];
+    messages: Bedrock.Message[];
+    params?: Partial<ConverseCommandParams>;
+    modelId: string;
+}): void;

package/dist/types/run.d.ts

@@ -180,10 +180,24 @@ export declare class Run<_T extends t.BaseGraphState> {
      * paths processed; returns 0 when checkpointing is disabled.
      */
     rewindFiles(): Promise<number>;
+    /**
+     * Resume an interrupted run. `commandOptions` forwards langgraph 1.4.5
+     * `Command` fields applied together with `resume` in one superstep:
+     * - `update`: channel updates committed at the resume point. On a *rebuilt*
+     *   Run (new instance + durable checkpointer), `update.messages` are the first
+     *   write the fresh wrapper sees, so they seed the `getRunMessages()` /
+     *   `returnContent` baseline and are excluded from them (still committed to the
+     *   checkpoint). Hosts that rebuild + inject messages should persist them
+     *   directly or read from `getState`. Unreachable without a durable checkpointer.
+     * - `goto`: a *dynamic* edge that does not cancel static `addEdge` routes. On
+     *   the built-in standard graph the fixed `toolNode -> agentNode/END` edge still
+     *   fires, so `goto` adds rather than replaces (e.g. `goto: END` will not stop a
+     *   tool-node resume). Intended for custom, Command-routed graphs.
+     */
     resume<TResume = t.ToolApprovalDecision[] | t.ToolApprovalDecisionMap>(resumeValue: TResume, callerConfig: Partial<RunnableConfig> & {
         version: 'v1' | 'v2';
         run_id?: string;
-    }, streamOptions?: t.EventStreamOptions): Promise<MessageContentComplex[] | undefined>;
+    }, streamOptions?: t.EventStreamOptions, commandOptions?: Pick<ConstructorParameters<typeof Command>[0], 'update' | 'goto'>): Promise<MessageContentComplex[] | undefined>;
     private resolveInterruptResumeConfig;
     private createSystemCallback;
     getCallbacks(clientCallbacks: t.ClientCallbacks): t.SystemCallbacks;

package/dist/types/tools/ToolNode.d.ts

@@ -11,7 +11,7 @@ import { RunnableCallable } from '@/utils';
  * batch-scoped value the method needs so the signature stays at
  * three positional parameters even as new context fields are added.
  */
-type RunToolBatchContext = {
+type RunToolBatchContext<T = unknown> = {
     /** Position of this call within the parent ToolNode batch. */
     batchIndex?: number;
     /** Batch turn shared across every call in the batch. */
@@ -50,6 +50,13 @@ type RunToolBatchContext = {
      * contract for hosts relying on it for policy / recovery guidance.
      */
     additionalContextsSink?: string[];
+    /**
+     * Graph state the ToolNode was invoked with, threaded from `run()`
+     * so `tool.invoke` can forward it as langgraph 1.4's `runtime.state`
+     * (the deprecation-free replacement for `getCurrentTaskInput()`,
+     * which relies on `node:async_hooks` and is browser-incompatible).
+     */
+    runInput?: T;
 };
 export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
     private toolMap;
@@ -203,7 +210,7 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
      * register the output for future `{{tool<idx>turn<turn>}}`
      * substitutions. Omit when no registration should occur.
      */
-    protected runTool(call: ToolCall, config: RunnableConfig, batchContext?: RunToolBatchContext): Promise<BaseMessage | Command>;
+    protected runTool(call: ToolCall, config: RunnableConfig, batchContext?: RunToolBatchContext<T>): Promise<BaseMessage | Command>;
     /**
      * Runs a single in-process tool call with the same lifecycle hooks
      * the event-dispatch path fires (`PreToolUse`, `PermissionDenied`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.2.46",
+  "version": "3.2.52",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -200,15 +200,10 @@
     "format": "prettier --write ."
   },
   "overrides": {
-    "@langchain/openai": "1.4.5",
-    "@anthropic-ai/sdk": "$@anthropic-ai/sdk",
+    "@langchain/openai": "1.5.3",
     "@browserbasehq/stagehand": {
       "openai": "$openai"
     },
-    "@langchain/google-common": "$@langchain/google-common",
-    "@langchain/google-gauth": "$@langchain/google-gauth",
-    "@langchain/google-genai": "$@langchain/google-genai",
-    "@langchain/google-vertexai": "$@langchain/google-vertexai",
     "uuid": "$uuid",
     "fast-xml-parser": "5.7.2",
     "ajv": "6.14.0",
@@ -217,21 +212,21 @@
     "js-yaml": "^4.2.0"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.92.0",
-    "@aws-sdk/client-bedrock-runtime": "^3.1013.0",
-    "@langchain/anthropic": "^1.3.28",
-    "@langchain/aws": "^1.3.5",
-    "@langchain/core": "1.1.48",
-    "@langchain/deepseek": "^1.0.25",
-    "@langchain/google-common": "2.1.31",
-    "@langchain/google-gauth": "2.1.31",
-    "@langchain/google-genai": "2.1.31",
-    "@langchain/google-vertexai": "2.1.31",
-    "@langchain/langgraph": "^1.2.9",
-    "@langchain/mistralai": "^1.0.8",
-    "@langchain/openai": "1.4.5",
+    "@anthropic-ai/sdk": "^0.103.0",
+    "@aws-sdk/client-bedrock-runtime": "^3.1075.0",
+    "@langchain/anthropic": "^1.5.1",
+    "@langchain/aws": "^1.4.2",
+    "@langchain/core": "^1.2.1",
+    "@langchain/deepseek": "^1.1.3",
+    "@langchain/google-common": "2.2.0",
+    "@langchain/google-gauth": "2.2.0",
+    "@langchain/google-genai": "2.2.0",
+    "@langchain/google-vertexai": "2.2.0",
+    "@langchain/langgraph": "^1.4.5",
+    "@langchain/mistralai": "^1.2.0",
+    "@langchain/openai": "1.5.3",
     "@langchain/textsplitters": "^1.0.1",
-    "@langchain/xai": "^1.3.17",
+    "@langchain/xai": "^1.4.3",
     "@langfuse/langchain": "^5.4.1",
     "@langfuse/otel": "^5.4.1",
     "@langfuse/tracing": "^5.4.1",

package/src/graphs/MultiAgentGraph.ts

@@ -12,12 +12,11 @@ import {
   Command,
   StateGraph,
   Annotation,
-  getCurrentTaskInput,
   messagesStateReducer,
 } from '@langchain/langgraph';
 import type { BaseMessage, AIMessageChunk } from '@langchain/core/messages';
 import type { LangGraphRunnableConfig } from '@langchain/langgraph';
-import type { ToolRunnableConfig } from '@langchain/core/tools';
+import type { ToolRuntime } from '@langchain/core/tools';
 import type * as t from '@/types';
 import { StandardGraph } from './Graph';
 import { Constants } from '@/common';
@@ -330,12 +329,10 @@ export class MultiAgentGraph extends StandardGraph {
 
       tools.push(
         tool(
-          async (rawInput, config) => {
+          async (rawInput, runtime: ToolRuntime) => {
             const input = rawInput as Record<string, unknown>;
-            const state = getCurrentTaskInput() as t.BaseGraphState;
-            const toolCallId =
-              (config as ToolRunnableConfig | undefined)?.toolCall?.id ??
-              'unknown';
+            const state = runtime.state as t.BaseGraphState;
+            const toolCallId = runtime.toolCall?.id ?? 'unknown';
 
             /** Evaluated condition */
             const result = edge.condition!(state);
@@ -414,11 +411,9 @@ export class MultiAgentGraph extends StandardGraph {
 
         tools.push(
           tool(
-            async (rawInput, config) => {
+            async (rawInput, runtime: ToolRuntime) => {
               const input = rawInput as Record<string, unknown>;
-              const toolCallId =
-                (config as ToolRunnableConfig | undefined)?.toolCall?.id ??
-                'unknown';
+              const toolCallId = runtime.toolCall?.id ?? 'unknown';
 
               let content = `Successfully transferred to ${destination}`;
               if (
@@ -439,7 +434,7 @@ export class MultiAgentGraph extends StandardGraph {
                 },
               });
 
-              const state = getCurrentTaskInput() as t.BaseGraphState;
+              const state = runtime.state as t.BaseGraphState;
 
               /**
                * For parallel handoff support:

package/src/llm/anthropic/index.ts

@@ -486,6 +486,7 @@ export class CustomAnthropic extends ChatAnthropicMessages {
       | Anthropic.Messages.ToolChoiceAuto
       | Anthropic.Messages.ToolChoiceAny
       | Anthropic.Messages.ToolChoiceTool
+      | Anthropic.Messages.ToolChoiceNone
       | undefined = handleToolChoice(options?.tool_choice);
 
     const callOptions = options as CustomAnthropicCallOptions | undefined;
@@ -508,12 +509,19 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     const toolBetas = getToolBetas(options?.tools);
     const compactionBetas = getCompactionBetas(contextManagement);
     const taskBudgetBetas = getTaskBudgetBetas(this.model, mergedOutputConfig);
-    const formattedTools = this.formatStructuredToolToAnthropic(options?.tools);
+    const formattedTools = this.formatStructuredToolToAnthropic(
+      options?.tools,
+      {
+        strict: options?.strict,
+      }
+    );
 
     const sharedParams = {
       tools: formattedTools,
       tool_choice,
-      thinking: this.thinking,
+      // Match upstream: omit `thinking` unless the user set it, so we don't send
+      // `{ type: 'disabled' }` (an unsupported param on some models) by default.
+      thinking: this.thinkingExplicitlySet ? this.thinking : undefined,
       context_management: contextManagement,
       ...this.invocationKwargs,
       container: callOptions?.container,
@@ -527,6 +535,9 @@ export class CustomAnthropic extends ChatAnthropicMessages {
       output_config: mergedOutputConfig,
       inference_geo: inferenceGeo,
       mcp_servers: callOptions?.mcp_servers,
+      // Top-level request cache_control (1.5.x): API auto-advances the cache
+      // breakpoint across turns. Additive — independent of our block-level cache.
+      cache_control: options?.cache_control,
     };
     validateInvocationParamCompatibility({
       model: this.model,

package/src/llm/anthropic/inherited-content-utils.spec.ts

@@ -0,0 +1,244 @@
+/**
+ * Inherited Anthropic content/util tests, ported from @langchain/anthropic@1.5.1.
+ *
+ * Upstream sources (vitest), consolidated here and adapted to this fork (jest):
+ *  - src/v1/tests/standard_content.test.ts        (v1 standard content-block conversion)
+ *  - src/utils/tests/message_outputs.test.ts      (message_outputs — copied at utils/message_outputs.ts)
+ *  - src/utils/tests/tools.test.ts                (tools util — copied at utils/tools.ts)
+ *
+ * Adaptation notes:
+ *  - vitest -> jest; `zod/v3` -> `zod`; no `vi.*` usage was needed.
+ *  - The fork copies `message_outputs.ts` and `tools.ts` near-verbatim, so those
+ *    cases are imported and asserted directly against our copies.
+ *  - Upstream's `_formatStandardContent` operates on the v1 `ContentBlock.Multimodal`
+ *    model (`fileId`/`text-plain`/`data: Uint8Array`/`metadata`). This fork does not
+ *    implement that function or the v1 block model; instead it converts the deprecated
+ *    v0.3 `source_type`-based standard blocks via the private `standardContentBlockConverter`,
+ *    reached through the public `_convertMessagesToAnthropicPayload`. The standard-content
+ *    cases below are therefore routed through that path and assert the fork's equivalent
+ *    output. Cases with no fork equivalent are dropped inline with a reason.
+ */
+import { HumanMessage } from '@langchain/core/messages';
+import { _makeMessageChunkFromAnthropicEvent } from './utils/message_outputs';
+import { _convertMessagesToAnthropicPayload } from './utils/message_inputs';
+import { handleToolChoice } from './utils/tools';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/**
+ * Helper mirroring upstream's `createAnthropicMessage`, but using this fork's
+ * conversion entry point. Upstream wrapped raw v1 `contentBlocks` and called
+ * `_formatStandardContent`; here we send deprecated v0.3 standard blocks through
+ * `_convertMessagesToAnthropicPayload` and read back the converted human-turn content.
+ */
+function convertStandardBlock(block: Record<string, unknown>): unknown {
+  const payload = _convertMessagesToAnthropicPayload([
+    new HumanMessage({ content: [block as any] }),
+  ]);
+  const human = payload.messages.find((m: any) => m.role === 'user')!;
+  return (human.content as unknown[])[0];
+}
+
+describe('standard content-block conversion (ported from standard_content.test.ts)', () => {
+  // Adapted: upstream converted a v1 `file` block backed by a `fileId` into a
+  // `{ source: { type: 'file', file_id } }` document. This fork has no fileId
+  // source type; the metadata passthrough (cache_control/citations/context/title)
+  // is the load-bearing behavior, so we assert it on a URL-backed file document.
+  it('converts file blocks into Anthropic documents and forwards metadata', () => {
+    const content = convertStandardBlock({
+      type: 'file',
+      source_type: 'url',
+      url: 'https://example.com/doc.pdf',
+      mime_type: 'application/pdf',
+      metadata: {
+        cache_control: { type: 'ephemeral', ttl: '5m' },
+        citations: { enabled: true },
+        context: 'source context',
+        title: 'My Document',
+      },
+    });
+
+    expect(content).toMatchObject({
+      type: 'document',
+      source: { type: 'url', url: 'https://example.com/doc.pdf' },
+      cache_control: { type: 'ephemeral', ttl: '5m' },
+      citations: { enabled: true },
+      context: 'source context',
+      title: 'My Document',
+    });
+  });
+
+  it('converts inlined text files into text document sources', () => {
+    const content = convertStandardBlock({
+      type: 'file',
+      source_type: 'text',
+      text: 'Plain text body',
+      mime_type: 'text/plain',
+    });
+
+    expect(content).toMatchObject({
+      type: 'document',
+      source: {
+        type: 'text',
+        data: 'Plain text body',
+        media_type: 'text/plain',
+      },
+    });
+  });
+
+  it('wraps base64 image file payloads in document content blocks', () => {
+    // Upstream passed a Uint8Array and asserted Buffer.from(..).toString('base64');
+    // this fork takes a pre-encoded base64 string, so we pass the encoded value.
+    const data = Buffer.from(Uint8Array.from([1, 2, 3])).toString('base64');
+    const content = convertStandardBlock({
+      type: 'file',
+      source_type: 'base64',
+      data,
+      mime_type: 'image/png',
+    });
+
+    expect(content).toMatchObject({
+      type: 'document',
+      source: {
+        type: 'content',
+        content: [
+          {
+            type: 'image',
+            source: {
+              type: 'base64',
+              data,
+              media_type: 'image/png',
+            },
+          },
+        ],
+      },
+    });
+  });
+
+  it('converts standard image blocks with metadata', () => {
+    const content = convertStandardBlock({
+      type: 'image',
+      source_type: 'url',
+      url: 'https://example.com/image.png',
+      metadata: {
+        cache_control: { type: 'ephemeral', ttl: '1h' },
+      },
+    });
+
+    expect(content).toMatchObject({
+      type: 'image',
+      source: { type: 'url', url: 'https://example.com/image.png' },
+      cache_control: { type: 'ephemeral', ttl: '1h' },
+    });
+  });
+
+  // Dropped (inherited): upstream's "promotes plain text blocks to Anthropic text
+  // documents" exercises the v1 `text-plain` content-block type, which this fork does
+  // not model. The equivalent text->document-source path is already covered by the
+  // "inlined text files" case above (v0.3 `file`/`source_type: 'text'`).
+
+  it('throws for unsupported audio blocks', () => {
+    // Upstream threw /does not support audio/i. This fork throws from the standard
+    // converter because it intentionally implements no `fromStandardAudioBlock`,
+    // so we assert the fork's actual message.
+    expect(() =>
+      convertStandardBlock({
+        type: 'audio',
+        source_type: 'base64',
+        data: 'AQID',
+        mime_type: 'audio/mpeg',
+      })
+    ).toThrow(/fromStandardAudioBlock/);
+  });
+});
+
+describe('_makeMessageChunkFromAnthropicEvent (ported from message_outputs.test.ts)', () => {
+  const fields = { streamUsage: true, coerceContentToString: false };
+
+  it('message_start chunk contains correct cache token counts', () => {
+    const event = {
+      type: 'message_start' as const,
+      message: {
+        id: 'msg_01',
+        type: 'message' as const,
+        role: 'assistant' as const,
+        content: [],
+        model: 'claude-3-5-haiku-latest',
+        stop_reason: null,
+        stop_sequence: null,
+        usage: {
+          input_tokens: 100,
+          output_tokens: 0,
+          cache_creation_input_tokens: 500,
+          cache_read_input_tokens: 1000,
+        },
+      },
+    };
+
+    const result = _makeMessageChunkFromAnthropicEvent(event as any, fields);
+    expect(result).not.toBeNull();
+
+    const usage = result!.chunk.usage_metadata!;
+    // input_tokens in LangChain = input_tokens + cache_creation + cache_read
+    expect(usage.input_tokens).toBe(1600);
+    expect(usage.input_token_details?.cache_creation).toBe(500);
+    expect(usage.input_token_details?.cache_read).toBe(1000);
+  });
+
+  it('message_delta chunk has input_tokens=0 and no cache token details', () => {
+    const event = {
+      type: 'message_delta' as const,
+      delta: { stop_reason: 'end_turn' as const, stop_sequence: null },
+      usage: {
+        input_tokens: 100,
+        output_tokens: 42,
+        // Anthropic API returns cumulative cache values here — same as message_start
+        cache_creation_input_tokens: 500,
+        cache_read_input_tokens: 1000,
+      },
+    };
+
+    const result = _makeMessageChunkFromAnthropicEvent(event as any, fields);
+    expect(result).not.toBeNull();
+
+    const usage = result!.chunk.usage_metadata!;
+    expect(usage.output_tokens).toBe(42);
+    expect(usage.input_tokens).toBe(0);
+    expect(usage.input_token_details?.cache_creation).toBeUndefined();
+    expect(usage.input_token_details?.cache_read).toBeUndefined();
+  });
+});
+
+describe('handleToolChoice (ported from tools.test.ts)', () => {
+  it('should return undefined for undefined input', () => {
+    expect(handleToolChoice(undefined)).toBeUndefined();
+  });
+
+  it("should handle 'any' tool choice", () => {
+    expect(handleToolChoice('any')).toEqual({ type: 'any' });
+  });
+
+  it("maps OpenAI-style 'required' to Anthropic 'any'", () => {
+    expect(handleToolChoice('required')).toEqual({ type: 'any' });
+  });
+
+  it("should handle 'auto' tool choice", () => {
+    expect(handleToolChoice('auto')).toEqual({ type: 'auto' });
+  });
+
+  it("maps 'none' to Anthropic 'none' (disables tools)", () => {
+    expect(handleToolChoice('none')).toEqual({ type: 'none' });
+  });
+
+  it('should handle specific tool name as string', () => {
+    expect(handleToolChoice('my_custom_tool')).toEqual({
+      type: 'tool',
+      name: 'my_custom_tool',
+    });
+  });
+
+  it('should pass through object tool choice', () => {
+    const toolChoice = { type: 'tool' as const, name: 'specific_tool' };
+    expect(handleToolChoice(toolChoice)).toEqual(toolChoice);
+  });
+});