@ai-sdk/provider-utils 5.0.0-beta.25 → 5.0.0-beta.27

package/dist/test/index.d.ts

@@ -9,9 +9,10 @@ declare function convertReadableStreamToArray<T>(stream: ReadableStream<T>): Pro
 declare function convertResponseStreamToArray(response: Response): Promise<string[]>;
 
 declare function isNodeVersion(version: number): boolean;
+declare function isNodeVersionAtLeast(major: number, minor?: number, patch?: number): boolean;
 
 declare function mockId({ prefix, }?: {
     prefix?: string;
 }): () => string;
 
-export { convertArrayToAsyncIterable, convertArrayToReadableStream, convertAsyncIterableToArray, convertReadableStreamToArray, convertResponseStreamToArray, isNodeVersion, mockId };
+export { convertArrayToAsyncIterable, convertArrayToReadableStream, convertAsyncIterableToArray, convertReadableStreamToArray, convertResponseStreamToArray, isNodeVersion, isNodeVersionAtLeast, mockId };

package/dist/test/index.js

@@ -47,16 +47,29 @@ async function convertReadableStreamToArray(stream) {
 
 // src/test/convert-response-stream-to-array.ts
 async function convertResponseStreamToArray(response) {
-  return convertReadableStreamToArray(
+  return await convertReadableStreamToArray(
     response.body.pipeThrough(new TextDecoderStream())
   );
 }
 
 // src/test/is-node-version.ts
+function getNodeVersionParts() {
+  return process.versions.node.split(".").map((version) => Number.parseInt(version, 10));
+}
 function isNodeVersion(version) {
-  const nodeMajorVersion = parseInt(process.version.slice(1).split(".")[0], 10);
+  const [nodeMajorVersion] = getNodeVersionParts();
   return nodeMajorVersion === version;
 }
+function isNodeVersionAtLeast(major, minor = 0, patch = 0) {
+  const [nodeMajorVersion, nodeMinorVersion, nodePatchVersion] = getNodeVersionParts();
+  if (nodeMajorVersion !== major) {
+    return nodeMajorVersion > major;
+  }
+  if (nodeMinorVersion !== minor) {
+    return nodeMinorVersion > minor;
+  }
+  return nodePatchVersion >= patch;
+}
 
 // src/test/mock-id.ts
 function mockId({
@@ -72,6 +85,7 @@ export {
   convertReadableStreamToArray,
   convertResponseStreamToArray,
   isNodeVersion,
+  isNodeVersionAtLeast,
   mockId
 };
 //# sourceMappingURL=index.js.map

package/dist/test/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/test/convert-array-to-async-iterable.ts","../../src/test/convert-array-to-readable-stream.ts","../../src/test/convert-async-iterable-to-array.ts","../../src/test/convert-readable-stream-to-array.ts","../../src/test/convert-response-stream-to-array.ts","../../src/test/is-node-version.ts","../../src/test/mock-id.ts"],"sourcesContent":["export function convertArrayToAsyncIterable<T>(values: T[]): AsyncIterable<T> {\n  return {\n    async *[Symbol.asyncIterator]() {\n      for (const value of values) {\n        yield value;\n      }\n    },\n  };\n}\n","export function convertArrayToReadableStream<T>(\n  values: T[],\n): ReadableStream<T> {\n  return new ReadableStream({\n    start(controller) {\n      try {\n        for (const value of values) {\n          controller.enqueue(value);\n        }\n      } finally {\n        controller.close();\n      }\n    },\n  });\n}\n","export async function convertAsyncIterableToArray<T>(\n  iterable: AsyncIterable<T>,\n): Promise<T[]> {\n  const result: T[] = [];\n  for await (const item of iterable) {\n    result.push(item);\n  }\n  return result;\n}\n","export async function convertReadableStreamToArray<T>(\n  stream: ReadableStream<T>,\n): Promise<T[]> {\n  const reader = stream.getReader();\n  const result: T[] = [];\n\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    result.push(value);\n  }\n\n  return result;\n}\n","import { convertReadableStreamToArray } from './convert-readable-stream-to-array';\n\nexport async function convertResponseStreamToArray(\n  response: Response,\n): Promise<string[]> {\n  return convertReadableStreamToArray(\n    response.body!.pipeThrough(new TextDecoderStream()),\n  );\n}\n","export function isNodeVersion(version: number) {\n  const nodeMajorVersion = parseInt(process.version.slice(1).split('.')[0], 10);\n  return nodeMajorVersion === version;\n}\n","export function mockId({\n  prefix = 'id',\n}: {\n  prefix?: string;\n} = {}): () => string {\n  let counter = 0;\n  return () => `${prefix}-${counter++}`;\n}\n"],"mappings":";AAAO,SAAS,4BAA+B,QAA+B;AAC5E,SAAO;AAAA,IACL,QAAQ,OAAO,aAAa,IAAI;AAC9B,iBAAW,SAAS,QAAQ;AAC1B,cAAM;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACF;;;ACRO,SAAS,6BACd,QACmB;AACnB,SAAO,IAAI,eAAe;AAAA,IACxB,MAAM,YAAY;AAChB,UAAI;AACF,mBAAW,SAAS,QAAQ;AAC1B,qBAAW,QAAQ,KAAK;AAAA,QAC1B;AAAA,MACF,UAAE;AACA,mBAAW,MAAM;AAAA,MACnB;AAAA,IACF;AAAA,EACF,CAAC;AACH;;;ACdA,eAAsB,4BACpB,UACc;AACd,QAAM,SAAc,CAAC;AACrB,mBAAiB,QAAQ,UAAU;AACjC,WAAO,KAAK,IAAI;AAAA,EAClB;AACA,SAAO;AACT;;;ACRA,eAAsB,6BACpB,QACc;AACd,QAAM,SAAS,OAAO,UAAU;AAChC,QAAM,SAAc,CAAC;AAErB,SAAO,MAAM;AACX,UAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAC1C,QAAI,KAAM;AACV,WAAO,KAAK,KAAK;AAAA,EACnB;AAEA,SAAO;AACT;;;ACXA,eAAsB,6BACpB,UACmB;AACnB,SAAO;AAAA,IACL,SAAS,KAAM,YAAY,IAAI,kBAAkB,CAAC;AAAA,EACpD;AACF;;;ACRO,SAAS,cAAc,SAAiB;AAC7C,QAAM,mBAAmB,SAAS,QAAQ,QAAQ,MAAM,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC,GAAG,EAAE;AAC5E,SAAO,qBAAqB;AAC9B;;;ACHO,SAAS,OAAO;AAAA,EACrB,SAAS;AACX,IAEI,CAAC,GAAiB;AACpB,MAAI,UAAU;AACd,SAAO,MAAM,GAAG,MAAM,IAAI,SAAS;AACrC;","names":[]}
+{"version":3,"sources":["../../src/test/convert-array-to-async-iterable.ts","../../src/test/convert-array-to-readable-stream.ts","../../src/test/convert-async-iterable-to-array.ts","../../src/test/convert-readable-stream-to-array.ts","../../src/test/convert-response-stream-to-array.ts","../../src/test/is-node-version.ts","../../src/test/mock-id.ts"],"sourcesContent":["export function convertArrayToAsyncIterable<T>(values: T[]): AsyncIterable<T> {\n  return {\n    async *[Symbol.asyncIterator]() {\n      for (const value of values) {\n        yield value;\n      }\n    },\n  };\n}\n","export function convertArrayToReadableStream<T>(\n  values: T[],\n): ReadableStream<T> {\n  return new ReadableStream({\n    start(controller) {\n      try {\n        for (const value of values) {\n          controller.enqueue(value);\n        }\n      } finally {\n        controller.close();\n      }\n    },\n  });\n}\n","export async function convertAsyncIterableToArray<T>(\n  iterable: AsyncIterable<T>,\n): Promise<T[]> {\n  const result: T[] = [];\n  for await (const item of iterable) {\n    result.push(item);\n  }\n  return result;\n}\n","export async function convertReadableStreamToArray<T>(\n  stream: ReadableStream<T>,\n): Promise<T[]> {\n  const reader = stream.getReader();\n  const result: T[] = [];\n\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    result.push(value);\n  }\n\n  return result;\n}\n","import { convertReadableStreamToArray } from './convert-readable-stream-to-array';\n\nexport async function convertResponseStreamToArray(\n  response: Response,\n): Promise<string[]> {\n  return await convertReadableStreamToArray(\n    response.body!.pipeThrough(new TextDecoderStream()),\n  );\n}\n","function getNodeVersionParts() {\n  return process.versions.node\n    .split('.')\n    .map(version => Number.parseInt(version, 10));\n}\n\nexport function isNodeVersion(version: number) {\n  const [nodeMajorVersion] = getNodeVersionParts();\n  return nodeMajorVersion === version;\n}\n\nexport function isNodeVersionAtLeast(major: number, minor = 0, patch = 0) {\n  const [nodeMajorVersion, nodeMinorVersion, nodePatchVersion] =\n    getNodeVersionParts();\n\n  if (nodeMajorVersion !== major) {\n    return nodeMajorVersion > major;\n  }\n\n  if (nodeMinorVersion !== minor) {\n    return nodeMinorVersion > minor;\n  }\n\n  return nodePatchVersion >= patch;\n}\n","export function mockId({\n  prefix = 'id',\n}: {\n  prefix?: string;\n} = {}): () => string {\n  let counter = 0;\n  return () => `${prefix}-${counter++}`;\n}\n"],"mappings":";AAAO,SAAS,4BAA+B,QAA+B;AAC5E,SAAO;AAAA,IACL,QAAQ,OAAO,aAAa,IAAI;AAC9B,iBAAW,SAAS,QAAQ;AAC1B,cAAM;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACF;;;ACRO,SAAS,6BACd,QACmB;AACnB,SAAO,IAAI,eAAe;AAAA,IACxB,MAAM,YAAY;AAChB,UAAI;AACF,mBAAW,SAAS,QAAQ;AAC1B,qBAAW,QAAQ,KAAK;AAAA,QAC1B;AAAA,MACF,UAAE;AACA,mBAAW,MAAM;AAAA,MACnB;AAAA,IACF;AAAA,EACF,CAAC;AACH;;;ACdA,eAAsB,4BACpB,UACc;AACd,QAAM,SAAc,CAAC;AACrB,mBAAiB,QAAQ,UAAU;AACjC,WAAO,KAAK,IAAI;AAAA,EAClB;AACA,SAAO;AACT;;;ACRA,eAAsB,6BACpB,QACc;AACd,QAAM,SAAS,OAAO,UAAU;AAChC,QAAM,SAAc,CAAC;AAErB,SAAO,MAAM;AACX,UAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAC1C,QAAI,KAAM;AACV,WAAO,KAAK,KAAK;AAAA,EACnB;AAEA,SAAO;AACT;;;ACXA,eAAsB,6BACpB,UACmB;AACnB,SAAO,MAAM;AAAA,IACX,SAAS,KAAM,YAAY,IAAI,kBAAkB,CAAC;AAAA,EACpD;AACF;;;ACRA,SAAS,sBAAsB;AAC7B,SAAO,QAAQ,SAAS,KACrB,MAAM,GAAG,EACT,IAAI,aAAW,OAAO,SAAS,SAAS,EAAE,CAAC;AAChD;AAEO,SAAS,cAAc,SAAiB;AAC7C,QAAM,CAAC,gBAAgB,IAAI,oBAAoB;AAC/C,SAAO,qBAAqB;AAC9B;AAEO,SAAS,qBAAqB,OAAe,QAAQ,GAAG,QAAQ,GAAG;AACxE,QAAM,CAAC,kBAAkB,kBAAkB,gBAAgB,IACzD,oBAAoB;AAEtB,MAAI,qBAAqB,OAAO;AAC9B,WAAO,mBAAmB;AAAA,EAC5B;AAEA,MAAI,qBAAqB,OAAO;AAC9B,WAAO,mBAAmB;AAAA,EAC5B;AAEA,SAAO,oBAAoB;AAC7B;;;ACxBO,SAAS,OAAO;AAAA,EACrB,SAAS;AACX,IAEI,CAAC,GAAiB;AACpB,MAAI,UAAU;AACd,SAAO,MAAM,GAAG,MAAM,IAAI,SAAS;AACrC;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/provider-utils",
-  "version": "5.0.0-beta.25",
+  "version": "5.0.0-beta.27",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -34,7 +34,7 @@
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
     "@workflow/serde": "4.1.0",
-    "eventsource-parser": "^3.0.6",
+    "eventsource-parser": "^3.0.8",
     "@ai-sdk/provider": "4.0.0-beta.12"
   },
   "devDependencies": {
@@ -52,7 +52,8 @@
     "node": ">=18"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "homepage": "https://ai-sdk.dev/docs",
   "repository": {

package/src/index.ts

@@ -41,11 +41,15 @@ export { parseJsonEventStream } from './parse-json-event-stream';
 export { parseProviderOptions } from './parse-provider-options';
 export * from './post-to-api';
 export {
-  createProviderToolFactory,
-  createProviderToolFactoryWithOutputSchema,
-  type ProviderToolFactory,
-  type ProviderToolFactoryWithOutputSchema,
-} from './provider-tool-factory';
+  createProviderDefinedToolFactory,
+  createProviderDefinedToolFactoryWithOutputSchema,
+  type ProviderDefinedToolFactory,
+  type ProviderDefinedToolFactoryWithOutputSchema,
+} from './provider-defined-tool-factory';
+export {
+  createProviderExecutedToolFactory,
+  type ProviderExecutedToolFactory,
+} from './provider-executed-tool-factory';
 export {
   DEFAULT_MAX_DOWNLOAD_SIZE,
   readResponseWithSizeLimit,

package/src/maybe-promise-like.ts

@@ -1,3 +1,6 @@
+/**
+ * A value that can be provided either synchronously or as a promise-like.
+ */
 export type MaybePromiseLike<T> =
   | T // Raw value
   | PromiseLike<T>; // Promise of value

package/src/parse-json.ts

@@ -43,7 +43,7 @@ export async function parseJSON<T>({
       return value;
     }
 
-    return validateTypes<T>({ value, schema });
+    return await validateTypes<T>({ value, schema });
   } catch (error) {
     if (
       JSONParseError.isInstance(error) ||

package/src/post-to-api.ts

@@ -28,7 +28,7 @@ export const postJsonToApi = async <T>({
   abortSignal?: AbortSignal;
   fetch?: FetchFunction;
 }) =>
-  postToApi({
+  await postToApi({
     url,
     headers: {
       'Content-Type': 'application/json',
@@ -61,7 +61,7 @@ export const postFormDataToApi = async <T>({
   abortSignal?: AbortSignal;
   fetch?: FetchFunction;
 }) =>
-  postToApi({
+  await postToApi({
     url,
     headers,
     body: {

package/src/{provider-tool-factory.ts → provider-defined-tool-factory.ts}

@@ -1,8 +1,11 @@
 import { tool, Tool, ToolExecuteFunction } from './types/tool';
 import { FlexibleSchema } from './schema';
 import { Context } from './types/context';
-
-export type ProviderToolFactory<
+/**
+ * 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 = {},
@@ -17,7 +20,7 @@ export type ProviderToolFactory<
   },
 ) => Tool<INPUT, OUTPUT, CONTEXT>;
 
-export function createProviderToolFactory<
+export function createProviderDefinedToolFactory<
   INPUT,
   ARGS extends object,
   CONTEXT extends Context = {},
@@ -27,7 +30,7 @@ export function createProviderToolFactory<
 }: {
   id: `${string}.${string}`;
   inputSchema: FlexibleSchema<INPUT>;
-}): ProviderToolFactory<INPUT, ARGS, CONTEXT> {
+}): ProviderDefinedToolFactory<INPUT, ARGS, CONTEXT> {
   return <OUTPUT>({
     execute,
     outputSchema,
@@ -48,6 +51,7 @@ export function createProviderToolFactory<
   }): Tool<INPUT, OUTPUT, CONTEXT> =>
     tool({
       type: 'provider',
+      isProviderExecuted: false,
       id,
       args,
       inputSchema,
@@ -61,7 +65,7 @@ export function createProviderToolFactory<
     });
 }
 
-export type ProviderToolFactoryWithOutputSchema<
+export type ProviderDefinedToolFactoryWithOutputSchema<
   INPUT,
   OUTPUT,
   ARGS extends object,
@@ -77,7 +81,7 @@ export type ProviderToolFactoryWithOutputSchema<
   },
 ) => Tool<INPUT, OUTPUT, CONTEXT>;
 
-export function createProviderToolFactoryWithOutputSchema<
+export function createProviderDefinedToolFactoryWithOutputSchema<
   INPUT,
   OUTPUT,
   ARGS extends object,
@@ -86,23 +90,11 @@ export function createProviderToolFactoryWithOutputSchema<
   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;
-}): ProviderToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS, CONTEXT> {
+}): ProviderDefinedToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS, CONTEXT> {
   return ({
     execute,
     needsApproval,
@@ -121,6 +113,7 @@ export function createProviderToolFactoryWithOutputSchema<
   }): Tool<INPUT, OUTPUT, CONTEXT> =>
     tool({
       type: 'provider',
+      isProviderExecuted: false,
       id,
       args,
       inputSchema,
@@ -131,6 +124,5 @@ export function createProviderToolFactoryWithOutputSchema<
       onInputStart,
       onInputDelta,
       onInputAvailable,
-      supportsDeferredResults,
     });
 }

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

@@ -0,0 +1,70 @@
+import { FlexibleSchema } from './schema';
+import { Context } from './types/context';
+import { tool, 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'];
+  },
+) => Tool<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'];
+  }): Tool<INPUT, OUTPUT, CONTEXT> =>
+    tool({
+      type: 'provider',
+      isProviderExecuted: true,
+      id,
+      args,
+      inputSchema,
+      outputSchema,
+      onInputStart,
+      onInputDelta,
+      onInputAvailable,
+      supportsDeferredResults,
+    });
+}

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

@@ -19,7 +19,9 @@ export interface StreamingToolCallDelta {
   } | null;
 }
 
-export interface StreamingToolCallTrackerOptions {
+export interface StreamingToolCallTrackerOptions<
+  DELTA extends StreamingToolCallDelta = StreamingToolCallDelta,
+> {
   /**
    * ID generator function for tool call IDs.
    * Defaults to the standard generateId.
@@ -40,9 +42,7 @@ export interface StreamingToolCallTrackerOptions {
    * The returned metadata is stored on the tool call and passed to
    * `buildToolCallProviderMetadata` when the tool call is finalized.
    */
-  extractMetadata?: (
-    delta: StreamingToolCallDelta,
-  ) => SharedV4ProviderMetadata | undefined;
+  extractMetadata?: (delta: DELTA) => SharedV4ProviderMetadata | undefined;
 
   /**
    * Build the `providerMetadata` object for a `tool-call` event.
@@ -62,6 +62,11 @@ interface TrackedToolCall {
   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,
@@ -70,18 +75,25 @@ interface TrackedToolCall {
  *
  * Used by openai, openai-compatible, groq, deepseek, and alibaba providers.
  */
-export class StreamingToolCallTracker {
+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: StreamingToolCallDelta,
+    delta: DELTA,
   ) => SharedV4ProviderMetadata | undefined;
   private readonly buildToolCallProviderMetadata?: (
     metadata: SharedV4ProviderMetadata | undefined,
   ) => SharedV4ProviderMetadata | undefined;
 
-  constructor(options: StreamingToolCallTrackerOptions = {}) {
+  constructor(
+    controller: StreamingToolCallTrackerController,
+    options: StreamingToolCallTrackerOptions<DELTA> = {},
+  ) {
+    this.controller = controller;
     this._generateId = options.generateId ?? defaultGenerateId;
     this.typeValidation = options.typeValidation ?? 'none';
     this.extractMetadata = options.extractMetadata;
@@ -93,16 +105,13 @@ export class StreamingToolCallTracker {
    * Emits tool-input-start, tool-input-delta, tool-input-end, and tool-call
    * events as appropriate.
    */
-  processDelta(
-    toolCallDelta: StreamingToolCallDelta,
-    enqueue: (part: LanguageModelV4StreamPart) => void,
-  ): void {
+  processDelta(toolCallDelta: DELTA): void {
     const index = toolCallDelta.index ?? this.toolCalls.length;
 
     if (this.toolCalls[index] == null) {
-      this.processNewToolCall(index, toolCallDelta, enqueue);
+      this.processNewToolCall(index, toolCallDelta);
     } else {
-      this.processExistingToolCall(index, toolCallDelta, enqueue);
+      this.processExistingToolCall(index, toolCallDelta);
     }
   }
 
@@ -110,19 +119,15 @@ export class StreamingToolCallTracker {
    * Finalize any unfinished tool calls. Should be called during the stream's
    * flush handler to ensure all tool calls are properly completed.
    */
-  flush(enqueue: (part: LanguageModelV4StreamPart) => void): void {
+  flush(): void {
     for (const toolCall of this.toolCalls) {
       if (!toolCall.hasFinished) {
-        this.finishToolCall(toolCall, enqueue);
+        this.finishToolCall(toolCall);
       }
     }
   }
 
-  private processNewToolCall(
-    index: number,
-    toolCallDelta: StreamingToolCallDelta,
-    enqueue: (part: LanguageModelV4StreamPart) => void,
-  ): void {
+  private processNewToolCall(index: number, toolCallDelta: DELTA): void {
     if (this.typeValidation === 'required') {
       if (toolCallDelta.type !== 'function') {
         throw new InvalidResponseDataError({
@@ -153,7 +158,7 @@ export class StreamingToolCallTracker {
       });
     }
 
-    enqueue({
+    this.controller.enqueue({
       type: 'tool-input-start',
       id: toolCallDelta.id,
       toolName: toolCallDelta.function.name,
@@ -176,7 +181,7 @@ export class StreamingToolCallTracker {
 
     // Emit initial delta if arguments already present
     if (toolCall.function.arguments.length > 0) {
-      enqueue({
+      this.controller.enqueue({
         type: 'tool-input-delta',
         id: toolCall.id,
         delta: toolCall.function.arguments,
@@ -186,15 +191,11 @@ export class StreamingToolCallTracker {
     // Check if tool call is complete
     // (some providers send the full tool call in one chunk)
     if (isParsableJson(toolCall.function.arguments)) {
-      this.finishToolCall(toolCall, enqueue);
+      this.finishToolCall(toolCall);
     }
   }
 
-  private processExistingToolCall(
-    index: number,
-    toolCallDelta: StreamingToolCallDelta,
-    enqueue: (part: LanguageModelV4StreamPart) => void,
-  ): void {
+  private processExistingToolCall(index: number, toolCallDelta: DELTA): void {
     const toolCall = this.toolCalls[index];
 
     if (toolCall.hasFinished) {
@@ -204,7 +205,7 @@ export class StreamingToolCallTracker {
     if (toolCallDelta.function?.arguments != null) {
       toolCall.function.arguments += toolCallDelta.function.arguments;
 
-      enqueue({
+      this.controller.enqueue({
         type: 'tool-input-delta',
         id: toolCall.id,
         delta: toolCallDelta.function.arguments,
@@ -213,15 +214,12 @@ export class StreamingToolCallTracker {
 
     // Check if tool call is complete
     if (isParsableJson(toolCall.function.arguments)) {
-      this.finishToolCall(toolCall, enqueue);
+      this.finishToolCall(toolCall);
     }
   }
 
-  private finishToolCall(
-    toolCall: TrackedToolCall,
-    enqueue: (part: LanguageModelV4StreamPart) => void,
-  ): void {
-    enqueue({
+  private finishToolCall(toolCall: TrackedToolCall): void {
+    this.controller.enqueue({
       type: 'tool-input-end',
       id: toolCall.id,
     });
@@ -230,7 +228,7 @@ export class StreamingToolCallTracker {
       toolCall.metadata,
     );
 
-    enqueue({
+    this.controller.enqueue({
       type: 'tool-call',
       toolCallId: toolCall.id ?? this._generateId(),
       toolName: toolCall.function.name,

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()),
   );
 }

package/src/test/is-node-version.ts

@@ -1,4 +1,25 @@
+function getNodeVersionParts() {
+  return process.versions.node
+    .split('.')
+    .map(version => Number.parseInt(version, 10));
+}
+
 export function isNodeVersion(version: number) {
-  const nodeMajorVersion = parseInt(process.version.slice(1).split('.')[0], 10);
+  const [nodeMajorVersion] = getNodeVersionParts();
   return nodeMajorVersion === version;
 }
+
+export function isNodeVersionAtLeast(major: number, minor = 0, patch = 0) {
+  const [nodeMajorVersion, nodeMinorVersion, nodePatchVersion] =
+    getNodeVersionParts();
+
+  if (nodeMajorVersion !== major) {
+    return nodeMajorVersion > major;
+  }
+
+  if (nodeMinorVersion !== minor) {
+    return nodeMinorVersion > minor;
+  }
+
+  return nodePatchVersion >= patch;
+}

package/src/types/index.ts

@@ -24,6 +24,7 @@ export type { InferToolSetContext } from './infer-tool-set-context';
 export type { ModelMessage } from './model-message';
 export type { ProviderOptions } from './provider-options';
 export type { ProviderReference } from './provider-reference';
+export type { SensitiveContext } from './sensitive-context';
 export type { SystemModelMessage } from './system-model-message';
 export {
   dynamicTool,

package/src/types/sensitive-context.ts

@@ -0,0 +1,9 @@
+import type { Context } from './context';
+
+/**
+ * Top-level context properties that contain sensitive data and should be
+ * excluded from telemetry.
+ */
+export type SensitiveContext<CONTEXT extends Context | unknown | never> =
+  | { [KEY in keyof CONTEXT]?: boolean }
+  | undefined;

package/src/types/tool-approval-request.ts

@@ -13,4 +13,11 @@ export type ToolApprovalRequest = {
    * ID of the tool call that the approval request is for.
    */
   toolCallId: string;
+
+  /**
+   * Flag indicating whether the tool was automatically approved or denied.
+   *
+   * @default false
+   */
+  isAutomatic?: boolean;
 };