@ai-sdk/provider-utils 5.0.0-beta.4 → 5.0.0-beta.49

package/src/provider-defined-tool-factory.ts

@@ -0,0 +1,129 @@
+import { tool, type ProviderDefinedTool, type Tool } from './types/tool';
+import type { FlexibleSchema } from './schema';
+import type { Context } from './types/context';
+import type { ToolExecuteFunction } from './types/tool-execute-function';
+/**
+ * A provider-defined tool is a tool for which the provider defines the input
+ * and output schemas, but does not execute the tool.
+ */
+export type ProviderDefinedToolFactory<
+  INPUT,
+  ARGS extends object,
+  CONTEXT extends Context = {},
+> = <OUTPUT>(
+  options: ARGS & {
+    execute?: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
+    needsApproval?: Tool<INPUT, OUTPUT, CONTEXT>['needsApproval'];
+    toModelOutput?: Tool<INPUT, OUTPUT, CONTEXT>['toModelOutput'];
+    onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
+    onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
+    onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
+  },
+) => ProviderDefinedTool<INPUT, OUTPUT, CONTEXT>;
+
+export function createProviderDefinedToolFactory<
+  INPUT,
+  ARGS extends object,
+  CONTEXT extends Context = {},
+>({
+  id,
+  inputSchema,
+}: {
+  id: `${string}.${string}`;
+  inputSchema: FlexibleSchema<INPUT>;
+}): ProviderDefinedToolFactory<INPUT, ARGS, CONTEXT> {
+  return <OUTPUT>({
+    execute,
+    outputSchema,
+    needsApproval,
+    toModelOutput,
+    onInputStart,
+    onInputDelta,
+    onInputAvailable,
+    ...args
+  }: ARGS & {
+    execute?: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
+    outputSchema?: FlexibleSchema<OUTPUT>;
+    needsApproval?: Tool<INPUT, OUTPUT, CONTEXT>['needsApproval'];
+    toModelOutput?: Tool<INPUT, OUTPUT, CONTEXT>['toModelOutput'];
+    onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
+    onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
+    onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
+  }): ProviderDefinedTool<INPUT, OUTPUT, CONTEXT> =>
+    tool({
+      type: 'provider',
+      isProviderExecuted: false,
+      id,
+      args,
+      inputSchema,
+      outputSchema,
+      execute,
+      needsApproval,
+      toModelOutput,
+      onInputStart,
+      onInputDelta,
+      onInputAvailable,
+    }) as ProviderDefinedTool<INPUT, OUTPUT, CONTEXT>;
+}
+
+export type ProviderDefinedToolFactoryWithOutputSchema<
+  INPUT,
+  OUTPUT,
+  ARGS extends object,
+  CONTEXT extends Context = {},
+> = (
+  options: ARGS & {
+    execute?: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
+    needsApproval?: Tool<INPUT, OUTPUT, CONTEXT>['needsApproval'];
+    toModelOutput?: Tool<INPUT, OUTPUT, CONTEXT>['toModelOutput'];
+    onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
+    onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
+    onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
+  },
+) => ProviderDefinedTool<INPUT, OUTPUT, CONTEXT>;
+
+export function createProviderDefinedToolFactoryWithOutputSchema<
+  INPUT,
+  OUTPUT,
+  ARGS extends object,
+  CONTEXT extends Context = {},
+>({
+  id,
+  inputSchema,
+  outputSchema,
+}: {
+  id: `${string}.${string}`;
+  inputSchema: FlexibleSchema<INPUT>;
+  outputSchema: FlexibleSchema<OUTPUT>;
+}): ProviderDefinedToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS, CONTEXT> {
+  return ({
+    execute,
+    needsApproval,
+    toModelOutput,
+    onInputStart,
+    onInputDelta,
+    onInputAvailable,
+    ...args
+  }: ARGS & {
+    execute?: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
+    needsApproval?: Tool<INPUT, OUTPUT, CONTEXT>['needsApproval'];
+    toModelOutput?: Tool<INPUT, OUTPUT, CONTEXT>['toModelOutput'];
+    onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
+    onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
+    onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
+  }): ProviderDefinedTool<INPUT, OUTPUT, CONTEXT> =>
+    tool({
+      type: 'provider',
+      isProviderExecuted: false,
+      id,
+      args,
+      inputSchema,
+      outputSchema,
+      execute,
+      needsApproval,
+      toModelOutput,
+      onInputStart,
+      onInputDelta,
+      onInputAvailable,
+    }) as ProviderDefinedTool<INPUT, OUTPUT, CONTEXT>;
+}

