@librechat/agents 3.3.4 → 3.3.6

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

@@ -1063,7 +1063,19 @@ export function convertToConverseMessages(messages: BaseMessage[]): {
       }
     });
 
-  // Combine consecutive user tool result messages into a single message
+  /**
+   * Combine ALL consecutive user messages into one, not just tool-result
+   * pairs. The Converse API documents strict role alternation; enforcement
+   * varies by model family (Claude on Converse currently tolerates adjacent
+   * user messages — verified live, 2026-07-28 — but the docs promise nothing
+   * for the others), so the converter never emits the shape. The case that
+   * matters: a `PostToolBatch`/`PreemptBoundary` hook injection lands a text
+   * turn directly after tool results, and `ToolMessage` and `HumanMessage`
+   * both convert to `role: 'user'` above. Block order is preserved
+   * (toolResult blocks, then text) — verified live that Converse accepts the
+   * mixed user message and answers both halves — and the toolUse/toolResult
+   * pairing stays intact.
+   */
   const combinedConverseMessages = converseMessages.reduce<BedrockMessage[]>(
     (acc, curr) => {
       if (acc.length === 0) {
@@ -1071,16 +1083,7 @@ export function convertToConverseMessages(messages: BaseMessage[]): {
         return acc;
       }
       const lastMessage = acc[acc.length - 1];
-      const lastHasToolResult =
-        lastMessage.content?.some((c) => 'toolResult' in c) === true;
-      const currHasToolResult =
-        curr.content?.some((c) => 'toolResult' in c) === true;
-      if (
-        lastMessage.role === 'user' &&
-        lastHasToolResult &&
-        curr.role === 'user' &&
-        currHasToolResult
-      ) {
+      if (lastMessage.role === 'user' && curr.role === 'user') {
         lastMessage.content = lastMessage.content?.concat(curr.content ?? []);
       } else {
         acc.push(curr);

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/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);
+  });
+});