@librechat/agents 3.2.33 → 3.2.35

package/src/llm/openai/index.ts

@@ -34,6 +34,10 @@ import type { ChatGeneration, ChatResult } from '@langchain/core/outputs';
 import type { ChatXAIInput } from '@langchain/xai';
 import type * as t from '@langchain/openai';
 import type { HeaderValue, HeadersLike } from './types';
+import {
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
 import { isReasoningModel, _convertMessagesToOpenAIParams } from './utils';
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
@@ -670,6 +674,69 @@ export class CustomAzureOpenAIClient extends AzureOpenAIClient {
   }
 }
 
+const OFFICIAL_OPENAI_BASE_URL_PATTERN = /^https:\/\/api\.openai\.com(\/|$)/;
+
+/**
+ * Official OpenAI (api.openai.com) and Azure OpenAI Chat Completions streams
+ * emit tool-call deltas strictly sequentially by index: once a delta for a
+ * later index appears, a prior index's arguments never change. Stamping this
+ * adapter lets the stream handler seal a prior call for eager execution the
+ * moment the next call begins. OpenAI-compatible endpoints (custom baseURL)
+ * must NOT be stamped — e.g. live Kimi/Moonshot streams revise prior-index
+ * args after advancing — so callers gate on the wire endpoint, not the class.
+ */
+function stampSequentialStreamedToolCallAdapter(
+  message: BaseMessageChunk
+): BaseMessageChunk {
+  if (
+    message instanceof AIMessageChunk &&
+    (message.tool_call_chunks?.length ?? 0) > 0
+  ) {
+    message.response_metadata = {
+      ...message.response_metadata,
+      [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+        OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER,
+    };
+  }
+  return message;
+}
+
+function isOfficialOpenAIBaseURL(baseURL: string | null | undefined): boolean {
+  // The OpenAI SDK falls back to OPENAI_BASE_URL when the client has no
+  // explicit baseURL, so an unset constructor value can still route to an
+  // OpenAI-compatible endpoint.
+  const effectiveBaseURL =
+    baseURL != null && baseURL !== '' ? baseURL : process.env.OPENAI_BASE_URL;
+  if (effectiveBaseURL == null || effectiveBaseURL === '') {
+    return true;
+  }
+  return OFFICIAL_OPENAI_BASE_URL_PATTERN.test(effectiveBaseURL);
+}
+
+const AZURE_FIRST_PARTY_BASE_PATH_PATTERN =
+  /^https:\/\/[^/]+\.(openai\.azure\.com|cognitiveservices\.azure\.com|api\.cognitive\.microsoft\.com)(:\d+)?(\/|$)/;
+
+/**
+ * Azure OpenAI is first-party when requests resolve to an instance-name
+ * endpoint or an *.openai.azure.com / *.cognitiveservices.azure.com /
+ * regional *.api.cognitive.microsoft.com base path. A custom
+ * `clientConfig.baseURL` or a non-Azure `azureOpenAIBasePath` routes through
+ * a proxy or Azure-compatible endpoint whose stream contract is unknown, so
+ * those are not stamped.
+ */
+function isFirstPartyAzureEndpoint(args: {
+  baseURL: string | null | undefined;
+  azureOpenAIBasePath: string | undefined;
+}): boolean {
+  if (args.baseURL != null && args.baseURL !== '') {
+    return false;
+  }
+  if (args.azureOpenAIBasePath == null || args.azureOpenAIBasePath === '') {
+    return true;
+  }
+  return AZURE_FIRST_PARTY_BASE_PATH_PATTERN.test(args.azureOpenAIBasePath);
+}
+
 class LibreChatOpenAICompletions extends OriginalChatOpenAICompletions {
   private includeReasoningContent?: boolean;
   private includeReasoningDetails?: boolean;
@@ -721,7 +788,7 @@ class LibreChatOpenAICompletions extends OriginalChatOpenAICompletions {
     rawResponse: OpenAIClient.Chat.Completions.ChatCompletionChunk,
     defaultRole?: OpenAIClient.Chat.ChatCompletionRole
   ): BaseMessageChunk {
-    return attachLibreChatDeltaFields(
+    const message = attachLibreChatDeltaFields(
       super._convertCompletionsDeltaToBaseMessageChunk(
         delta,
         rawResponse,
@@ -729,6 +796,10 @@ class LibreChatOpenAICompletions extends OriginalChatOpenAICompletions {
       ),
       delta
     );
+    if (isOfficialOpenAIBaseURL(this.clientConfig.baseURL)) {
+      return stampSequentialStreamedToolCallAdapter(message);
+    }
+    return message;
   }
 
   protected _convertCompletionsMessageToBaseMessage(
@@ -1090,6 +1161,29 @@ class LibreChatAzureOpenAICompletions extends OriginalAzureChatOpenAICompletions
     return getGatedReasoningParams(this.model, this.reasoning, options);
   }
 
+  protected _convertCompletionsDeltaToBaseMessageChunk(
+    delta: Record<string, unknown>,
+    rawResponse: OpenAIClient.Chat.Completions.ChatCompletionChunk,
+    defaultRole?: OpenAIClient.Chat.ChatCompletionRole
+  ): BaseMessageChunk {
+    const message = super._convertCompletionsDeltaToBaseMessageChunk(
+      delta,
+      rawResponse,
+      defaultRole
+    );
+    if (
+      isFirstPartyAzureEndpoint({
+        baseURL: this.clientConfig.baseURL,
+        azureOpenAIBasePath: this.azureOpenAIBasePath,
+      })
+    ) {
+      // First-party Azure OpenAI: same sequential-by-index stream contract
+      // as api.openai.com.
+      return stampSequentialStreamedToolCallAdapter(message);
+    }
+    return message;
+  }
+
   _getClientOptions(
     options: OpenAICoreRequestOptions | undefined
   ): OpenAICoreRequestOptions {

package/src/llm/openai/sequentialToolCallSeals.test.ts

@@ -0,0 +1,199 @@
+import { AIMessageChunk } from '@langchain/core/messages';
+import { expect, test, describe, beforeEach, afterAll } from '@jest/globals';
+import type { BaseMessageChunk } from '@langchain/core/messages';
+import {
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
+import { ChatOpenAI, AzureChatOpenAI } from './index';
+
+type DeltaConverter = {
+  _convertCompletionsDeltaToBaseMessageChunk(
+    delta: Record<string, unknown>,
+    rawResponse: Record<string, unknown>
+  ): BaseMessageChunk;
+};
+
+const rawResponse = {
+  id: 'chatcmpl-1',
+  object: 'chat.completion.chunk',
+  created: 1,
+  model: 'gpt-5.5',
+  choices: [],
+};
+
+const toolCallDelta = {
+  role: 'assistant',
+  tool_calls: [
+    {
+      index: 0,
+      id: 'call_1',
+      type: 'function',
+      function: { name: 'weather', arguments: '{"ci' },
+    },
+  ],
+};
+
+function convertDelta(
+  model: unknown,
+  delta: Record<string, unknown>
+): AIMessageChunk {
+  const converter = (model as { completions: DeltaConverter }).completions;
+  const message = converter._convertCompletionsDeltaToBaseMessageChunk(
+    delta,
+    rawResponse
+  );
+  expect(message).toBeInstanceOf(AIMessageChunk);
+  return message as AIMessageChunk;
+}
+
+function adapterOf(message: AIMessageChunk): unknown {
+  return (message.response_metadata as Record<string, unknown>)[
+    STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY
+  ];
+}
+
+describe('Chat Completions sequential tool-call seal stamping', () => {
+  // Both the implementation (OPENAI_BASE_URL fallback) and the Azure
+  // constructor (AZURE_OPENAI_BASE_PATH fallback) read the environment, so
+  // isolate these vars to keep the suite deterministic across shells.
+  const ISOLATED_ENV_VARS = ['OPENAI_BASE_URL', 'AZURE_OPENAI_BASE_PATH'];
+  const originalEnv = new Map(
+    ISOLATED_ENV_VARS.map((name) => [name, process.env[name]])
+  );
+
+  beforeEach(() => {
+    for (const name of ISOLATED_ENV_VARS) {
+      delete process.env[name];
+    }
+  });
+
+  afterAll(() => {
+    for (const [name, value] of originalEnv) {
+      if (value == null) {
+        delete process.env[name];
+      } else {
+        process.env[name] = value;
+      }
+    }
+  });
+
+  test('stamps tool-call deltas when no baseURL is configured (official)', () => {
+    const model = new ChatOpenAI({ model: 'gpt-5.5', apiKey: 'test' });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBe(
+      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
+    );
+  });
+
+  test('stamps tool-call deltas for an explicit api.openai.com baseURL', () => {
+    const model = new ChatOpenAI({
+      model: 'gpt-5.5',
+      apiKey: 'test',
+      configuration: { baseURL: 'https://api.openai.com/v1' },
+    });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBe(
+      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
+    );
+  });
+
+  test('does not stamp tool-call deltas for OpenAI-compatible endpoints', () => {
+    const model = new ChatOpenAI({
+      model: 'kimi-k2',
+      apiKey: 'test',
+      configuration: { baseURL: 'https://api.moonshot.ai/v1' },
+    });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBeUndefined();
+  });
+
+  test('does not stamp text-only deltas', () => {
+    const model = new ChatOpenAI({ model: 'gpt-5.5', apiKey: 'test' });
+    const message = convertDelta(model, {
+      role: 'assistant',
+      content: 'hello',
+    });
+    expect(adapterOf(message)).toBeUndefined();
+  });
+
+  test('does not stamp when OPENAI_BASE_URL routes to a compatible endpoint', () => {
+    process.env.OPENAI_BASE_URL = 'https://api.moonshot.ai/v1';
+    const model = new ChatOpenAI({ model: 'gpt-5.5', apiKey: 'test' });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBeUndefined();
+  });
+
+  test('stamps when OPENAI_BASE_URL points at api.openai.com', () => {
+    process.env.OPENAI_BASE_URL = 'https://api.openai.com/v1';
+    const model = new ChatOpenAI({ model: 'gpt-5.5', apiKey: 'test' });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBe(
+      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
+    );
+  });
+
+  test('stamps Azure OpenAI tool-call deltas (first-party endpoint)', () => {
+    const model = new AzureChatOpenAI({
+      azureOpenAIApiKey: 'test',
+      azureOpenAIApiInstanceName: 'test-instance',
+      azureOpenAIApiDeploymentName: 'test-deployment',
+      azureOpenAIApiVersion: '2024-08-01-preview',
+    });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBe(
+      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
+    );
+  });
+
+  test('stamps Azure deltas for an *.openai.azure.com base path', () => {
+    const model = new AzureChatOpenAI({
+      azureOpenAIApiKey: 'test',
+      azureOpenAIApiDeploymentName: 'test-deployment',
+      azureOpenAIApiVersion: '2024-08-01-preview',
+      azureOpenAIBasePath:
+        'https://test-resource.openai.azure.com/openai/deployments',
+    });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBe(
+      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
+    );
+  });
+
+  test('stamps Azure deltas for a regional cognitive services base path', () => {
+    const model = new AzureChatOpenAI({
+      azureOpenAIApiKey: 'test',
+      azureOpenAIApiDeploymentName: 'test-deployment',
+      azureOpenAIApiVersion: '2024-08-01-preview',
+      azureOpenAIBasePath:
+        'https://westeurope.api.cognitive.microsoft.com/openai/deployments',
+    });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBe(
+      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
+    );
+  });
+
+  test('does not stamp Azure deltas routed through a proxy base path', () => {
+    const model = new AzureChatOpenAI({
+      azureOpenAIApiKey: 'test',
+      azureOpenAIApiDeploymentName: 'test-deployment',
+      azureOpenAIApiVersion: '2024-08-01-preview',
+      azureOpenAIBasePath: 'https://proxy.example.com/openai/deployments',
+    });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBeUndefined();
+  });
+
+  test('does not stamp Azure deltas with a custom client baseURL', () => {
+    const model = new AzureChatOpenAI({
+      azureOpenAIApiKey: 'test',
+      azureOpenAIApiInstanceName: 'test-instance',
+      azureOpenAIApiDeploymentName: 'test-deployment',
+      azureOpenAIApiVersion: '2024-08-01-preview',
+      configuration: { baseURL: 'https://gateway.example.com/azure' },
+    } as unknown as ConstructorParameters<typeof AzureChatOpenAI>[0]);
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBeUndefined();
+  });
+});

package/src/llm/vertexai/index.ts

@@ -11,6 +11,11 @@ import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager
 import type { BaseMessage, UsageMetadata } from '@langchain/core/messages';
 import type { ChatGenerationChunk } from '@langchain/core/outputs';
 import type { GoogleThinkingConfig, VertexAIClientOptions } from '@/types';
+import {
+  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
 
 /**
  * `@langchain/google-common`'s `_streamResponseChunks` emits usage on TWO
@@ -48,6 +53,31 @@ export function repairStreamUsageMetadata(
   return generationInfoUsage;
 }
 
+/**
+ * The Gemini API delivers function calls as complete objects — never as
+ * partial arg deltas. `@langchain/google-common` pre-parses each streamed
+ * functionCall part into `tool_calls` (invalid args land in
+ * `invalid_tool_calls` instead), so a chunk whose tool-call chunks all parsed
+ * cleanly is sealed on arrival for eager tool execution. Anything that fails
+ * the parse check is left unstamped and falls back to the lazy path.
+ */
+export function sealCompleteStreamedToolCalls(message: AIMessageChunk): void {
+  const chunkCount = message.tool_call_chunks?.length ?? 0;
+  if (
+    chunkCount === 0 ||
+    (message.invalid_tool_calls?.length ?? 0) > 0 ||
+    (message.tool_calls?.length ?? 0) !== chunkCount
+  ) {
+    return;
+  }
+  message.response_metadata = {
+    ...message.response_metadata,
+    [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+      GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+    [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: { kind: 'all' },
+  };
+}
+
 type AdditionalKwargs =
   | undefined
   | (BaseMessage['additional_kwargs'] & {
@@ -503,6 +533,7 @@ export class ChatVertexAI extends ChatGoogle {
         if (repaired !== chunk.message.usage_metadata) {
           chunk.message.usage_metadata = repaired;
         }
+        sealCompleteStreamedToolCalls(chunk.message);
       }
       yield chunk;
     }

package/src/llm/vertexai/sealStreamedToolCalls.test.ts

@@ -0,0 +1,88 @@
+import { expect, test, describe } from '@jest/globals';
+import { AIMessageChunk } from '@langchain/core/messages';
+import {
+  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
+import { sealCompleteStreamedToolCalls } from './index';
+
+describe('sealCompleteStreamedToolCalls', () => {
+  test('stamps an on-arrival seal when every tool-call chunk parsed cleanly', () => {
+    const message = new AIMessageChunk({
+      content: '',
+      tool_call_chunks: [
+        {
+          id: 'call_1',
+          name: 'weather',
+          args: '{"city":"NYC"}',
+          type: 'tool_call_chunk',
+        },
+      ],
+    });
+
+    sealCompleteStreamedToolCalls(message);
+
+    expect(message.response_metadata).toMatchObject({
+      [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+        GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+      [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: { kind: 'all' },
+    });
+  });
+
+  test('stamps multi-call chunks when all calls are complete', () => {
+    const message = new AIMessageChunk({
+      content: '',
+      tool_call_chunks: [
+        {
+          id: 'call_1',
+          name: 'weather',
+          args: '{"city":"NYC"}',
+          type: 'tool_call_chunk',
+        },
+        {
+          id: 'call_2',
+          name: 'stock',
+          args: '{"ticker":"CH"}',
+          type: 'tool_call_chunk',
+        },
+      ],
+    });
+
+    sealCompleteStreamedToolCalls(message);
+
+    expect(
+      message.response_metadata[STREAMED_TOOL_CALL_SEAL_METADATA_KEY]
+    ).toEqual({ kind: 'all' });
+  });
+
+  test('leaves chunks without tool calls unstamped', () => {
+    const message = new AIMessageChunk({ content: 'hello' });
+
+    sealCompleteStreamedToolCalls(message);
+
+    expect(
+      message.response_metadata[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]
+    ).toBeUndefined();
+  });
+
+  test('leaves chunks with unparsable tool calls unstamped', () => {
+    // No id forces the parse into invalid_tool_calls.
+    const message = new AIMessageChunk({
+      content: '',
+      tool_call_chunks: [
+        {
+          name: 'weather',
+          args: '{"city":',
+          type: 'tool_call_chunk',
+        },
+      ],
+    });
+
+    sealCompleteStreamedToolCalls(message);
+
+    expect(
+      message.response_metadata[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]
+    ).toBeUndefined();
+  });
+});

package/src/llm/vertexai/streamSealDispatch.test.ts

@@ -0,0 +1,148 @@
+import { expect, test, describe, jest } from '@jest/globals';
+import { HumanMessage, AIMessageChunk } from '@langchain/core/messages';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { ChatGenerationChunk } from '@langchain/core/outputs';
+import {
+  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
+import { ChatVertexAI } from './index';
+
+/**
+ * Registered stream handlers consume chunks through `handleLLMNewToken`
+ * callback events. `@langchain/google-common` yields each chunk BEFORE
+ * dispatching that callback, and the generator only resumes (firing the
+ * callback) after this package's `_streamResponseChunks` override has
+ * stamped the seal on the same message object — so callback consumers must
+ * observe sealed chunks. This drives the real google-common stream loop and
+ * conversion with a stubbed connection to lock that ordering in.
+ */
+describe('Vertex stream seal dispatch', () => {
+  async function runStream(outputs: unknown[]): Promise<{
+    yielded: AIMessageChunk[];
+    dispatched: AIMessageChunk[];
+  }> {
+    const model = new ChatVertexAI({
+      model: 'gemini-2.5-flash',
+      authOptions: {
+        projectId: 'test-project',
+        credentials: { client_email: 'test@test', private_key: 'test' },
+      },
+    });
+
+    let index = 0;
+    const fakeStream = {
+      get streamDone(): boolean {
+        return index > outputs.length;
+      },
+      async nextChunk(): Promise<unknown> {
+        const output = index < outputs.length ? outputs[index] : null;
+        index += 1;
+        return output;
+      },
+    };
+    (
+      model as unknown as {
+        streamedConnection: { request: unknown };
+      }
+    ).streamedConnection.request = jest.fn(async () => ({ data: fakeStream }));
+
+    const dispatched: AIMessageChunk[] = [];
+    const runManager = {
+      handleCustomEvent: jest.fn(async () => undefined),
+      handleLLMNewToken: jest.fn(
+        async (
+          _token: string,
+          _idx?: unknown,
+          _runId?: unknown,
+          _parentRunId?: unknown,
+          _tags?: unknown,
+          fields?: { chunk?: ChatGenerationChunk }
+        ) => {
+          const message = fields?.chunk?.message;
+          if (message instanceof AIMessageChunk) {
+            dispatched.push(message);
+          }
+        }
+      ),
+    } as unknown as CallbackManagerForLLMRun;
+
+    const yielded: AIMessageChunk[] = [];
+    for await (const chunk of model._streamResponseChunks(
+      [new HumanMessage('hi')],
+      {} as Parameters<ChatVertexAI['_streamResponseChunks']>[1],
+      runManager
+    )) {
+      if (chunk.message instanceof AIMessageChunk) {
+        yielded.push(chunk.message);
+      }
+    }
+    return { yielded, dispatched };
+  }
+
+  test('callback consumers receive function-call chunks already sealed', async () => {
+    const { yielded, dispatched } = await runStream([
+      {
+        candidates: [
+          {
+            content: {
+              role: 'model',
+              parts: [
+                { functionCall: { name: 'weather', args: { city: 'NYC' } } },
+              ],
+            },
+            index: 0,
+          },
+        ],
+      },
+    ]);
+
+    const metadataOf = (m: AIMessageChunk): Record<string, unknown> =>
+      m.response_metadata as Record<string, unknown>;
+
+    const yieldedCall = yielded.find(
+      (m) => (m.tool_call_chunks?.length ?? 0) > 0
+    );
+    expect(yieldedCall).toBeDefined();
+    expect(
+      metadataOf(yieldedCall!)[STREAMED_TOOL_CALL_SEAL_METADATA_KEY]
+    ).toEqual({ kind: 'all' });
+
+    const dispatchedCall = dispatched.find(
+      (m) => (m.tool_call_chunks?.length ?? 0) > 0
+    );
+    expect(dispatchedCall).toBeDefined();
+    expect(dispatchedCall!.tool_calls?.[0]).toMatchObject({
+      name: 'weather',
+      args: { city: 'NYC' },
+    });
+    expect(
+      metadataOf(dispatchedCall!)[STREAMED_TOOL_CALL_SEAL_METADATA_KEY]
+    ).toEqual({ kind: 'all' });
+    expect(
+      metadataOf(dispatchedCall!)[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]
+    ).toBe(GOOGLE_STREAMED_TOOL_CALL_ADAPTER);
+  });
+
+  test('text-only chunks are not sealed on either path', async () => {
+    const { yielded, dispatched } = await runStream([
+      {
+        candidates: [
+          {
+            content: { role: 'model', parts: [{ text: 'hello' }] },
+            index: 0,
+          },
+        ],
+      },
+    ]);
+
+    const hasSeal = (m: AIMessageChunk): boolean =>
+      (m.response_metadata as Record<string, unknown>)[
+        STREAMED_TOOL_CALL_SEAL_METADATA_KEY
+      ] != null;
+
+    expect(yielded.some(hasSeal)).toBe(false);
+    expect(dispatched.some(hasSeal)).toBe(false);
+  });
+});

package/src/messages/content.ts

@@ -1,6 +1,26 @@
-import type { BaseMessage } from '@langchain/core/messages';
+import type {
+  BaseMessage,
+  MessageContentComplex,
+} from '@langchain/core/messages';
 import { ContentTypes } from '@/common';
 
+/**
+ * Whether {@link formatContentStrings} will flatten this message's content:
+ * a human/ai/system message whose content is an array of text-only blocks.
+ */
+export const isLegacyConvertible = (message: BaseMessage): boolean => {
+  const messageType = message.getType();
+  const isValidMessage =
+    messageType === 'human' || messageType === 'ai' || messageType === 'system';
+  if (!isValidMessage) {
+    return false;
+  }
+  if (!Array.isArray(message.content)) {
+    return false;
+  }
+  return message.content.every((block) => block.type === ContentTypes.TEXT);
+};
+
 /**
  * Formats an array of messages for LangChain, making sure all content fields are strings
  * @param {Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>} payload - The array of messages to format.
@@ -13,42 +33,14 @@ export const formatContentStrings = (
   const result: Array<BaseMessage> = [];
 
   for (const message of payload) {
-    const messageType = message.getType();
-    const isValidMessage =
-      messageType === 'human' ||
-      messageType === 'ai' ||
-      messageType === 'system';
-
-    if (!isValidMessage) {
-      result.push(message);
-      continue;
-    }
-
-    // If content is already a string, add as-is
-    if (typeof message.content === 'string') {
-      result.push(message);
-      continue;
-    }
-
-    // If content is not an array, add as-is
-    if (!Array.isArray(message.content)) {
-      result.push(message);
-      continue;
-    }
-
-    // Check if all content blocks are text type
-    const allTextBlocks = message.content.every(
-      (block) => block.type === ContentTypes.TEXT
-    );
-
-    // Only convert to string if all blocks are text type
-    if (!allTextBlocks) {
+    if (!isLegacyConvertible(message)) {
       result.push(message);
       continue;
     }
 
     // Reduce text types to a single string
-    const content = message.content.reduce((acc, curr) => {
+    const blocks = message.content as MessageContentComplex[];
+    const content = blocks.reduce((acc, curr) => {
       if (curr.type === ContentTypes.TEXT) {
         return `${acc}${curr[ContentTypes.TEXT] || ''}\n`;
       }