package/src/provider-executed-tool-factory.ts

@@ -0,0 +1,69 @@
+import type { FlexibleSchema } from './schema';
+import type { Context } from './types/context';
+import { tool, type ProviderExecutedTool, type Tool } from './types/tool';
+/**
+ * A provider-executed tool is a tool for which the provider executes the tool.
+ */
+export type ProviderExecutedToolFactory<
+  INPUT,
+  OUTPUT,
+  ARGS extends object,
+  CONTEXT extends Context = {},
+> = (
+  options: ARGS & {
+    onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
+    onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
+    onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
+  },
+) => ProviderExecutedTool<INPUT, OUTPUT, CONTEXT>;
+
+export function createProviderExecutedToolFactory<
+  INPUT,
+  OUTPUT,
+  ARGS extends object,
+  CONTEXT extends Context = {},
+>({
+  id,
+  inputSchema,
+  outputSchema,
+  supportsDeferredResults,
+}: {
+  id: `${string}.${string}`;
+  inputSchema: FlexibleSchema<INPUT>;
+  outputSchema: FlexibleSchema<OUTPUT>;
+
+  /**
+   * Whether this provider-executed tool supports deferred results.
+   *
+   * When true, the tool result may not be returned in the same turn as the
+   * tool call (e.g., when using programmatic tool calling where a server tool
+   * triggers a client-executed tool, and the server tool's result is deferred
+   * until the client tool is resolved).
+   *
+   * @default false
+   */
+  supportsDeferredResults?: boolean;
+}): ProviderExecutedToolFactory<INPUT, OUTPUT, ARGS, CONTEXT> {
+  return ({
+    onInputStart,
+    onInputDelta,
+    onInputAvailable,
+    ...args
+  }: ARGS & {
+    onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
+    onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
+    onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
+  }): ProviderExecutedTool<INPUT, OUTPUT, CONTEXT> =>
+    tool({
+      type: 'provider',
+      isProviderExecuted: true,
+      id,
+      args,
+      inputSchema,
+      outputSchema,
+      onInputStart,
+      onInputDelta,
+      onInputAvailable,
+      supportsDeferredResults,
+    }) as ProviderExecutedTool<INPUT, OUTPUT, CONTEXT>;
+}

package/src/read-response-with-size-limit.ts

