@ai-sdk/openai-compatible 2.0.79 → 2.0.81

package/src/chat/openai-compatible-chat-language-model.ts

@@ -13,6 +13,7 @@ import {
   type SharedV3Warning,
 } from '@ai-sdk/provider';
 import {
+  StreamingToolCallTracker,
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonErrorResponseHandler,
@@ -23,6 +24,7 @@ import {
   type FetchFunction,
   type ParseResult,
   type ResponseHandler,
+  type StreamingToolCallDelta,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import { resolveProviderOptionsKey, toCamelCase } from '../utils/to-camel-case';
@@ -41,6 +43,20 @@ import {
 import type { MetadataExtractor } from './openai-compatible-metadata-extractor';
 import { prepareTools } from './openai-compatible-prepare-tools';
 
+type OpenAICompatibleStreamingToolCallDelta = StreamingToolCallDelta & {
+  extra_content?: {
+    google?: {
+      thought_signature?: string | null;
+    } | null;
+  } | null;
+};
+
+type PendingToolCall = {
+  id: string | null;
+  bufferedArguments: string;
+  extraContent: OpenAICompatibleStreamingToolCallDelta['extra_content'];
+};
+
 export type OpenAICompatibleChatConfig = {
   provider: string;
   headers: () => Record<string, string | undefined>;
@@ -410,34 +426,70 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
       fetch: this.config.fetch,
     });
 
-    const toolCalls: Array<{
-      id: string;
-      type: 'function';
-      function: {
-        name: string;
-        arguments: string;
-      };
-      hasFinished: boolean;
-      thoughtSignature?: string;
-    }> = [];
+    const providerOptionsName = metadataKey;
+    let toolCallTracker: StreamingToolCallTracker<OpenAICompatibleStreamingToolCallDelta>;
 
     // Buffers tool-call deltas by `index` until `function.name` is known.
     // Some OpenAI-compatible providers send the first delta without
-    // `function.name`.
-    const pendingToolCalls = new Map<
-      number,
-      {
-        id: string | null;
-        bufferedArguments: string;
-        thoughtSignature: string | undefined;
+    // `function.name`, which the shared tracker rejects on first chunk.
+    const pendingToolCalls = new Map<number, PendingToolCall>();
+    const forwardedToolCallIndices = new Set<number>();
+
+    const processToolCallDelta = (
+      toolCallDelta: OpenAICompatibleStreamingToolCallDelta,
+    ) => {
+      const index = toolCallDelta.index;
+
+      if (index == null || forwardedToolCallIndices.has(index)) {
+        toolCallTracker.processDelta(toolCallDelta);
+        return;
+      }
+
+      let pending = pendingToolCalls.get(index);
+      if (pending == null) {
+        pending = {
+          id: toolCallDelta.id ?? null,
+          bufferedArguments: '',
+          extraContent: toolCallDelta.extra_content ?? null,
+        };
+        pendingToolCalls.set(index, pending);
+      } else {
+        if (pending.id == null && toolCallDelta.id != null) {
+          pending.id = toolCallDelta.id;
+        }
+        if (
+          pending.extraContent == null &&
+          toolCallDelta.extra_content != null
+        ) {
+          pending.extraContent = toolCallDelta.extra_content;
+        }
+      }
+
+      const argumentsDelta = toolCallDelta.function?.arguments;
+      if (argumentsDelta != null) {
+        pending.bufferedArguments += argumentsDelta;
       }
-    >();
+
+      const name = toolCallDelta.function?.name;
+      if (name != null) {
+        toolCallTracker.processDelta({
+          index,
+          id: pending.id,
+          function: {
+            name,
+            arguments: pending.bufferedArguments,
+          },
+          extra_content: pending.extraContent ?? undefined,
+        });
+        pendingToolCalls.delete(index);
+        forwardedToolCallIndices.add(index);
+      }
+    };
 
     let finishReason: LanguageModelV3FinishReason | undefined;
     let usage: z.infer<typeof openaiCompatibleTokenUsageSchema> | undefined =
       undefined;
     let isFirstChunk = true;
-    const providerOptionsName = metadataKey;
     let isActiveReasoning = false;
     let isActiveText = false;
     const convertUsage = (
@@ -451,6 +503,22 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
           LanguageModelV3StreamPart
         >({
           start(controller) {
+            toolCallTracker =
+              new StreamingToolCallTracker<OpenAICompatibleStreamingToolCallDelta>(
+                controller,
+                {
+                  generateId,
+                  extractMetadata: delta => {
+                    const thoughtSignature =
+                      delta.extra_content?.google?.thought_signature;
+
+                    return thoughtSignature
+                      ? { [providerOptionsName]: { thoughtSignature } }
+                      : undefined;
+                  },
+                  buildToolCallProviderMetadata: metadata => metadata,
+                },
+              );
             controller.enqueue({ type: 'stream-start', warnings });
           },
 
@@ -580,144 +648,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
               }
 
               for (const toolCallDelta of delta.tool_calls) {
-                const index = toolCallDelta.index ?? toolCalls.length;
-
-                if (toolCalls[index] == null) {
-                  if (toolCallDelta.index != null) {
-                    // Buffer deltas until `function.name` is known. Some
-                    // OpenAI-compatible providers send the first delta
-                    // without `function.name`.
-                    let pending = pendingToolCalls.get(index);
-                    if (pending == null) {
-                      pending = {
-                        id: toolCallDelta.id ?? null,
-                        bufferedArguments: '',
-                        thoughtSignature:
-                          toolCallDelta.extra_content?.google
-                            ?.thought_signature ?? undefined,
-                      };
-                      pendingToolCalls.set(index, pending);
-                    } else {
-                      if (pending.id == null && toolCallDelta.id != null) {
-                        pending.id = toolCallDelta.id;
-                      }
-                      if (
-                        pending.thoughtSignature == null &&
-                        toolCallDelta.extra_content?.google
-                          ?.thought_signature != null
-                      ) {
-                        pending.thoughtSignature =
-                          toolCallDelta.extra_content.google.thought_signature;
-                      }
-                    }
-
-                    const argumentsDelta = toolCallDelta.function?.arguments;
-                    if (argumentsDelta != null) {
-                      pending.bufferedArguments += argumentsDelta;
-                    }
-
-                    const name = toolCallDelta.function?.name;
-                    if (name == null) {
-                      continue; // wait for the delta that carries the name
-                    }
-
-                    pendingToolCalls.delete(index);
-
-                    if (pending.id == null) {
-                      throw new InvalidResponseDataError({
-                        data: toolCallDelta,
-                        message: `Expected 'id' to be a string.`,
-                      });
-                    }
-
-                    controller.enqueue({
-                      type: 'tool-input-start',
-                      id: pending.id,
-                      toolName: name,
-                    });
-
-                    toolCalls[index] = {
-                      id: pending.id,
-                      type: 'function',
-                      function: {
-                        name,
-                        arguments: pending.bufferedArguments,
-                      },
-                      hasFinished: false,
-                      thoughtSignature: pending.thoughtSignature,
-                    };
-                  } else {
-                    if (toolCallDelta.id == null) {
-                      throw new InvalidResponseDataError({
-                        data: toolCallDelta,
-                        message: `Expected 'id' to be a string.`,
-                      });
-                    }
-
-                    if (toolCallDelta.function?.name == null) {
-                      throw new InvalidResponseDataError({
-                        data: toolCallDelta,
-                        message: `Expected 'function.name' to be a string.`,
-                      });
-                    }
-
-                    controller.enqueue({
-                      type: 'tool-input-start',
-                      id: toolCallDelta.id,
-                      toolName: toolCallDelta.function.name,
-                    });
-
-                    toolCalls[index] = {
-                      id: toolCallDelta.id,
-                      type: 'function',
-                      function: {
-                        name: toolCallDelta.function.name,
-                        arguments: toolCallDelta.function.arguments ?? '',
-                      },
-                      hasFinished: false,
-                      thoughtSignature:
-                        toolCallDelta.extra_content?.google
-                          ?.thought_signature ?? undefined,
-                    };
-                  }
-
-                  const toolCall = toolCalls[index];
-
-                  if (
-                    toolCall.function?.name != null &&
-                    toolCall.function?.arguments != null
-                  ) {
-                    // send delta if the argument text has already started:
-                    if (toolCall.function.arguments.length > 0) {
-                      controller.enqueue({
-                        type: 'tool-input-delta',
-                        id: toolCall.id,
-                        delta: toolCall.function.arguments,
-                      });
-                    }
-                  }
-
-                  continue;
-                }
-
-                // existing tool call, merge if not finished
-                const toolCall = toolCalls[index];
-
-                if (toolCall.hasFinished) {
-                  continue;
-                }
-
-                if (toolCallDelta.function?.arguments != null) {
-                  toolCall.function!.arguments +=
-                    toolCallDelta.function?.arguments ?? '';
-                }
-
-                // send delta
-                controller.enqueue({
-                  type: 'tool-input-delta',
-                  id: toolCall.id,
-                  delta: toolCallDelta.function.arguments ?? '',
-                });
+                processToolCallDelta(toolCallDelta);
               }
             }
           },
@@ -731,44 +662,18 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
               controller.enqueue({ type: 'text-end', id: 'txt-0' });
             }
 
-            // Tool-call deltas that never received a `function.name` are
-            // invalid, preserving the original invalid-response semantics.
+            // Forward pending deltas so the tracker preserves the existing
+            // invalid-response behavior for calls that never receive a name.
             for (const [index, pending] of pendingToolCalls) {
-              throw new InvalidResponseDataError({
-                data: {
-                  index,
-                  id: pending.id,
-                  function: { arguments: pending.bufferedArguments },
-                },
-                message: `Expected 'function.name' to be a string.`,
+              toolCallTracker.processDelta({
+                index,
+                id: pending.id,
+                function: { arguments: pending.bufferedArguments },
               });
             }
+            pendingToolCalls.clear();
 
-            // go through all tool calls and send the ones that are not finished
-            for (const toolCall of toolCalls.filter(
-              toolCall => !toolCall.hasFinished,
-            )) {
-              controller.enqueue({
-                type: 'tool-input-end',
-                id: toolCall.id,
-              });
-
-              controller.enqueue({
-                type: 'tool-call',
-                toolCallId: toolCall.id ?? generateId(),
-                toolName: toolCall.function.name,
-                input: toolCall.function.arguments,
-                ...(toolCall.thoughtSignature
-                  ? {
-                      providerMetadata: {
-                        [providerOptionsName]: {
-                          thoughtSignature: toolCall.thoughtSignature,
-                        },
-                      },
-                    }
-                  : {}),
-              });
-            }
+            toolCallTracker.flush();
 
             if (finishReason == null) {
               finishReason = { unified: 'error', raw: undefined };