@librechat/agents 3.3.3 → 3.3.5

package/src/llm/bedrock/utils/toolResultCachePoint.test.ts

@@ -47,6 +47,10 @@ describe('convertToConverseMessages — tool-result cachePoint hoisting', () =>
 
     const { converseMessages } = convertToConverseMessages([
       new HumanMessage('go'),
+      new AIMessage({
+        content: '',
+        tool_calls: [{ id: 't1', name: 'calc', args: {}, type: 'tool_call' }],
+      }),
       toolMsg,
     ]);
 
@@ -66,6 +70,17 @@ describe('convertToConverseMessages — tool-result cachePoint hoisting', () =>
   it('leaves tool results without a cachePoint untouched', () => {
     const { converseMessages } = convertToConverseMessages([
       new HumanMessage('go'),
+      /**
+       * The calling assistant turn matters: without it the human turn and
+       * the tool result are adjacent user-role messages, which the converter
+       * now merges (Converse rejects consecutive user messages), and this
+       * test would assert against the merged artifact instead of the
+       * tool-result body it is about.
+       */
+      new AIMessage({
+        content: '',
+        tool_calls: [{ id: 't1', name: 'calc', args: {}, type: 'tool_call' }],
+      }),
       new ToolMessage({ tool_call_id: 't1', content: 'plain result' }),
     ]);
 

package/src/llm/google/utils/common.test.ts

@@ -1,6 +1,9 @@
 import { expect, test, describe } from '@jest/globals';
-import { AIMessageChunk } from '@langchain/core/messages';
-import type { Content, EnhancedGenerateContentResponse } from '@google/generative-ai';
+import { AIMessage, AIMessageChunk } from '@langchain/core/messages';
+import type {
+  Content,
+  EnhancedGenerateContentResponse,
+} from '@google/generative-ai';
 import {
   STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
   STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
@@ -8,9 +11,53 @@ import {
 } from '@/tools/streamedToolCallSeals';
 import {
   convertResponseContentToChatGenerationChunk,
+  convertMessageContentToParts,
   dropUnsupportedModelTurnPrefill,
   rejectsModelTurnPrefill,
 } from './common';
+import { toLangChainContent } from '@/messages/langchain';
+
+describe('convertMessageContentToParts cross-provider tool calls', () => {
+  test('deduplicates Anthropic tool_use content mirrored in parsed tool_calls', () => {
+    const message = new AIMessage({
+      content: toLangChainContent([
+        { type: 'text', text: 'Checking.' },
+        {
+          type: 'tool_use',
+          id: 'call_weather',
+          name: 'weather',
+          input: '',
+        },
+        { type: 'text', index: 0, input: '{"city":"NYC"}' },
+      ]),
+      tool_calls: [
+        {
+          id: 'call_weather',
+          name: 'weather',
+          args: { city: 'NYC' },
+        },
+      ],
+    });
+
+    const parts = convertMessageContentToParts(
+      message,
+      false,
+      [],
+      'gemini-3.5-flash'
+    );
+    const functionCalls = parts.filter((part) => 'functionCall' in part);
+
+    expect(functionCalls).toHaveLength(1);
+    expect(parts).not.toContainEqual({});
+    expect(functionCalls[0]).toMatchObject({
+      functionCall: {
+        id: 'call_weather',
+        name: 'weather',
+        args: { city: 'NYC' },
+      },
+    });
+  });
+});
 
 function buildResponse(
   parts: Array<Record<string, unknown>>
@@ -72,7 +119,9 @@ describe('rejectsModelTurnPrefill', () => {
     expect(rejectsModelTurnPrefill('gemini-3.6-flash')).toBe(true);
     expect(rejectsModelTurnPrefill('gemini-3.5-flash-lite')).toBe(true);
     expect(rejectsModelTurnPrefill('models/gemini-3.6-flash')).toBe(true);
-    expect(rejectsModelTurnPrefill('google/gemini-3.5-flash-lite-latest')).toBe(true);
+    expect(rejectsModelTurnPrefill('google/gemini-3.5-flash-lite-latest')).toBe(
+      true
+    );
   });
 
   test('is false for models that still accept prefill and for empty input', () => {
@@ -86,34 +135,51 @@ describe('rejectsModelTurnPrefill', () => {
 
 describe('dropUnsupportedModelTurnPrefill', () => {
   const userTurn: Content = { role: 'user', parts: [{ text: 'Hi' }] };
-  const modelTurn: Content = { role: 'model', parts: [{ text: 'Hello, I am' }] };
+  const modelTurn: Content = {
+    role: 'model',
+    parts: [{ text: 'Hello, I am' }],
+  };
 
   test('drops a trailing model turn for no-prefill models', () => {
     const contents: Content[] = [userTurn, modelTurn];
-    const result = dropUnsupportedModelTurnPrefill(contents, 'gemini-3.6-flash');
+    const result = dropUnsupportedModelTurnPrefill(
+      contents,
+      'gemini-3.6-flash'
+    );
     expect(result).toEqual([userTurn]);
   });
 
   test('drops multiple consecutive trailing model turns but keeps one turn', () => {
     const contents: Content[] = [userTurn, modelTurn, modelTurn];
-    const result = dropUnsupportedModelTurnPrefill(contents, 'gemini-3.5-flash-lite');
+    const result = dropUnsupportedModelTurnPrefill(
+      contents,
+      'gemini-3.5-flash-lite'
+    );
     expect(result).toEqual([userTurn]);
   });
 
   test('leaves a trailing model turn for models that accept prefill', () => {
     const contents: Content[] = [userTurn, modelTurn];
-    const result = dropUnsupportedModelTurnPrefill(contents, 'gemini-3.5-flash');
+    const result = dropUnsupportedModelTurnPrefill(
+      contents,
+      'gemini-3.5-flash'
+    );
     expect(result).toBe(contents);
   });
 
   test('is a no-op when the request already ends with a user turn', () => {
     const contents: Content[] = [modelTurn, userTurn];
-    const result = dropUnsupportedModelTurnPrefill(contents, 'gemini-3.6-flash');
+    const result = dropUnsupportedModelTurnPrefill(
+      contents,
+      'gemini-3.6-flash'
+    );
     expect(result).toBe(contents);
   });
 
   test('is a no-op for empty or undefined contents', () => {
     expect(dropUnsupportedModelTurnPrefill([], 'gemini-3.6-flash')).toEqual([]);
-    expect(dropUnsupportedModelTurnPrefill(undefined, 'gemini-3.6-flash')).toBeUndefined();
+    expect(
+      dropUnsupportedModelTurnPrefill(undefined, 'gemini-3.6-flash')
+    ).toBeUndefined();
   });
 });

package/src/llm/google/utils/common.ts

@@ -390,7 +390,9 @@ function _convertLangChainContentToPart(
   }
 
   if (content.type === 'text') {
-    return { text: content.text };
+    return typeof content.text === 'string' && content.text !== ''
+      ? { text: content.text }
+      : undefined;
   } else if (content.type === 'executableCode') {
     return { executableCode: content.executableCode };
   } else if (content.type === 'codeExecutionResult') {
@@ -429,10 +431,14 @@ function _convertLangChainContentToPart(
   } else if (content.type === 'media') {
     return messageContentMedia(content);
   } else if (content.type === 'tool_use') {
+    const functionId = getGoogleFunctionId(
+      typeof content.id === 'string' ? content.id : undefined
+    );
     return {
       functionCall: {
         name: content.name,
         args: content.input,
+        ...(functionId != null ? { id: functionId } : {}),
       },
     };
   } else if (
@@ -553,7 +559,28 @@ export function convertMessageContentToParts(
     });
   }
 
-  return [...messageParts, ...functionCalls];
+  const parsedFunctionCallIds = new Set(
+    functionCalls.flatMap((part) => {
+      const functionCall = part.functionCall as GoogleFunctionCallWithId;
+      return functionCall.id != null ? [functionCall.id] : [];
+    })
+  );
+  const parsedFunctionCallNames = new Set(
+    functionCalls.map((part) => part.functionCall.name)
+  );
+  const contentWithoutParsedMirrors = messageParts.filter((part) => {
+    if (!('functionCall' in part) || part.functionCall == null) {
+      return true;
+    }
+    const functionCall = part.functionCall as GoogleFunctionCallWithId;
+    return !(
+      (functionCall.id != null && parsedFunctionCallIds.has(functionCall.id)) ||
+      (functionCall.id == null &&
+        parsedFunctionCallNames.has(functionCall.name))
+    );
+  });
+
+  return [...contentWithoutParsedMirrors, ...functionCalls];
 }
 
 export function convertBaseMessagesToContent(
@@ -665,7 +692,11 @@ export function dropUnsupportedModelTurnPrefill(
   contents: Content[] | undefined,
   model?: string
 ): Content[] | undefined {
-  if (contents == null || contents.length === 0 || !rejectsModelTurnPrefill(model)) {
+  if (
+    contents == null ||
+    contents.length === 0 ||
+    !rejectsModelTurnPrefill(model)
+  ) {
     return contents;
   }
   let end = contents.length;

package/src/llm/invoke.alternation.test.ts

@@ -0,0 +1,87 @@
+// src/llm/invoke.alternation.test.ts
+/**
+ * `attemptInvoke` is the single funnel for primary, fallback and
+ * summarization model calls, and it keys the alternation pass on the provider
+ * ACTUALLY serving the call. This is the seam that protects a fallback: an
+ * OpenAI primary that failed after a boundary injected two human turns hands
+ * the same array to a Bedrock fallback, which rejects consecutive user turns.
+ */
+import { AIMessage, HumanMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { ChatGenerationChunk } from '@langchain/core/outputs';
+import { Providers } from '@/common';
+import { FakeChatModel } from '@/llm/fake';
+import { attemptInvoke } from './invoke';
+import type * as t from '@/types';
+
+class CapturingChatModel extends FakeChatModel {
+  readonly invocations: BaseMessage[][] = [];
+
+  constructor() {
+    super({ responses: ['ok'] });
+  }
+
+  override async *_streamResponseChunks(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    this.invocations.push(messages);
+    yield* super._streamResponseChunks(messages, options, runManager);
+  }
+}
+
+const adjacentUserPayload = (): BaseMessage[] => [
+  new HumanMessage({ content: 'question' }),
+  new AIMessage({ content: 'partial answer' }),
+  new HumanMessage({ content: 'hook context' }),
+  new HumanMessage({ content: 'steer' }),
+];
+
+async function invokeAs(provider: Providers): Promise<BaseMessage[]> {
+  const model = new CapturingChatModel();
+  await attemptInvoke({
+    model: model as unknown as t.ChatModel,
+    messages: adjacentUserPayload(),
+    provider,
+    onChunk: async () => undefined,
+  });
+  expect(model.invocations).toHaveLength(1);
+  return model.invocations[0];
+}
+
+describe('attemptInvoke alternation funnel', () => {
+  it('coalesces adjacent user turns when the serving provider is strict', async () => {
+    const sent = await invokeAs(Providers.BEDROCK);
+    expect(sent.map((m) => m.getType())).toEqual(['human', 'ai', 'human']);
+    expect(sent[2].content).toBe('hook context\n\nsteer');
+  });
+
+  it('leaves the payload alone for a tolerant provider', async () => {
+    const sent = await invokeAs(Providers.OPENAI);
+    expect(sent.map((m) => m.getType())).toEqual([
+      'human',
+      'ai',
+      'human',
+      'human',
+    ]);
+  });
+
+  it('is idempotent when the graph already coalesced for the primary', async () => {
+    const model = new CapturingChatModel();
+    const once = await invokeAs(Providers.BEDROCK);
+    await attemptInvoke({
+      model: model as unknown as t.ChatModel,
+      messages: once,
+      provider: Providers.BEDROCK,
+      onChunk: async () => undefined,
+    });
+    expect(model.invocations[0].map((m) => m.getType())).toEqual([
+      'human',
+      'ai',
+      'human',
+    ]);
+    expect(model.invocations[0][2].content).toBe('hook context\n\nsteer');
+  });
+});

package/src/llm/invoke.handoffCue.test.ts

@@ -0,0 +1,112 @@
+// src/llm/invoke.handoffCue.test.ts
+/**
+ * The handoff cue is re-keyed on the provider ACTUALLY serving the call at
+ * the `attemptInvoke` funnel — the seam every fallback send passes through.
+ * A tolerant primary falling back to a Claude surface must gain the cue; an
+ * Anthropic primary falling back to a tolerant provider must have the baked
+ * cue stripped; and the serving model id must be read through the wrapper
+ * stack, or a wrapped Bedrock-Nova model would default to Claude.
+ */
+import { AIMessage, HumanMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { ChatGenerationChunk } from '@langchain/core/outputs';
+import { RunnableBinding } from '@langchain/core/runnables';
+import { Providers } from '@/common';
+import { PREDECESSOR_HANDOFF_CUE } from '@/messages/handoffCue';
+import { FakeChatModel } from '@/llm/fake';
+import { attemptInvoke, type InvokeContext } from './invoke';
+
+class CapturingChatModel extends FakeChatModel {
+  readonly invocations: BaseMessage[][] = [];
+  /** Serving model id, as a real provider client would expose it. */
+  model?: string;
+
+  constructor(modelId?: string) {
+    super({ responses: ['ok'] });
+    this.model = modelId;
+  }
+
+  override async *_streamResponseChunks(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    this.invocations.push(messages);
+    yield* super._streamResponseChunks(messages, options, runManager);
+  }
+}
+
+const runTail = new AIMessage({ content: 'predecessor output', id: 'run-1' });
+const context = {
+  isRunProducedMessage: (message: BaseMessage): boolean =>
+    message.id === 'run-1',
+  getOrCreateToolOutputRegistry: (): undefined => undefined,
+} as unknown as InvokeContext;
+
+const bakedCue = (): HumanMessage =>
+  new HumanMessage({
+    content: PREDECESSOR_HANDOFF_CUE,
+    additional_kwargs: { role: 'user', isMeta: true, source: 'handoff' },
+  });
+
+async function sentBy(
+  provider: Providers,
+  options?: { modelId?: string; wrap?: boolean; messages?: BaseMessage[] }
+): Promise<BaseMessage[]> {
+  const model = new CapturingChatModel(options?.modelId);
+  const served =
+    options?.wrap === true
+      ? new RunnableBinding({ bound: model, kwargs: {}, config: {} })
+      : model;
+  await attemptInvoke({
+    model: served as never,
+    messages: options?.messages ?? [new HumanMessage('go'), runTail],
+    provider,
+    context,
+    onChunk: async () => undefined,
+  });
+  return model.invocations[0];
+}
+
+describe('attemptInvoke handoff-cue funnel', () => {
+  it('applies the cue when the serving provider is Anthropic', async () => {
+    const sent = await sentBy(Providers.ANTHROPIC);
+    expect(sent.at(-1)?.content).toBe(PREDECESSOR_HANDOFF_CUE);
+  });
+
+  it('applies the cue for Bedrock serving a WRAPPED Claude model', async () => {
+    const sent = await sentBy(Providers.BEDROCK, {
+      modelId: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0',
+      wrap: true,
+    });
+    expect(sent.at(-1)?.content).toBe(PREDECESSOR_HANDOFF_CUE);
+  });
+
+  it('does not apply the cue for Bedrock serving a WRAPPED Nova model', async () => {
+    const sent = await sentBy(Providers.BEDROCK, {
+      modelId: 'us.amazon.nova-pro-v1:0',
+      wrap: true,
+    });
+    expect(sent.at(-1)?.getType()).toBe('ai');
+  });
+
+  it('strips a baked cue for a tolerant serving provider', async () => {
+    const sent = await sentBy(Providers.OPENAI, {
+      messages: [new HumanMessage('go'), runTail, bakedCue()],
+    });
+    expect(sent.at(-1)?.getType()).toBe('ai');
+    expect(sent.some((m) => m.content === PREDECESSOR_HANDOFF_CUE)).toBe(
+      false
+    );
+  });
+
+  it('is idempotent when the primary already baked the cue', async () => {
+    const sent = await sentBy(Providers.ANTHROPIC, {
+      messages: [new HumanMessage('go'), runTail, bakedCue()],
+    });
+    expect(
+      sent.filter((m) => m.content === PREDECESSOR_HANDOFF_CUE)
+    ).toHaveLength(1);
+  });
+});