@librechat/agents 3.1.56 → 3.1.60

package/src/index.ts

@@ -8,6 +8,9 @@ export * from './messages';
 /* Graphs */
 export * from './graphs';
 
+/* Summarization */
+export * from './summarization';
+
 /* Tools */
 export * from './tools/Calculator';
 export * from './tools/CodeExecutor';
@@ -33,3 +36,7 @@ export type {
   OpenRouterReasoningEffort,
   ChatOpenRouterCallOptions,
 } from './llm/openrouter';
+export { getChatModelClass } from './llm/providers';
+export { initializeModel } from './llm/init';
+export { attemptInvoke, tryFallbackProviders } from './llm/invoke';
+export { isThinkingEnabled, getMaxOutputTokensKey } from './llm/request';

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

@@ -56,13 +56,13 @@ async function invoke(
 }
 
 // use this for tests involving "extended thinking"
-const extendedThinkingModelName = 'claude-3-7-sonnet-20250219';
+const extendedThinkingModelName = 'claude-sonnet-4-5-20250929';
 
 // use this for tests involving citations
 const citationsModelName = 'claude-sonnet-4-5-20250929';
 
 // use this for tests involving PDF documents
-const pdfModelName = 'claude-3-5-haiku-20241022';
+const pdfModelName = 'claude-haiku-4-5';
 
 // Use this model for all other tests
 const modelName = 'claude-3-haiku-20240307';