@@ -1,3 +1,4 @@
+import { cancelResponseBody } from './cancel-response-body';
 import { DownloadError } from './download-error';
 
 /**
@@ -40,6 +41,9 @@ export async function readResponseWithSizeLimit({
   if (contentLength != null) {
     const length = parseInt(contentLength, 10);
     if (!isNaN(length) && length > maxBytes) {
+      // Cancel the body so the underlying connection is released back to the
+      // pool instead of being left open until the socket is exhausted.
+      await cancelResponseBody(response);
       throw new DownloadError({
         url,
         message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes (Content-Length: ${length}).`,

package/src/resolve-full-media-type.ts

@@ -0,0 +1,49 @@
+import {
+  UnsupportedFunctionalityError,
+  type LanguageModelV4FilePart,
+} from '@ai-sdk/provider';
+import {
+  detectMediaType,
+  getTopLevelMediaType,
+  isFullMediaType,
+} from './detect-media-type';
+
+/**
+ * Resolves a file part's media type to a full `type/subtype` form required by
+ * providers whose API demands the full IANA media type.
+ *
+ * - If `part.mediaType` is already a full media type (e.g. `image/png`), it is
+ *   returned as-is.
+ * - Otherwise, when inline bytes are available (`part.data.type === 'data'`),
+ *   the subtype is sniffed from the bytes using the signature table that
+ *   corresponds to the top-level segment.
+ * - When neither applies (e.g. top-level-only with a URL source, or bytes that
+ *   cannot be detected), an `UnsupportedFunctionalityError` is thrown.
+ */
+export function resolveFullMediaType({
+  part,
+}: {
+  part: LanguageModelV4FilePart;
+}): string {
+  if (isFullMediaType(part.mediaType)) {
+    return part.mediaType;
+  }
+
+  if (part.data.type === 'data') {
+    const detected = detectMediaType({
+      data: part.data.data,
+      topLevelType: getTopLevelMediaType(part.mediaType),
+    });
+    if (detected) {
+      return detected;
+    }
+
+    throw new UnsupportedFunctionalityError({
+      functionality: `file of media type "${part.mediaType}" must specify subtype since it could not be auto-detected`,
+    });
+  }
+
+  throw new UnsupportedFunctionalityError({
+    functionality: `file of media type "${part.mediaType}" must specify subtype since it is not passed as inline bytes`,
+  });
+}

package/src/resolve-provider-reference.ts

@@ -0,0 +1,26 @@
+import {
+  NoSuchProviderReferenceError,
+  type SharedV4ProviderReference,
+} from '@ai-sdk/provider';
+/**
+ * Resolves a provider reference to the provider-specific identifier for the
+ * given provider. Throws `NoSuchProviderReferenceError` if the provider is not
+ * found in the reference mapping.
+ */
+export function resolveProviderReference({
+  reference,
+  provider,
+}: {
+  reference: SharedV4ProviderReference;
+  provider: string;
+}): string {
+  const id = reference[provider];
+  if (id != null) {
+    return id;
+  }
+
+  throw new NoSuchProviderReferenceError({
+    provider,
+    reference,
+  });
+}

package/src/resolve.ts

@@ -1,5 +1,20 @@
-import { MaybePromiseLike } from './maybe-promise-like';
+import type { MaybePromiseLike } from './maybe-promise-like';
 
