@librechat/agents 3.2.32 → 3.2.34

package/src/llm/bedrock/index.ts

@@ -34,6 +34,7 @@ import type { BaseMessage, ResponseMetadata } from '@langchain/core/messages';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
 import {
   convertToConverseMessages,
+  createConverseToolUseStopChunk,
   handleConverseStreamContentBlockStart,
   handleConverseStreamContentBlockDelta,
   handleConverseStreamMetadata,
@@ -224,6 +225,15 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
     }
 
     const seenBlockIndices = new Set<number>();
+    const toolUseBlockIndices = new Set<number>();
+    /**
+     * Guardrails can reject an already-streamed toolUse block at
+     * `messageStop` (`guardrail_intervened`), after `contentBlockStop` has
+     * passed. Only emit eager-execution seals when no guardrails are
+     * configured, so a later intervention can't race an eagerly started tool.
+     */
+    const sealToolUseOnStop =
+      options.guardrailConfig == null && this.guardrailConfig == null;
 
     for await (const event of response.stream) {
       if (event.contentBlockStart != null) {
@@ -234,8 +244,23 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
           const idx = event.contentBlockStart.contentBlockIndex;
           if (idx != null) {
             seenBlockIndices.add(idx);
+            if (event.contentBlockStart.start?.toolUse != null) {
+              toolUseBlockIndices.add(idx);
+            }
           }
           yield this.enrichChunk(startChunk, seenBlockIndices);
+
+          // Registered stream handlers receive chunks through callback
+          // events, not the yielded generator — dispatch the start chunk so
+          // they see the tool call's id/name (eager chunk state needs both).
+          await runManager?.handleLLMNewToken(
+            startChunk.text,
+            undefined,
+            undefined,
+            undefined,
+            undefined,
+            { chunk: startChunk }
+          );
         }
       } else if (event.contentBlockDelta != null) {
         const deltaChunk = handleConverseStreamContentBlockDelta(
@@ -263,6 +288,21 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
         const stopIdx = event.contentBlockStop.contentBlockIndex;
         if (stopIdx != null) {
           seenBlockIndices.add(stopIdx);
+          if (sealToolUseOnStop && toolUseBlockIndices.has(stopIdx)) {
+            // Converse guarantees the block's input is complete at stop, so
+            // emit an explicit seal chunk for eager tool execution — through
+            // the callback path too, for registered stream handlers.
+            const sealChunk = createConverseToolUseStopChunk(stopIdx);
+            yield sealChunk;
+            await runManager?.handleLLMNewToken(
+              sealChunk.text,
+              undefined,
+              undefined,
+              undefined,
+              undefined,
+              { chunk: sealChunk }
+            );
+          }
         }
       } else {
         yield new ChatGenerationChunk({

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

@@ -0,0 +1,158 @@
+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,
+  BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
+import { CustomChatBedrockConverse } from './index';
+
+/**
+ * Registered stream handlers consume chunks through `handleLLMNewToken`
+ * callback events, not the yielded generator (`attemptInvoke` skips manual
+ * dispatch when a handler is registered). These tests drive the Converse
+ * stream loop with a stubbed client and assert that toolUse start and stop
+ * seal chunks reach BOTH paths.
+ */
+describe('Converse stream seal dispatch', () => {
+  async function runStream(
+    events: Array<Record<string, unknown>>,
+    modelFields: Record<string, unknown> = {}
+  ): Promise<{
+    yielded: AIMessageChunk[];
+    dispatched: AIMessageChunk[];
+  }> {
+    const model = new CustomChatBedrockConverse({
+      model: 'anthropic.claude-3-5-sonnet-20240620-v1:0',
+      region: 'us-east-1',
+      credentials: { accessKeyId: 'test', secretAccessKey: 'test' },
+      ...modelFields,
+    });
+
+    (model as unknown as { client: { send: unknown } }).client.send = jest.fn(
+      async () => ({
+        stream: (async function* () {
+          yield* events;
+        })(),
+      })
+    );
+
+    const dispatched: AIMessageChunk[] = [];
+    const runManager = {
+      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<CustomChatBedrockConverse['_streamResponseChunks']>[1],
+      runManager
+    )) {
+      if (chunk.message instanceof AIMessageChunk) {
+        yielded.push(chunk.message);
+      }
+    }
+    return { yielded, dispatched };
+  }
+
+  const toolUseEvents = [
+    {
+      contentBlockStart: {
+        contentBlockIndex: 1,
+        start: { toolUse: { toolUseId: 'call_1', name: 'weather' } },
+      },
+    },
+    {
+      contentBlockDelta: {
+        contentBlockIndex: 1,
+        delta: { toolUse: { input: '{"city":"NYC"}' } },
+      },
+    },
+    { contentBlockStop: { contentBlockIndex: 1 } },
+  ];
+
+  test('dispatches toolUse start and stop seal chunks to callbacks', async () => {
+    const { yielded, dispatched } = await runStream(toolUseEvents);
+
+    const sealOf = (m: AIMessageChunk): unknown =>
+      (m.response_metadata as Record<string, unknown>)[
+        STREAMED_TOOL_CALL_SEAL_METADATA_KEY
+      ];
+
+    expect(yielded.some((m) => sealOf(m) != null)).toBe(true);
+
+    expect(dispatched).toHaveLength(3);
+    expect(dispatched[0].tool_call_chunks).toMatchObject([
+      { id: 'call_1', name: 'weather', index: 1 },
+    ]);
+    expect(dispatched[1].tool_call_chunks).toMatchObject([
+      { args: '{"city":"NYC"}', index: 1 },
+    ]);
+    expect(sealOf(dispatched[2])).toEqual({ kind: 'single', index: 1 });
+    expect(
+      (dispatched[2].response_metadata as Record<string, unknown>)[
+        STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY
+      ]
+    ).toBe(BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER);
+  });
+
+  test('does not emit seal chunks when guardrails are configured', async () => {
+    const { yielded, dispatched } = await runStream(toolUseEvents, {
+      guardrailConfig: {
+        guardrailIdentifier: 'guardrail_1',
+        guardrailVersion: '1',
+      },
+    });
+
+    const hasSeal = (m: AIMessageChunk): boolean =>
+      (m.response_metadata as Record<string, unknown>)[
+        STREAMED_TOOL_CALL_SEAL_METADATA_KEY
+      ] != null;
+
+    // Guardrails can reject the turn at messageStop after contentBlockStop,
+    // so no eager seal may be emitted — but tool chunks still stream.
+    expect(yielded.some(hasSeal)).toBe(false);
+    expect(dispatched.some(hasSeal)).toBe(false);
+    expect(dispatched).toHaveLength(2);
+    expect(dispatched[0].tool_call_chunks).toMatchObject([
+      { id: 'call_1', name: 'weather', index: 1 },
+    ]);
+  });
+
+  test('does not emit seal chunks for non-toolUse block stops', async () => {
+    const { yielded, dispatched } = await runStream([
+      {
+        contentBlockDelta: {
+          contentBlockIndex: 0,
+          delta: { text: 'hello' },
+        },
+      },
+      { contentBlockStop: { contentBlockIndex: 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);
+    expect(dispatched).toHaveLength(1);
+  });
+});

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

@@ -10,6 +10,7 @@ export {
 
 export {
   convertConverseMessageToLangChainMessage,
+  createConverseToolUseStopChunk,
   handleConverseStreamContentBlockStart,
   handleConverseStreamContentBlockDelta,
   handleConverseStreamMetadata,

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

@@ -0,0 +1,85 @@
+import { expect, test, describe } from '@jest/globals';
+import { AIMessageChunk } from '@langchain/core/messages';
+import type { ContentBlockDeltaEvent, ContentBlockStartEvent } from '../types';
+import {
+  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
+import {
+  createConverseToolUseStopChunk,
+  handleConverseStreamContentBlockStart,
+  handleConverseStreamContentBlockDelta,
+} from './message_outputs';
+
+function asAIMessageChunk(message: unknown): AIMessageChunk {
+  expect(message).toBeInstanceOf(AIMessageChunk);
+  return message as AIMessageChunk;
+}
+
+describe('Converse streamed tool-call seal metadata', () => {
+  test('stamps the adapter on toolUse content block starts', () => {
+    const chunk = handleConverseStreamContentBlockStart({
+      contentBlockIndex: 1,
+      start: {
+        toolUse: { toolUseId: 'call_1', name: 'weather' },
+      },
+    } as ContentBlockStartEvent);
+
+    const message = asAIMessageChunk(chunk?.message);
+    expect(message.response_metadata).toMatchObject({
+      contentBlockIndex: 1,
+      [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+        BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
+    });
+    expect(message.tool_call_chunks).toEqual([
+      {
+        id: 'call_1',
+        name: 'weather',
+        index: 1,
+        type: 'tool_call_chunk',
+      },
+    ]);
+  });
+
+  test('stamps the adapter on toolUse deltas but not text deltas', () => {
+    const toolChunk = handleConverseStreamContentBlockDelta({
+      contentBlockIndex: 1,
+      delta: { toolUse: { input: '{"city":' } },
+    } as ContentBlockDeltaEvent);
+    const toolMetadata = asAIMessageChunk(toolChunk.message)
+      .response_metadata as Record<string, unknown>;
+    expect(toolMetadata[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]).toBe(
+      BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER
+    );
+
+    const textChunk = handleConverseStreamContentBlockDelta({
+      contentBlockIndex: 0,
+      delta: { text: 'hello' },
+    } as ContentBlockDeltaEvent);
+    const textMetadata = asAIMessageChunk(textChunk.message)
+      .response_metadata as Record<string, unknown>;
+    expect(
+      textMetadata[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]
+    ).toBeUndefined();
+  });
+
+  test('builds an explicit single seal chunk for a stopped toolUse block', () => {
+    const chunk = createConverseToolUseStopChunk(2);
+
+    const message = asAIMessageChunk(chunk.message);
+    expect(message.response_metadata).toEqual({
+      [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+        BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
+      [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: { kind: 'single', index: 2 },
+    });
+    expect(message.tool_call_chunks).toEqual([
+      {
+        args: '',
+        index: 2,
+        type: 'tool_call_chunk',
+      },
+    ]);
+    expect(message.content).toBe('');
+  });
+});

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

@@ -17,6 +17,11 @@ import type {
   MessageContentReasoningBlockReasoningTextPartial,
   MessageContentReasoningBlockRedacted,
 } from '../types';
+import {
+  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
 import { toLangChainContent } from '@/messages/langchain';
 
 /**
@@ -235,6 +240,8 @@ export function handleConverseStreamContentBlockDelta(
         ],
         response_metadata: {
           contentBlockIndex: contentBlockDelta.contentBlockIndex,
+          [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+            BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
         },
       }),
     });
@@ -292,6 +299,8 @@ export function handleConverseStreamContentBlockStart(
         ],
         response_metadata: {
           contentBlockIndex: index,
+          [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+            BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
         },
       }),
     });
@@ -301,6 +310,40 @@ export function handleConverseStreamContentBlockStart(
   return null;
 }
 
+/**
+ * Build the chunk emitted when a Converse `contentBlockStop` event closes a
+ * toolUse block. The Converse protocol guarantees a block's input is complete
+ * at `contentBlockStop`, so this chunk carries an explicit streamed tool-call
+ * seal for that block index. The empty `args` delta merges as a no-op into the
+ * accumulated tool call; id/name are omitted so the chunk matches the existing
+ * entry purely by index.
+ */
+export function createConverseToolUseStopChunk(
+  contentBlockIndex: number
+): ChatGenerationChunk {
+  return new ChatGenerationChunk({
+    text: '',
+    message: new AIMessageChunk({
+      content: '',
+      tool_call_chunks: [
+        {
+          args: '',
+          index: contentBlockIndex,
+          type: 'tool_call_chunk',
+        },
+      ],
+      response_metadata: {
+        [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+          BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
+        [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: {
+          kind: 'single',
+          index: contentBlockIndex,
+        },
+      },
+    }),
+  });
+}
+
 /**
  * Handle a metadata event from Bedrock Converse stream.
  */

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

@@ -0,0 +1,64 @@
+import { expect, test, describe } from '@jest/globals';
+import { AIMessageChunk } from '@langchain/core/messages';
+import type { EnhancedGenerateContentResponse } from '@google/generative-ai';
+import {
+  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
+import { convertResponseContentToChatGenerationChunk } from './common';
+
+function buildResponse(
+  parts: Array<Record<string, unknown>>
+): EnhancedGenerateContentResponse {
+  return {
+    candidates: [
+      {
+        content: { role: 'model', parts },
+        index: 0,
+      },
+    ],
+  } as unknown as EnhancedGenerateContentResponse;
+}
+
+function asAIMessageChunk(message: unknown): AIMessageChunk {
+  expect(message).toBeInstanceOf(AIMessageChunk);
+  return message as AIMessageChunk;
+}
+
+describe('convertResponseContentToChatGenerationChunk seal metadata', () => {
+  test('stamps an on-arrival seal on function call chunks', () => {
+    const chunk = convertResponseContentToChatGenerationChunk(
+      buildResponse([
+        {
+          functionCall: { name: 'weather', args: { city: 'NYC' } },
+        },
+      ]),
+      { usageMetadata: undefined, index: 0 }
+    );
+
+    const message = asAIMessageChunk(chunk?.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' },
+    });
+    expect(message.tool_call_chunks).toHaveLength(1);
+    expect(message.tool_calls?.[0]).toMatchObject({
+      name: 'weather',
+      args: { city: 'NYC' },
+    });
+  });
+
+  test('does not stamp seal metadata on text-only chunks', () => {
+    const chunk = convertResponseContentToChatGenerationChunk(
+      buildResponse([{ text: 'hello' }]),
+      { usageMetadata: undefined, index: 0 }
+    );
+
+    const metadata = asAIMessageChunk(chunk?.message)
+      .response_metadata as Record<string, unknown>;
+    expect(metadata[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]).toBeUndefined();
+    expect(metadata[STREAMED_TOOL_CALL_SEAL_METADATA_KEY]).toBeUndefined();
+  });
+});

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

@@ -35,6 +35,11 @@ import {
   type FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool,
 } from '@google/generative-ai';
 import type { ChatGeneration, ChatResult } 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 {
   jsonSchemaToGeminiParameters,
   schemaToGenerativeAIParameters,
@@ -770,6 +775,18 @@ export function convertResponseContentToChatGenerationChunk(
     response.candidates[0]?.finishReason === 'MAX_TOKENS' ||
     response.candidates[0]?.finishReason === 'SAFETY';
 
+  // The GenAI API delivers function calls as complete objects (never partial
+  // arg deltas), so every call on this chunk is sealed on arrival for eager
+  // tool execution.
+  const response_metadata: Record<string, unknown> | undefined =
+    toolCallChunks.length > 0
+      ? {
+        [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+            GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+        [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: { kind: 'all' },
+      }
+      : undefined;
+
   return new ChatGenerationChunk({
     text,
     message: new AIMessageChunk({
@@ -779,6 +796,7 @@ export function convertResponseContentToChatGenerationChunk(
       // Each chunk can have unique "generationInfo", and merging strategy is unclear,
       // so leave blank for now.
       additional_kwargs,
+      response_metadata,
       usage_metadata: isFinalChunk ? extra.usageMetadata : undefined,
     }),
     generationInfo,

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 {