@librechat/agents 3.2.46 → 3.2.52

package/src/llm/anthropic/inherited-strict.spec.ts

@@ -0,0 +1,302 @@
+// Inherited from @langchain/anthropic@1.5.1 tests/chat_models.test.ts (strict tool calling), adapted to LibreChat's fork.
+import { z } from 'zod';
+import { tool } from '@langchain/core/tools';
+import { describe, test, expect, jest } from '@jest/globals';
+import { CustomAnthropic as ChatAnthropic } from '@/llm/anthropic';
+
+test('extras with cache_control are merged into tool definitions', () => {
+  const searchFiles = tool(
+    async (input: { query: string }) => {
+      return `Results for ${input.query}`;
+    },
+    {
+      name: 'search_files',
+      description: 'Search files.',
+      schema: z.object({
+        query: z.string(),
+      }),
+      extras: { cache_control: { type: 'ephemeral' } },
+    }
+  );
+
+  const model = new ChatAnthropic({
+    modelName: 'claude-haiku-4-5-20251001',
+    anthropicApiKey: 'testing',
+  });
+
+  const formattedTools = model.formatStructuredToolToAnthropic([searchFiles]);
+
+  expect(formattedTools).toBeDefined();
+  const searchTool = formattedTools?.find(
+    (t) => 'name' in t && t.name === 'search_files'
+  );
+  expect(searchTool).toBeDefined();
+  expect(searchTool).toHaveProperty('cache_control', { type: 'ephemeral' });
+});
+
+describe('strict tool calling', () => {
+  const weatherTool = tool(
+    async (input: { location: string }) => `Weather in ${input.location}`,
+    {
+      name: 'get_current_weather',
+      description: 'Get the current weather in a location',
+      schema: z.object({
+        location: z.string().describe('The location to get the weather for'),
+      }),
+    }
+  );
+
+  const strictWeatherTool = tool(
+    async (input: { location: string }) => `Weather in ${input.location}`,
+    {
+      name: 'get_current_weather',
+      description: 'Get the current weather in a location',
+      schema: z.object({ location: z.string() }),
+      extras: { strict: true },
+    }
+  );
+
+  const openAIShapedWeatherTool = {
+    type: 'function' as const,
+    function: {
+      name: 'get_current_weather',
+      description: 'Get the current weather in a location',
+      parameters: {
+        type: 'object',
+        properties: { location: { type: 'string' } },
+        required: ['location'],
+      },
+      strict: true,
+    },
+  };
+
+  const anthropicShapedWeatherTool = {
+    name: 'get_current_weather',
+    description: 'Get the current weather in a location',
+    input_schema: {
+      type: 'object' as const,
+      properties: { location: { type: 'string' } },
+      required: ['location'],
+    },
+    strict: true,
+  };
+
+  type MockFetch = jest.Mock<
+    (url: string | URL | Request, options?: RequestInit) => Promise<Response>
+  >;
+
+  function makeMockFetch(): MockFetch {
+    const mockFetch =
+      jest.fn<
+        (
+          url: string | URL | Request,
+          options?: RequestInit
+        ) => Promise<Response>
+      >();
+    mockFetch.mockImplementation((_url, _options) =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify({
+            id: 'msg_test',
+            type: 'message',
+            role: 'assistant',
+            model: 'claude-haiku-4-5-20251001',
+            // `tool_use` shape (not text) is required so `withStructuredOutput`
+            // can parse a tool call out of the response.
+            content: [
+              {
+                type: 'tool_use',
+                id: 'toolu_test',
+                name: 'get_current_weather',
+                input: { location: 'test' },
+              },
+            ],
+            stop_reason: 'tool_use',
+            stop_sequence: null,
+            usage: { input_tokens: 1, output_tokens: 1 },
+          }),
+          {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+          }
+        )
+      )
+    );
+    return mockFetch;
+  }
+
+  function makeMockedModel(): { model: ChatAnthropic; mockFetch: MockFetch } {
+    const mockFetch = makeMockFetch();
+    const model = new ChatAnthropic({
+      model: 'claude-haiku-4-5-20251001',
+      anthropicApiKey: 'testing',
+      clientOptions: { fetch: mockFetch },
+      maxRetries: 0,
+    });
+    return { model, mockFetch };
+  }
+
+  function getRequestTools(
+    mockFetch: MockFetch
+  ): Array<Record<string, unknown>> {
+    expect(mockFetch).toHaveBeenCalled();
+    const [, init] = mockFetch.mock.calls[0];
+    if (!init || !init.body) {
+      throw new Error('Body not found in request.');
+    }
+    const body = JSON.parse(init.body as string) as {
+      tools: Array<Record<string, unknown>>;
+    };
+    return body.tools;
+  }
+
+  test('applies strict from .bindTools call args', async () => {
+    const { model, mockFetch } = makeMockedModel();
+    const modelWithTools = model.bindTools([weatherTool], { strict: true });
+    await modelWithTools.invoke("What's the weather like?");
+    expect(getRequestTools(mockFetch)[0]).toHaveProperty('strict', true);
+  });
+
+  test('applies strict from .withConfig call options', async () => {
+    const { model, mockFetch } = makeMockedModel();
+    const modelWithTools = model.withConfig({
+      tools: [weatherTool],
+      strict: true,
+    });
+    await modelWithTools.invoke("What's the weather like?");
+    expect(getRequestTools(mockFetch)[0]).toHaveProperty('strict', true);
+  });
+
+  test('applies strict from .bindTools(...).withConfig({ strict })', async () => {
+    const { model, mockFetch } = makeMockedModel();
+    const modelWithTools = model
+      .bindTools([weatherTool])
+      .withConfig({ strict: true });
+    await modelWithTools.invoke("What's the weather like?");
+    expect(getRequestTools(mockFetch)[0]).toHaveProperty('strict', true);
+  });
+
+  test('applies strict from per-call invoke options', async () => {
+    const { model, mockFetch } = makeMockedModel();
+    const modelWithTools = model.bindTools([weatherTool]);
+    await modelWithTools.invoke("What's the weather like?", { strict: true });
+    expect(getRequestTools(mockFetch)[0]).toHaveProperty('strict', true);
+  });
+
+  test('per-call invoke strict overrides .bindTools strict', async () => {
+    const { model, mockFetch } = makeMockedModel();
+    const modelWithTools = model.bindTools([weatherTool], { strict: true });
+    await modelWithTools.invoke("What's the weather like?", { strict: false });
+    expect(getRequestTools(mockFetch)[0]).toHaveProperty('strict', false);
+  });
+
+  test('applies strict from .withStructuredOutput config', async () => {
+    const { model, mockFetch } = makeMockedModel();
+    const modelWithTools = model.withStructuredOutput(
+      z.object({
+        location: z.string().describe('The location to get the weather for'),
+      }),
+      { strict: true, method: 'functionCalling' }
+    );
+    await modelWithTools.invoke("What's the weather like?");
+    expect(getRequestTools(mockFetch)[0]).toHaveProperty('strict', true);
+  });
+
+  test('omits strict when not provided anywhere', async () => {
+    const { model, mockFetch } = makeMockedModel();
+    const modelWithTools = model.bindTools([weatherTool]);
+    await modelWithTools.invoke("What's the weather like?");
+    expect(getRequestTools(mockFetch)[0]).not.toHaveProperty('strict');
+  });
+
+  test('omits strict when not passed in .withStructuredOutput', async () => {
+    const { model, mockFetch } = makeMockedModel();
+    const modelWithTools = model.withStructuredOutput(
+      z.object({
+        location: z.string().describe('The location to get the weather for'),
+      }),
+      { method: 'functionCalling' }
+    );
+    await modelWithTools.invoke("What's the weather like?");
+    expect(getRequestTools(mockFetch)[0]).not.toHaveProperty('strict');
+  });
+
+  test('per-tool extras.strict applies to that tool only', async () => {
+    const { model, mockFetch } = makeMockedModel();
+    const looseSearchTool = tool(
+      async (input: { query: string }) => `Results for ${input.query}`,
+      {
+        name: 'search',
+        description: 'Search the web',
+        schema: z.object({ query: z.string() }),
+      }
+    );
+    const modelWithTools = model.bindTools([
+      strictWeatherTool,
+      looseSearchTool,
+    ]);
+    await modelWithTools.invoke("What's the weather like?");
+    const tools = getRequestTools(mockFetch);
+    const strictTool = tools.find((t) => t.name === 'get_current_weather');
+    const looseTool = tools.find((t) => t.name === 'search');
+    expect(strictTool).toHaveProperty('strict', true);
+    expect(looseTool).not.toHaveProperty('strict');
+  });
+
+  test('per-tool function.strict applies on OpenAI-shaped tools', async () => {
+    const { model, mockFetch } = makeMockedModel();
+    const modelWithTools = model.bindTools([openAIShapedWeatherTool]);
+    await modelWithTools.invoke("What's the weather like?");
+    expect(getRequestTools(mockFetch)[0]).toHaveProperty('strict', true);
+  });
+
+  test("per-call strict overrides OpenAI-shaped tool's function.strict", async () => {
+    const { model, mockFetch } = makeMockedModel();
+    const modelWithTools = model.bindTools([openAIShapedWeatherTool], {
+      strict: false,
+    });
+    await modelWithTools.invoke("What's the weather like?");
+    expect(getRequestTools(mockFetch)[0]).toHaveProperty('strict', false);
+  });
+
+  test('per-tool native strict applies on Anthropic-shaped tools', async () => {
+    const { model, mockFetch } = makeMockedModel();
+    const modelWithTools = model.bindTools([anthropicShapedWeatherTool]);
+    await modelWithTools.invoke("What's the weather like?");
+    expect(getRequestTools(mockFetch)[0]).toHaveProperty('strict', true);
+  });
+
+  test("per-call strict overrides Anthropic-shaped tool's own strict", async () => {
+    const { model, mockFetch } = makeMockedModel();
+    const modelWithTools = model.bindTools([anthropicShapedWeatherTool], {
+      strict: false,
+    });
+    await modelWithTools.invoke("What's the weather like?");
+    expect(getRequestTools(mockFetch)[0]).toHaveProperty('strict', false);
+  });
+
+  test('per-call strict overrides per-tool extras.strict', async () => {
+    const { model, mockFetch } = makeMockedModel();
+    const modelWithTools = model.bindTools([strictWeatherTool], {
+      strict: false,
+    });
+    await modelWithTools.invoke("What's the weather like?");
+    expect(getRequestTools(mockFetch)[0]).toHaveProperty('strict', false);
+  });
+
+  test.each([['jsonSchema'], ['jsonMode']])(
+    'withStructuredOutput throws when strict is set with method = %s',
+    (method) => {
+      const model = new ChatAnthropic({
+        model: 'claude-haiku-4-5-20251001',
+        anthropicApiKey: 'testing',
+      });
+      expect(() =>
+        model.withStructuredOutput(z.object({ location: z.string() }), {
+          strict: true,
+          method: method as 'jsonSchema' | 'jsonMode',
+        })
+      ).toThrow(/strict.*functionCalling/);
+    }
+  );
+});