@@ -1401,7 +1401,7 @@ test('Test redacted thinking blocks multiturn streaming', async () => {
 
 test('Can handle google function calling blocks in content', async () => {
   const chat = new ChatAnthropic({
-    modelName: 'claude-3-7-sonnet-latest',
+    modelName: 'claude-sonnet-4-5-20250929',
     maxRetries: 0,
   });
   const toolCallId = 'tool_call_id';

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

@@ -34,6 +34,7 @@ import {
   AnthropicCompactionBlockParam,
   AnthropicToolResponse,
 } from '../types';
+import { Constants } from '@/common';
 
 function _formatImage(imageUrl: string) {
   const parsed = parseBase64DataUrl({ dataUrl: imageUrl });
@@ -377,8 +378,7 @@ function _formatContent(message: BaseMessage) {
         const rawPart = contentPart as Record<string, unknown>;
         const id = rawPart.id as string;
 
-        // Only correct if this is definitely a server tool (ID starts with 'srvtoolu_')
-        if (id && id.startsWith('srvtoolu_')) {
+        if (id && id.startsWith(Constants.ANTHROPIC_SERVER_TOOL_PREFIX)) {
           let input = rawPart.input;
 
           // Ensure input is an object
@@ -420,8 +420,10 @@ function _formatContent(message: BaseMessage) {
         const toolUseId = rawPart.tool_use_id as string;
         const content = rawPart.content;
 
-        // Only correct if this is definitely a server tool result (tool_use_id starts with 'srvtoolu_')
-        if (toolUseId && toolUseId.startsWith('srvtoolu_')) {
+        if (
+          toolUseId &&
+          toolUseId.startsWith(Constants.ANTHROPIC_SERVER_TOOL_PREFIX)
+        ) {
           // Verify content is either an array (success) or error object
           const isValidContent =
             Array.isArray(content) ||

package/src/llm/bedrock/llm.spec.ts

@@ -795,7 +795,7 @@ describe.skip('Integration tests', () => {
   test('with thinking/reasoning enabled', async () => {
     const model = new CustomChatBedrockConverse({
       ...integrationArgs,
-      model: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
+      model: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0',
       maxTokens: 5000,
       additionalModelRequestFields: {
         thinking: { type: 'enabled', budget_tokens: 2000 },

package/src/llm/bedrock/utils/message_inputs.ts

@@ -316,9 +316,13 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
     const contentBlocks: BedrockContentBlock[] = [];
 
     concatenatedBlocks.forEach((block) => {
-      if (block.type === 'text' && (block as { text?: string }).text !== '') {
+      if (block.type === 'text') {
+        const text = (block as { text?: string }).text ?? '';
+        // Skip completely empty text blocks (common in AI messages with tool_use blocks)
+        if (text === '') {
+          return;
+        }
         // Merge whitespace/newlines with previous text blocks to avoid validation errors.
-        const text = (block as { text: string }).text;
         const cleanedText = text.replace(/\n/g, '').trim();
         if (cleanedText === '') {
           if (contentBlocks.length > 0) {

package/src/llm/init.ts

@@ -0,0 +1,63 @@
+import { ChatVertexAI } from '@langchain/google-vertexai';
+import type { Runnable } from '@langchain/core/runnables';
+import type * as t from '@/types';
+import { ChatOpenAI, AzureChatOpenAI } from '@/llm/openai';
+import { getChatModelClass } from '@/llm/providers';
+import { isOpenAILike } from '@/utils';
+import { Providers } from '@/common';
+
+/**
+ * Creates a chat model instance for a given provider, applies provider-specific
+ * field assignments, and optionally binds tools.
+ *
+ * This is the single entry point for model creation across the codebase — used
+ * by both the agent graph (main LLM) and the summarization node (compaction LLM).
+ * An optional `override` model can be passed to skip construction entirely
+ * (useful for cached/reused model instances or test fakes).
+ */
+export function initializeModel({
+  provider,
+  clientOptions,
+  tools,
+  override,
+}: {
+  provider: Providers;
+  clientOptions?: t.ClientOptions;
+  tools?: t.GraphTools;
+  override?: t.ChatModelInstance;
+}): Runnable {
+  const model =
+    override ??
+    new (getChatModelClass(provider))(clientOptions ?? ({} as never));
+
+  if (
+    isOpenAILike(provider) &&
+    (model instanceof ChatOpenAI || model instanceof AzureChatOpenAI)
+  ) {
+    const opts = clientOptions as t.OpenAIClientOptions | undefined;
+    if (opts) {
+      model.temperature = opts.temperature as number;
+      model.topP = opts.topP as number;
+      model.frequencyPenalty = opts.frequencyPenalty as number;
+      model.presencePenalty = opts.presencePenalty as number;
+      model.n = opts.n as number;
+    }
+  } else if (provider === Providers.VERTEXAI && model instanceof ChatVertexAI) {
+    const opts = clientOptions as t.VertexAIClientOptions | undefined;
+    if (opts) {
+      model.temperature = opts.temperature as number;
+      model.topP = opts.topP as number;
+      model.topK = opts.topK as number;
+      model.topLogprobs = opts.topLogprobs as number;
+      model.frequencyPenalty = opts.frequencyPenalty as number;
+      model.presencePenalty = opts.presencePenalty as number;
+      model.maxOutputTokens = opts.maxOutputTokens as number;
+    }
+  }
+
+  if (!tools || tools.length === 0) {
+    return model as unknown as Runnable;
+  }
+
+  return (model as t.ModelWithTools).bindTools(tools);
+}

package/src/llm/invoke.ts

@@ -0,0 +1,144 @@
+import { concat } from '@langchain/core/utils/stream';
+import { AIMessageChunk } from '@langchain/core/messages';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type { ToolCall } from '@langchain/core/messages/tool';
+import type { BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { manualToolStreamProviders } from '@/llm/providers';
+import { modifyDeltaProperties } from '@/messages';
+import { ChatModelStreamHandler } from '@/stream';
+import { GraphEvents, Providers } from '@/common';
+import { initializeModel } from '@/llm/init';
+
+/**
+ * Context passed to `attemptInvoke` for the default stream handler.
+ * Matches the subset of Graph that `ChatModelStreamHandler.handle` needs.
+ */
+export type InvokeContext = Parameters<ChatModelStreamHandler['handle']>[3];
+
+/**
+ * Per-chunk callback for custom stream processing.
+ * When provided, replaces the default `ChatModelStreamHandler`.
+ */
+export type OnChunk = (chunk: AIMessageChunk) => void | Promise<void>;
+
+/**
+ * Invokes a chat model with the given messages, handling both streaming and
+ * non-streaming paths.
+ *
+ * By default, stream chunks are processed through a `ChatModelStreamHandler`
+ * that dispatches run steps (MESSAGE_CREATION, TOOL_CALLS) for the graph.
+ * Pass an `onChunk` callback to override this with custom chunk processing
+ * (e.g. summarization delta events).
+ */
+export async function attemptInvoke(
+  {
+    model,
+    messages,
+    provider,
+    context,
+    onChunk,
+  }: {
+    model: t.ChatModel;
+    messages: BaseMessage[];
+    provider: Providers;
+    context?: InvokeContext;
+    onChunk?: OnChunk;
+  },
+  config?: RunnableConfig
+): Promise<Partial<t.BaseGraphState>> {
+  if (model.stream) {
+    const stream = await model.stream(messages, config);
+    let finalChunk: AIMessageChunk | undefined;
+
+    if (onChunk) {
+      for await (const chunk of stream) {
+        await onChunk(chunk);
+        finalChunk = finalChunk ? concat(finalChunk, chunk) : chunk;
+      }
+    } else {
+      const metadata = config?.metadata as Record<string, unknown> | undefined;
+      const streamHandler = new ChatModelStreamHandler();
+      for await (const chunk of stream) {
+        await streamHandler.handle(
+          GraphEvents.CHAT_MODEL_STREAM,
+          { chunk },
+          metadata,
+          context
+        );
+        finalChunk = finalChunk ? concat(finalChunk, chunk) : chunk;
+      }
+    }
+
+    if (manualToolStreamProviders.has(provider)) {
+      finalChunk = modifyDeltaProperties(provider, finalChunk);
+    }
+
+    if ((finalChunk?.tool_calls?.length ?? 0) > 0) {
+      finalChunk!.tool_calls = finalChunk!.tool_calls?.filter(
+        (tool_call: ToolCall) => !!tool_call.name
+      );
+    }
+
+    return { messages: [finalChunk as AIMessageChunk] };
+  }
+
+  const finalMessage = await model.invoke(messages, config);
+  if ((finalMessage.tool_calls?.length ?? 0) > 0) {
+    finalMessage.tool_calls = finalMessage.tool_calls?.filter(
+      (tool_call: ToolCall) => !!tool_call.name
+    );
+  }
+  return { messages: [finalMessage] };
+}
+
+/**
+ * Attempts each fallback provider in order until one succeeds.
+ * Throws the last error if all fallbacks fail.
+ */
+export async function tryFallbackProviders({
+  fallbacks,
+  tools,
+  messages,
+  config,
+  primaryError,
+  context,
+  onChunk,
+}: {
+  fallbacks: Array<{ provider: Providers; clientOptions?: t.ClientOptions }>;
+  tools?: t.GraphTools;
+  messages: BaseMessage[];
+  config?: RunnableConfig;
+  primaryError: unknown;
+  context?: InvokeContext;
+  onChunk?: OnChunk;
+}): Promise<Partial<t.BaseGraphState> | undefined> {
+  let lastError: unknown = primaryError;
+  for (const fb of fallbacks) {
+    try {
+      const fbModel = initializeModel({
+        provider: fb.provider,
+        clientOptions: fb.clientOptions,
+        tools,
+      });
+      const result = await attemptInvoke(
+        {
+          model: fbModel as t.ChatModel,
+          messages,
+          provider: fb.provider,
+          context,
+          onChunk,
+        },
+        config
+      );
+      return result;
+    } catch (e) {
+      lastError = e;
+      continue;
+    }
+  }
+  if (lastError !== undefined) {
+    throw lastError;
+  }
+  return undefined;
+}

package/src/llm/request.ts

@@ -0,0 +1,55 @@
+import type * as t from '@/types';
+import { Providers } from '@/common';
+
+/**
+ * Returns true when the provider + clientOptions indicate extended thinking
+ * is enabled.  Works across Anthropic (direct), Bedrock (additionalModelRequestFields),
+ * and OpenAI-compat (modelKwargs.thinking).
+ */
+export function isThinkingEnabled(
+  provider: Providers,
+  clientOptions?: t.ClientOptions
+): boolean {
+  if (!clientOptions) return false;
+
+  if (
+    provider === Providers.ANTHROPIC &&
+    (clientOptions as t.AnthropicClientOptions).thinking != null
+  ) {
+    return true;
+  }
+
+  if (
+    provider === Providers.BEDROCK &&
+    (clientOptions as t.BedrockAnthropicInput).additionalModelRequestFields?.[
+      'thinking'
+    ] != null
+  ) {
+    return true;
+  }
+
+  if (
+    provider === Providers.OPENAI &&
+    (
+      (clientOptions as t.OpenAIClientOptions).modelKwargs
+        ?.thinking as t.AnthropicClientOptions['thinking']
+    )?.type === 'enabled'
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Returns the correct key for setting max output tokens on the model
+ * constructor options.  Google/Vertex use `maxOutputTokens`, all others
+ * use `maxTokens`.
+ */
+export function getMaxOutputTokensKey(
+  provider: Providers | string
+): 'maxOutputTokens' | 'maxTokens' {
+  return provider === Providers.GOOGLE || provider === Providers.VERTEXAI
+    ? 'maxOutputTokens'
+    : 'maxTokens';
+}

package/src/messages/__tests__/observationMasking.test.ts

@@ -0,0 +1,221 @@
+import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { TokenCounter } from '@/types/run';
+import { maskConsumedToolResults } from '@/messages/prune';
+
+const charCounter: TokenCounter = (msg) => {
+  const raw = msg.content;
+  if (typeof raw === 'string') return raw.length;
+  return 0;
+};
+
+function toolMsg(
+  content: string,
+  name = 'tool',
+  toolCallId = `tc_${Math.random().toString(36).slice(2, 8)}`
+): ToolMessage {
+  return new ToolMessage({ content, tool_call_id: toolCallId, name });
+}
+
+function aiWithText(text: string): AIMessage {
+  return new AIMessage(text);
+}
+
+function aiToolCall(toolCallId: string, name = 'tool'): AIMessage {
+  return new AIMessage({
+    content: [{ type: 'tool_use', id: toolCallId, name, input: {} }],
+    tool_calls: [{ id: toolCallId, name, args: {}, type: 'tool_call' }],
+  });
+}
+
+describe('maskConsumedToolResults', () => {
+  it('masks consumed tool results (followed by AI with text)', () => {
+    const tcId = 'tc_1';
+    const messages: BaseMessage[] = [
+      new HumanMessage('hello'),
+      aiToolCall(tcId, 'search'),
+      toolMsg('A'.repeat(1000), 'search', tcId),
+      aiWithText('Based on the search results, here is the answer.'),
+    ];
+    const map: Record<string, number | undefined> = {
+      0: 5,
+      1: 20,
+      2: 1000,
+      3: 50,
+    };
+
+    const count = maskConsumedToolResults({
+      messages,
+      indexTokenCountMap: map,
+      tokenCounter: charCounter,
+    });
+
+    expect(count).toBe(1);
+    const maskedContent = messages[2].content as string;
+    expect(maskedContent.length).toBeLessThan(1000);
+    expect(maskedContent.length).toBeLessThanOrEqual(300);
+  });
+
+  it('does NOT mask unconsumed tool results (no subsequent AI text)', () => {
+    const tcId = 'tc_1';
+    const messages: BaseMessage[] = [
+      new HumanMessage('hello'),
+      aiToolCall(tcId, 'search'),
+      toolMsg('A'.repeat(1000), 'search', tcId),
+    ];
+    const map: Record<string, number | undefined> = {
+      0: 5,
+      1: 20,
+      2: 1000,
+    };
+
+    const count = maskConsumedToolResults({
+      messages,
+      indexTokenCountMap: map,
+      tokenCounter: charCounter,
+    });
+
+    expect(count).toBe(0);
+    expect((messages[2].content as string).length).toBe(1000);
+  });
+
+  it('does NOT mask tool results followed by AI with only tool calls (no text)', () => {
+    const tcId1 = 'tc_1';
+    const tcId2 = 'tc_2';
+    const messages: BaseMessage[] = [
+      new HumanMessage('hello'),
+      aiToolCall(tcId1, 'search'),
+      toolMsg('A'.repeat(1000), 'search', tcId1),
+      aiToolCall(tcId2, 'fetch'),
+      toolMsg('B'.repeat(500), 'fetch', tcId2),
+    ];
+    const map: Record<string, number | undefined> = {
+      0: 5,
+      1: 20,
+      2: 1000,
+      3: 20,
+      4: 500,
+    };
+
+    const count = maskConsumedToolResults({
+      messages,
+      indexTokenCountMap: map,
+      tokenCounter: charCounter,
+    });
+
+    // No AI message with substantive text exists, so nothing is consumed
+    expect(count).toBe(0);
+  });
+
+  it('masks multiple consumed results before a text AI response', () => {
+    const tcId1 = 'tc_1';
+    const tcId2 = 'tc_2';
+    const messages: BaseMessage[] = [
+      new HumanMessage('hello'),
+      aiToolCall(tcId1, 'search'),
+      toolMsg('A'.repeat(1000), 'search', tcId1),
+      aiToolCall(tcId2, 'fetch'),
+      toolMsg('B'.repeat(800), 'fetch', tcId2),
+      aiWithText('Here are the combined results.'),
+    ];
+    const map: Record<string, number | undefined> = {
+      0: 5,
+      1: 20,
+      2: 1000,
+      3: 20,
+      4: 800,
+      5: 30,
+    };
+
+    const count = maskConsumedToolResults({
+      messages,
+      indexTokenCountMap: map,
+      tokenCounter: charCounter,
+    });
+
+    expect(count).toBe(2);
+    expect((messages[2].content as string).length).toBeLessThanOrEqual(300);
+    expect((messages[4].content as string).length).toBeLessThanOrEqual(300);
+  });
+
+  it('never masks AI messages', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hello'),
+      aiWithText('A'.repeat(2000)),
+    ];
+    const map: Record<string, number | undefined> = {
+      0: 5,
+      1: 2000,
+    };
+
+    const count = maskConsumedToolResults({
+      messages,
+      indexTokenCountMap: map,
+      tokenCounter: charCounter,
+    });
+
+    expect(count).toBe(0);
+    expect((messages[1].content as string).length).toBe(2000);
+  });
+
+  it('skips short tool results below maxChars threshold', () => {
+    const tcId = 'tc_1';
+    const messages: BaseMessage[] = [
+      new HumanMessage('hello'),
+      aiToolCall(tcId, 'search'),
+      toolMsg('short result', 'search', tcId),
+      aiWithText('Got it.'),
+    ];
+    const map: Record<string, number | undefined> = {
+      0: 5,
+      1: 20,
+      2: 12,
+      3: 7,
+    };
+
+    const count = maskConsumedToolResults({
+      messages,
+      indexTokenCountMap: map,
+      tokenCounter: charCounter,
+    });
+
+    expect(count).toBe(0);
+    expect(messages[2].content).toBe('short result');
+  });
+
+  it('updates indexTokenCountMap for masked messages', () => {
+    const tcId = 'tc_1';
+    const messages: BaseMessage[] = [
+      new HumanMessage('hello'),
+      aiToolCall(tcId, 'search'),
+      toolMsg('A'.repeat(2000), 'search', tcId),
+      aiWithText('Summary of results.'),
+    ];
+    const map: Record<string, number | undefined> = {
+      0: 5,
+      1: 20,
+      2: 2000,
+      3: 20,
+    };
+
+    maskConsumedToolResults({
+      messages,
+      indexTokenCountMap: map,
+      tokenCounter: charCounter,
+    });
+
+    // Token count should be updated to match the masked content length
+    expect(map[2]).toBeLessThan(2000);
+    expect(map[2]).toBe((messages[2].content as string).length);
+  });
+
+  it('handles empty messages array', () => {
+    const map: Record<string, number | undefined> = {};
+    const count = maskConsumedToolResults({
+      messages: [],
+      indexTokenCountMap: map,
+      tokenCounter: charCounter,
+    });
+    expect(count).toBe(0);
+  });
+});