+/**
+ * A value or a lazy provider of a value, each of which may be synchronous or asynchronous.
+ *
+ * @template T The resolved type after {@link resolve} runs.
+ *
+ * One of:
+ * - A plain value of type {@link T}
+ * - A {@link PromiseLike} of {@link T} (e.g. a `Promise<T>`)
+ * - A zero-argument function that returns a plain {@link T}
+ * - A zero-argument function that returns a {@link PromiseLike} of {@link T}
+ *
+ * The function form is only invoked when passed to {@link resolve}; it is not distinguished from
+ * a {@link T} that happens to be a function—callers should wrap function values if disambiguation
+ * is required.
+ */
 export type Resolvable<T> = MaybePromiseLike<T> | (() => MaybePromiseLike<T>);
 
 /**

package/src/response-handler.ts

@@ -1,8 +1,8 @@
 import { APICallError, EmptyResponseBodyError } from '@ai-sdk/provider';
 import { extractResponseHeaders } from './extract-response-headers';
-import { parseJSON, ParseResult, safeParseJSON } from './parse-json';
+import { parseJSON, safeParseJSON, type ParseResult } from './parse-json';
 import { parseJsonEventStream } from './parse-json-event-stream';
-import { FlexibleSchema } from './schema';
+import type { FlexibleSchema } from './schema';
 
 export type ResponseHandler<RETURN_TYPE> = (options: {
   url: string;
@@ -64,7 +64,7 @@ export const createJsonErrorResponseHandler =
           isRetryable: isRetryable?.(response, parsedError),
         }),
       };
-    } catch (parseError) {
+    } catch {
       return {
         responseHeaders,
         value: new APICallError({

package/src/schema.ts

@@ -1,6 +1,9 @@
-import { JSONSchema7, TypeValidationError } from '@ai-sdk/provider';
-import { StandardSchemaV1, StandardJSONSchemaV1 } from '@standard-schema/spec';
-import * as z3 from 'zod/v3';
+import { TypeValidationError, type JSONSchema7 } from '@ai-sdk/provider';
+import type {
+  StandardSchemaV1,
+  StandardJSONSchemaV1,
+} from '@standard-schema/spec';
+import type * as z3 from 'zod/v3';
 import * as z4 from 'zod/v4';
 import { addAdditionalPropertiesToJsonSchema } from './add-additional-properties-to-json-schema';
 import { zod3ToJsonSchema } from './to-json-schema/zod3-to-json-schema';
@@ -133,7 +136,11 @@ export function asSchema<OBJECT>(
   schema: FlexibleSchema<OBJECT> | undefined,
 ): Schema<OBJECT> {
   return schema == null
-    ? jsonSchema({ properties: {}, additionalProperties: false })
+    ? jsonSchema({
+        type: 'object',
+        properties: {},
+        additionalProperties: false,
+      })
     : isSchema(schema)
       ? schema
       : '~standard' in schema

package/src/secure-json-parse.ts

@@ -83,7 +83,7 @@ export function secureJsonParse(text: string) {
   try {
     // Performance optimization, see https://github.com/fastify/secure-json-parse/pull/90
     Error.stackTraceLimit = 0;
-  } catch (e) {
+  } catch {
     // Fallback in case Error is immutable (v8 readonly)
     return _parse(text);
   }

package/src/serialize-model-options.ts

@@ -0,0 +1,63 @@
+import type { JSONObject } from '@ai-sdk/provider';
+import { isJSONSerializable } from './is-json-serializable';
+import type { Resolvable } from './resolve';
+
+/**
+ * Serializes a model instance for workflow step boundaries.
+ * Returns the `modelId` plus the JSON-serializable config properties.
+ *
+ * Non-serializable values are omitted. As a special case, a
+ * function-valued `headers` property is resolved during serialization
+ * and included if the returned value is JSON-serializable.
+ *
+ * Used as the body of `static [WORKFLOW_SERIALIZE]` in provider models.
+ *
+ * @example
+ * ```ts
+ * static [WORKFLOW_SERIALIZE](model: MyLanguageModel) {
+ *   return serializeModelOptions({
+ *     modelId: model.modelId,
+ *     config: model.config,
+ *   });
+ * }
+ * ```
+ */
+export function serializeModelOptions<
+  CONFIG extends {
+    headers?: Resolvable<Record<string, string | undefined>>;
+  },
+>(options: {
+  modelId: string;
+  config: CONFIG;
+}): {
+  modelId: string;
+  config: JSONObject;
+} {
+  const serializableConfig: JSONObject = {};
+  for (const [key, value] of Object.entries(options.config)) {
+    if (key === 'headers') {
+      const resolvedHeaders = resolveSync(value);
+      if (isJSONSerializable(resolvedHeaders)) {
+        serializableConfig[key] = resolvedHeaders;
+      }
+    } else if (isJSONSerializable(value)) {
+      serializableConfig[key] = value;
+    }
+  }
+  return { modelId: options.modelId, config: serializableConfig };
+}
+
+function resolveSync<T>(value: Resolvable<T>): T {
+  let next: unknown = value;
+  if (typeof value === 'function') {
+    next = (value as () => unknown)();
+  }
+
+  // the serialization for workflows currently only supports synchronous values
+  // TODO introduce SerializationError
+  if (next instanceof Promise) {
+    throw new Error('Promise returned from resolveSync');
+  }
+
+  return next as T;
+}

package/src/streaming-tool-call-tracker.ts