package/src/llm/anthropic/llm.spec.ts

@@ -2087,6 +2087,71 @@ describe('Citations', () => {
   });
 });
 
+// Inherited from @langchain/anthropic@1.5.1 tests/chat_models.test.ts — verifies
+// the fork honors upstream's `thinkingExplicitlySet` gating in invocationParams.
+describe('invocationParams thinking gating', () => {
+  test('omits thinking when not explicitly configured', () => {
+    const model = new ChatAnthropic({
+      model: 'claude-haiku-4-5-20251001',
+      apiKey: 'testing',
+    });
+
+    expect(model.invocationParams({}).thinking).toBeUndefined();
+  });
+
+  test('includes thinking when explicitly disabled', () => {
+    const model = new ChatAnthropic({
+      model: 'claude-haiku-4-5-20251001',
+      apiKey: 'testing',
+      thinking: { type: 'disabled' },
+    });
+
+    expect(model.invocationParams({}).thinking).toEqual({ type: 'disabled' });
+  });
+
+  test('includes thinking when explicitly enabled', () => {
+    const model = new ChatAnthropic({
+      model: 'claude-haiku-4-5-20251001',
+      temperature: 1,
+      apiKey: 'testing',
+      thinking: { type: 'enabled', budget_tokens: 1000 },
+    });
+
+    expect(model.invocationParams({}).thinking).toEqual({
+      type: 'enabled',
+      budget_tokens: 1000,
+    });
+  });
+});
+
+// Inherited from @langchain/anthropic@1.5.1 — top-level request cache_control.
+describe('invocationParams cache_control', () => {
+  const newModel = () =>
+    new ChatAnthropic({
+      model: 'claude-haiku-4-5-20251001',
+      apiKey: 'testing',
+    });
+
+  test('includes cache_control when provided in call options', () => {
+    expect(
+      newModel().invocationParams({ cache_control: { type: 'ephemeral' } })
+        .cache_control
+    ).toEqual({ type: 'ephemeral' });
+  });
+
+  test('includes cache_control with 1h ttl', () => {
+    expect(
+      newModel().invocationParams({
+        cache_control: { type: 'ephemeral', ttl: '1h' },
+      }).cache_control
+    ).toEqual({ type: 'ephemeral', ttl: '1h' });
+  });
+
+  test('omits cache_control when not provided', () => {
+    expect(newModel().invocationParams({}).cache_control).toBeUndefined();
+  });
+});
+
 describe('Opus 4.7', () => {
   test('default max_tokens for claude-opus-4-7 is 16384', () => {
     const model = new ChatAnthropic({

package/src/llm/anthropic/utils/tools.ts

@@ -7,10 +7,12 @@ export function handleToolChoice(
   | Anthropic.Messages.ToolChoiceAuto
   | Anthropic.Messages.ToolChoiceAny
   | Anthropic.Messages.ToolChoiceTool
+  | Anthropic.Messages.ToolChoiceNone
   | undefined {
   if (toolChoice == null) {
     return undefined;
-  } else if (toolChoice === 'any') {
+  } else if (toolChoice === 'any' || toolChoice === 'required') {
+    // "required" is the OpenAI-style alias for forcing tool use.
     return {
       type: 'any',
     };
@@ -18,6 +20,10 @@ export function handleToolChoice(
     return {
       type: 'auto',
     };
+  } else if (toolChoice === 'none') {
+    return {
+      type: 'none',
+    };
   } else if (typeof toolChoice === 'string') {
     return {
       type: 'tool',

package/src/llm/bedrock/cachePoints.ts

@@ -0,0 +1,86 @@
+// Vendored from @langchain/aws@1.4.2 (utils/message_inputs.ts) because the
+// upstream `applyCachePointsToConversePayload` export is internal.
+import type {
+  BedrockPromptCacheControl,
+  ConverseCommandParams,
+} from '@langchain/aws';
+import type * as Bedrock from '@aws-sdk/client-bedrock-runtime';
+
+function isConverseCachePoint(block: unknown): boolean {
+  return Boolean(
+    typeof block === 'object' &&
+      block !== null &&
+      'cachePoint' in block &&
+      block.cachePoint &&
+      typeof block.cachePoint === 'object' &&
+      block.cachePoint !== null &&
+      'type' in block.cachePoint
+  );
+}
+
+function createConverseCachePointBlock(
+  cacheControl: BedrockPromptCacheControl,
+  isNovaModel: boolean
+): { cachePoint: { type: 'default'; ttl?: '1h' } } {
+  const ttl =
+    !isNovaModel && cacheControl.ttl && cacheControl.ttl !== '5m'
+      ? cacheControl.ttl
+      : undefined;
+  return {
+    cachePoint: {
+      type: 'default',
+      ...(ttl ? { ttl } : {}),
+    },
+  };
+}
+
+export function applyCachePointsToConversePayload(fields: {
+  cacheControl?: BedrockPromptCacheControl;
+  system: Bedrock.SystemContentBlock[];
+  messages: Bedrock.Message[];
+  params?: Partial<ConverseCommandParams>;
+  modelId: string;
+}): void {
+  const { cacheControl, system, messages, params, modelId } = fields;
+  if (!cacheControl) {
+    return;
+  }
+
+  const isNovaModel = modelId.toLowerCase().includes('amazon.nova');
+  const cacheBlock = createConverseCachePointBlock(cacheControl, isNovaModel);
+
+  if (
+    system.length > 0 &&
+    !system.some((block) => isConverseCachePoint(block))
+  ) {
+    system.push(cacheBlock);
+  }
+
+  const lastMessage = messages[messages.length - 1];
+  const lastContent = lastMessage.content;
+  if (Array.isArray(lastContent)) {
+    const hasNovaToolBlock =
+      isNovaModel &&
+      lastContent.some(
+        (block) =>
+          typeof block === 'object' &&
+          block !== null &&
+          ('toolResult' in block || 'toolUse' in block)
+      );
+    if (
+      !hasNovaToolBlock &&
+      !lastContent.some((block) => isConverseCachePoint(block))
+    ) {
+      lastContent.push(cacheBlock);
+    }
+  }
+
+  const tools = params?.toolConfig?.tools;
+  if (
+    !isNovaModel &&
+    Array.isArray(tools) &&
+    !tools.some((tool) => isConverseCachePoint(tool))
+  ) {
+    tools.push(cacheBlock as unknown as Bedrock.Tool);
+  }
+}

package/src/llm/bedrock/index.ts

@@ -44,6 +44,7 @@ import {
   supportsBedrockToolCache,
   type PromptCacheTtl,
 } from '@/messages/cache';
+import { applyCachePointsToConversePayload } from './cachePoints';
 import { insertBedrockToolCachePoint } from './toolCache';
 
 /**
@@ -245,6 +246,14 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
 
     const modelId = this.getModelId();
 
+    applyCachePointsToConversePayload({
+      cacheControl: options.cache_control,
+      system: converseSystem,
+      messages: converseMessages,
+      params,
+      modelId,
+    });
+
     const command = new ConverseStreamCommand({
       modelId,
       messages: converseMessages,

package/src/llm/bedrock/inherited-cache.spec.ts

@@ -0,0 +1,144 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { expect, test, describe, jest } from '@jest/globals';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import {
+  BedrockRuntimeClient,
+  ConverseCommand,
+  ConverseStreamCommand,
+} from '@aws-sdk/client-bedrock-runtime';
+import type {
+  ConverseCommandInput,
+  ConverseStreamCommandInput,
+} from '@aws-sdk/client-bedrock-runtime';
+import { CustomChatBedrockConverse as ChatBedrockConverse } from './index';
+
+jest.setTimeout(120000);
+
+const baseConstructorArgs = {
+  region: 'us-east-1',
+  credentials: {
+    secretAccessKey: 'test-secret',
+    accessKeyId: 'test-key',
+  },
+  model: 'anthropic.claude-3-sonnet-20240229-v1:0',
+};
+
+function nonStreamingClient(): {
+  client: BedrockRuntimeClient;
+  send: ReturnType<typeof jest.fn>;
+} {
+  const send = jest.fn<any>().mockResolvedValue({
+    output: {
+      message: {
+        role: 'assistant',
+        content: [{ text: 'Response' }],
+      },
+    },
+    usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+  });
+  return { client: { send } as unknown as BedrockRuntimeClient, send };
+}
+
+function streamingClient(): {
+  client: BedrockRuntimeClient;
+  send: ReturnType<typeof jest.fn>;
+} {
+  const send = jest.fn<any>().mockResolvedValue({
+    stream: (async function* streamChunks() {
+      yield {
+        contentBlockDelta: {
+          contentBlockIndex: 0,
+          delta: { text: 'Response' },
+        },
+      };
+      yield {
+        metadata: {
+          usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+        },
+      };
+    })(),
+  });
+  return { client: { send } as unknown as BedrockRuntimeClient, send };
+}
+
+describe('CustomChatBedrockConverse prompt caching request mapping', () => {
+  test('invoke maps cache_control to system, messages, and tools', async () => {
+    const { client, send } = nonStreamingClient();
+    const model = new ChatBedrockConverse({ ...baseConstructorArgs, client });
+
+    await model.invoke(
+      [new SystemMessage('System prompt'), new HumanMessage('Hello')],
+      {
+        cache_control: { type: 'ephemeral', ttl: '1h' },
+        tools: [
+          {
+            toolSpec: {
+              name: 'get_weather',
+              description: 'Get weather',
+              inputSchema: {
+                json: { type: 'object', properties: {} },
+              },
+            },
+          },
+        ],
+      }
+    );
+
+    expect(send).toHaveBeenCalledTimes(1);
+    const command = send.mock.calls[0][0] as ConverseCommand;
+    expect(command).toBeInstanceOf(ConverseCommand);
+    const input = command.input as ConverseCommandInput;
+
+    expect(input.system).toEqual([
+      { text: 'System prompt' },
+      { cachePoint: { type: 'default', ttl: '1h' } },
+    ]);
+    expect(input.messages?.[0].content).toEqual([
+      { text: 'Hello' },
+      { cachePoint: { type: 'default', ttl: '1h' } },
+    ]);
+    expect(input.toolConfig?.tools).toEqual([
+      {
+        toolSpec: {
+          name: 'get_weather',
+          description: 'Get weather',
+          inputSchema: {
+            json: { type: 'object', properties: {} },
+          },
+        },
+      },
+      { cachePoint: { type: 'default', ttl: '1h' } },
+    ]);
+  });
+
+  test('stream maps cache_control to system and last message', async () => {
+    const { client, send } = streamingClient();
+    const model = new ChatBedrockConverse({ ...baseConstructorArgs, client });
+
+    const stream = await model.stream(
+      [new SystemMessage('System prompt'), new HumanMessage('Hello')],
+      {
+        cache_control: { type: 'ephemeral' },
+      }
+    );
+    for await (const _chunk of stream) {
+      // Fully consume stream so the command is executed.
+    }
+
+    expect(send).toHaveBeenCalledTimes(1);
+    const command = send.mock.calls[0][0] as ConverseStreamCommand;
+    expect(command).toBeInstanceOf(ConverseStreamCommand);
+    const input = command.input as ConverseStreamCommandInput;
+
+    expect(input.system).toEqual([
+      { text: 'System prompt' },
+      { cachePoint: { type: 'default' } },
+    ]);
+    expect(input.messages?.[0].content).toEqual([
+      { text: 'Hello' },
+      { cachePoint: { type: 'default' } },
+    ]);
+  });
+
+  // Dropped (inherited): live
+});