@@ -0,0 +1,241 @@
+import {
+  InvalidResponseDataError,
+  type LanguageModelV4StreamPart,
+  type SharedV4ProviderMetadata,
+} from '@ai-sdk/provider';
+import { generateId as defaultGenerateId } from './generate-id';
+import { isParsableJson } from './parse-json';
+
+/**
+ * Minimal interface for a streaming tool call delta from an OpenAI-compatible API.
+ */
+export interface StreamingToolCallDelta {
+  index?: number | null;
+  id?: string | null;
+  type?: string | null;
+  function?: {
+    name?: string | null;
+    arguments?: string | null;
+  } | null;
+}
+
+export interface StreamingToolCallTrackerOptions<
+  DELTA extends StreamingToolCallDelta = StreamingToolCallDelta,
+> {
+  /**
+   * ID generator function for tool call IDs.
+   * Defaults to the standard generateId.
+   */
+  generateId?: () => string;
+
+  /**
+   * How to validate the `type` field on new tool call deltas.
+   * - `'none'`: no validation (default)
+   * - `'if-present'`: throw if type is present and not `'function'`
+   * - `'required'`: throw if type is not exactly `'function'`
+   */
+  typeValidation?: 'none' | 'if-present' | 'required';
+
+  /**
+   * Extract provider-specific metadata from a tool call delta.
+   * Called once when a new tool call is detected.
+   * The returned metadata is stored on the tool call and passed to
+   * `buildToolCallProviderMetadata` when the tool call is finalized.
+   */
+  extractMetadata?: (delta: DELTA) => SharedV4ProviderMetadata | undefined;
+
+  /**
+   * Build the `providerMetadata` object for a `tool-call` event.
+   * Receives the metadata previously extracted via `extractMetadata`.
+   * If `undefined` is returned, no `providerMetadata` is included in the event.
+   */
+  buildToolCallProviderMetadata?: (
+    metadata: SharedV4ProviderMetadata | undefined,
+  ) => SharedV4ProviderMetadata | undefined;
+}
+
+interface TrackedToolCall {
+  id: string;
+  type: 'function';
+  function: { name: string; arguments: string };
+  hasFinished: boolean;
+  metadata?: SharedV4ProviderMetadata;
+}
+
+type StreamingToolCallTrackerController = Pick<
+  TransformStreamDefaultController<LanguageModelV4StreamPart>,
+  'enqueue'
+>;
+
+/**
+ * Tracks streaming tool call state across multiple deltas from an
+ * OpenAI-compatible chat completion stream. Handles argument accumulation,
+ * emits tool-input-start/delta/end and tool-call events, and finalizes
+ * unfinished tool calls on flush.
+ *
+ * Used by openai, openai-compatible, groq, deepseek, and alibaba providers.
+ */
+export class StreamingToolCallTracker<
+  DELTA extends StreamingToolCallDelta = StreamingToolCallDelta,
+> {
+  private toolCalls: TrackedToolCall[] = [];
+  private readonly controller: StreamingToolCallTrackerController;
+  private readonly _generateId: () => string;
+  private readonly typeValidation: 'none' | 'if-present' | 'required';
+  private readonly extractMetadata?: (
+    delta: DELTA,
+  ) => SharedV4ProviderMetadata | undefined;
+  private readonly buildToolCallProviderMetadata?: (
+    metadata: SharedV4ProviderMetadata | undefined,
+  ) => SharedV4ProviderMetadata | undefined;
+
+  constructor(
+    controller: StreamingToolCallTrackerController,
+    options: StreamingToolCallTrackerOptions<DELTA> = {},
+  ) {
+    this.controller = controller;
+    this._generateId = options.generateId ?? defaultGenerateId;
+    this.typeValidation = options.typeValidation ?? 'none';
+    this.extractMetadata = options.extractMetadata;
+    this.buildToolCallProviderMetadata = options.buildToolCallProviderMetadata;
+  }
+
+  /**
+   * Process a tool call delta from a streaming response chunk.
+   * Emits tool-input-start, tool-input-delta, tool-input-end, and tool-call
+   * events as appropriate.
+   */
+  processDelta(toolCallDelta: DELTA): void {
+    const index = toolCallDelta.index ?? this.toolCalls.length;
+
+    if (this.toolCalls[index] == null) {
+      this.processNewToolCall(index, toolCallDelta);
+    } else {
+      this.processExistingToolCall(index, toolCallDelta);
+    }
+  }
+
+  /**
+   * Finalize any unfinished tool calls. Should be called during the stream's
+   * flush handler to ensure all tool calls are properly completed.
+   */
+  flush(): void {
+    for (const toolCall of this.toolCalls) {
+      if (!toolCall.hasFinished) {
+        this.finishToolCall(toolCall);
+      }
+    }
+  }
+
+  private processNewToolCall(index: number, toolCallDelta: DELTA): void {
+    if (this.typeValidation === 'required') {
+      if (toolCallDelta.type !== 'function') {
+        throw new InvalidResponseDataError({
+          data: toolCallDelta,
+          message: `Expected 'function' type.`,
+        });
+      }
+    } else if (this.typeValidation === 'if-present') {
+      if (toolCallDelta.type != null && toolCallDelta.type !== 'function') {
+        throw new InvalidResponseDataError({
+          data: toolCallDelta,
+          message: `Expected 'function' type.`,
+        });
+      }
+    }
+
+    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.`,
+      });
+    }
+
+    this.controller.enqueue({
+      type: 'tool-input-start',
+      id: toolCallDelta.id,
+      toolName: toolCallDelta.function.name,
+    });
+
+    const metadata = this.extractMetadata?.(toolCallDelta);
+
+    this.toolCalls[index] = {
+      id: toolCallDelta.id,
+      type: 'function',
+      function: {
+        name: toolCallDelta.function.name,
+        arguments: toolCallDelta.function.arguments ?? '',
+      },
+      hasFinished: false,
+      metadata,
+    };
+
+    const toolCall = this.toolCalls[index];
+
+    // Emit initial delta if arguments already present
+    if (toolCall.function.arguments.length > 0) {
+      this.controller.enqueue({
+        type: 'tool-input-delta',
+        id: toolCall.id,
+        delta: toolCall.function.arguments,
+      });
+    }
+
+    // Check if tool call is complete
+    // (some providers send the full tool call in one chunk)
+    if (isParsableJson(toolCall.function.arguments)) {
+      this.finishToolCall(toolCall);
+    }
+  }
+
+  private processExistingToolCall(index: number, toolCallDelta: DELTA): void {
+    const toolCall = this.toolCalls[index];
+
+    if (toolCall.hasFinished) {
+      return;
+    }
+
+    if (toolCallDelta.function?.arguments != null) {
+      toolCall.function.arguments += toolCallDelta.function.arguments;
+
+      this.controller.enqueue({
+        type: 'tool-input-delta',
+        id: toolCall.id,
+        delta: toolCallDelta.function.arguments,
+      });
+    }
+
+    // Check if tool call is complete
+    if (isParsableJson(toolCall.function.arguments)) {
+      this.finishToolCall(toolCall);
+    }
+  }
+
+  private finishToolCall(toolCall: TrackedToolCall): void {
+    this.controller.enqueue({
+      type: 'tool-input-end',
+      id: toolCall.id,
+    });
+
+    const providerMetadata = this.buildToolCallProviderMetadata?.(
+      toolCall.metadata,
+    );
+
+    this.controller.enqueue({
+      type: 'tool-call',
+      toolCallId: toolCall.id ?? this._generateId(),
+      toolName: toolCall.function.name,
+      input: toolCall.function.arguments,
+      ...(providerMetadata ? { providerMetadata } : {}),
+    });
+
+    toolCall.hasFinished = true;
+  }
+}

package/src/test/convert-response-stream-to-array.ts

@@ -3,7 +3,7 @@ import { convertReadableStreamToArray } from './convert-readable-stream-to-array
 export async function convertResponseStreamToArray(
   response: Response,
 ): Promise<string[]> {
-  return convertReadableStreamToArray(
+  return await convertReadableStreamToArray(
     response.body!.pipeThrough(new TextDecoderStream()),
   );
 }