@ai-sdk/provider-utils 5.0.0-beta.3 → 5.0.0-beta.30

package/src/index.ts

@@ -1,32 +1,45 @@
+export { asArray } from './as-array';
+export type { Arrayable } from './as-array';
 export * from './combine-headers';
 export { convertAsyncIteratorToReadableStream } from './convert-async-iterator-to-readable-stream';
+export { convertInlineFileDataToUint8Array } from './convert-inline-file-data-to-uint8-array';
+export { convertImageModelFileToDataUri } from './convert-image-model-file-to-data-uri';
+export { convertToFormData } from './convert-to-form-data';
 export {
   createToolNameMapping,
   type ToolNameMapping,
 } from './create-tool-name-mapping';
 export * from './delay';
 export { DelayedPromise } from './delayed-promise';
-export * from './extract-response-headers';
-export { convertImageModelFileToDataUri } from './convert-image-model-file-to-data-uri';
-export { convertToFormData } from './convert-to-form-data';
+export {
+  detectMediaType,
+  getTopLevelMediaType,
+  isFullMediaType,
+} from './detect-media-type';
 export { downloadBlob } from './download-blob';
 export { DownloadError } from './download-error';
-export {
-  readResponseWithSizeLimit,
-  DEFAULT_MAX_DOWNLOAD_SIZE,
-} from './read-response-with-size-limit';
+export * from './extract-response-headers';
 export * from './fetch-function';
+export { filterNullable } from './filter-nullable';
 export { createIdGenerator, generateId, type IdGenerator } from './generate-id';
 export * from './get-error-message';
 export * from './get-from-api';
 export { getRuntimeEnvironmentUserAgent } from './get-runtime-environment-user-agent';
+export type { HasRequiredKey } from './has-required-key';
 export { injectJsonInstructionIntoMessages } from './inject-json-instruction';
 export * from './is-abort-error';
+export { isBuffer } from './is-buffer';
 export { isNonNullable } from './is-non-nullable';
+export { isProviderReference } from './is-provider-reference';
 export { isUrlSupported } from './is-url-supported';
 export * from './load-api-key';
 export { loadOptionalSetting } from './load-optional-setting';
 export { loadSetting } from './load-setting';
+export {
+  isCustomReasoning,
+  mapReasoningToProviderBudget,
+  mapReasoningToProviderEffort,
+} from './map-reasoning-to-provider';
 export { type MaybePromiseLike } from './maybe-promise-like';
 export { mediaTypeToExtension } from './media-type-to-extension';
 export { normalizeHeaders } from './normalize-headers';
@@ -35,13 +48,23 @@ 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,
+} from './read-response-with-size-limit';
 export * from './remove-undefined-entries';
 export * from './resolve';
+export { resolveFullMediaType } from './resolve-full-media-type';
+export { resolveProviderReference } from './resolve-provider-reference';
 export * from './response-handler';
 export {
   asSchema,
@@ -54,6 +77,12 @@ export {
   type Schema,
   type ValidationResult,
 } from './schema';
+export { serializeModelOptions } from './serialize-model-options';
+export {
+  StreamingToolCallTracker,
+  type StreamingToolCallDelta,
+  type StreamingToolCallTrackerOptions,
+} from './streaming-tool-call-tracker';
 export { stripFileExtension } from './strip-file-extension';
 export * from './uint8-utils';
 export { validateDownloadUrl } from './validate-download-url';
@@ -67,6 +96,7 @@ export * from './types';
 
 // external re-exports
 export type * from '@standard-schema/spec';
+export { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from '@workflow/serde';
 export {
   EventSourceParserStream,
   type EventSourceMessage,

package/src/inject-json-instruction.ts

@@ -1,7 +1,7 @@
-import {
+import type {
   JSONSchema7,
-  LanguageModelV3Message,
-  LanguageModelV3Prompt,
+  LanguageModelV4Message,
+  LanguageModelV4Prompt,
 } from '@ai-sdk/provider';
 
 const DEFAULT_SCHEMA_PREFIX = 'JSON schema:';
@@ -39,12 +39,12 @@ export function injectJsonInstructionIntoMessages({
   schemaPrefix,
   schemaSuffix,
 }: {
-  messages: LanguageModelV3Prompt;
+  messages: LanguageModelV4Prompt;
   schema?: JSONSchema7;
   schemaPrefix?: string;
   schemaSuffix?: string;
-}): LanguageModelV3Prompt {
-  const systemMessage: LanguageModelV3Message =
+}): LanguageModelV4Prompt {
+  const systemMessage: LanguageModelV4Message =
     messages[0]?.role === 'system'
       ? { ...messages[0] }
       : { role: 'system', content: '' };

package/src/is-buffer.ts

@@ -0,0 +1,9 @@
+/**
+ * Type-guard for Node.js `Buffer` instances.
+ *
+ * Uses optional chaining on `globalThis.Buffer` so it returns `false` in
+ * runtimes where `Buffer` is not available (e.g. CloudFlare Workers).
+ */
+export function isBuffer(value: unknown): value is Buffer {
+  return globalThis.Buffer?.isBuffer(value) ?? false;
+}

package/src/is-json-serializable.ts

@@ -0,0 +1,29 @@
+import type { JSONValue } from '@ai-sdk/provider';
+
+/**
+ * Checks whether a value can cross a workflow serialization boundary.
+ *
+ * The check accepts JSON-like primitives, arrays, and plain objects whose
+ * nested values are also serializable. It rejects functions, symbols,
+ * bigints, and non-plain objects such as class instances, dates, and regexes.
+ */
+export function isJSONSerializable(value: unknown): value is JSONValue {
+  if (value === null || value === undefined) return true;
+
+  const type = typeof value;
+  if (type === 'string' || type === 'number' || type === 'boolean') return true;
+  if (type === 'function' || type === 'symbol' || type === 'bigint')
+    return false;
+
+  if (Array.isArray(value)) {
+    return value.every(isJSONSerializable);
+  }
+
+  if (Object.getPrototypeOf(value) === Object.prototype) {
+    return Object.values(value as Record<string, unknown>).every(
+      isJSONSerializable,
+    );
+  }
+
+  return false;
+}

package/src/is-provider-reference.ts

@@ -0,0 +1,21 @@
+import type { SharedV4ProviderReference } from '@ai-sdk/provider';
+import { isBuffer } from './is-buffer';
+
+/**
+ * Checks whether a value is a provider reference (a mapping of provider names
+ * to provider-specific identifiers) as opposed to raw bytes, a URL, or a
+ * tagged `{ type: ... }` object.
+ */
+export function isProviderReference(
+  data: unknown,
+): data is SharedV4ProviderReference {
+  return (
+    typeof data === 'object' &&
+    data !== null &&
+    !(data instanceof Uint8Array) &&
+    !(data instanceof URL) &&
+    !(data instanceof ArrayBuffer) &&
+    !isBuffer(data) &&
+    !('type' in data)
+  );
+}

package/src/is-url-supported.ts

@@ -1,7 +1,9 @@
 /**
  * Checks if the given URL is supported natively by the model.
  *
- * @param mediaType - The media type of the URL. Case-sensitive.
+ * @param mediaType - The media type of the URL. Case-sensitive. May be a full
+ *                    `type/subtype`, a wildcard `type/*`, or just the
+ *                    top-level segment (e.g. `image`).
  * @param url - The URL to check.
  * @param supportedUrls - A record where keys are case-sensitive media types (or '*')
  *                        and values are arrays of RegExp patterns for URLs.
@@ -22,6 +24,8 @@ export function isUrlSupported({
   url = url.toLowerCase();
   mediaType = mediaType.toLowerCase();
 
+  const isTopLevelOnly = !mediaType.includes('/');
+
   return (
     Object.entries(supportedUrls)
       // standardize supported url map into lowercase prefixes:
@@ -32,7 +36,18 @@ export function isUrlSupported({
           : { mediaTypePrefix: mediaType.replace(/\*/, ''), regexes: value };
       })
       // gather all regexp pattern from matched media type prefixes:
-      .filter(({ mediaTypePrefix }) => mediaType.startsWith(mediaTypePrefix))
+      .filter(({ mediaTypePrefix }) => {
+        if (mediaTypePrefix === '') {
+          return true;
+        }
+        // For a top-level-only media type (e.g. `image`), we cannot determine
+        // whether a specific subtype (e.g. `image/png`) would apply, so we
+        // only match the corresponding `type/*` prefix exactly.
+        if (isTopLevelOnly) {
+          return `${mediaType}/` === mediaTypePrefix;
+        }
+        return mediaType.startsWith(mediaTypePrefix);
+      })
       .flatMap(({ regexes }) => regexes)
       // check if any pattern matches the url:
       .some(pattern => pattern.test(url))

package/src/load-api-key.ts

@@ -23,7 +23,7 @@ export function loadApiKey({
 
   if (typeof process === 'undefined') {
     throw new LoadAPIKeyError({
-      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`,
+      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables are not supported in this environment.`,
     });
   }
 

package/src/load-setting.ts

@@ -35,7 +35,7 @@ export function loadSetting({
       message:
         `${description} setting is missing. ` +
         `Pass it using the '${settingName}' parameter. ` +
-        `Environment variables is not supported in this environment.`,
+        `Environment variables are not supported in this environment.`,
     });
   }
 

package/src/map-reasoning-to-provider.ts

@@ -0,0 +1,108 @@
+import type {
+  LanguageModelV4CallOptions,
+  SharedV4Warning,
+} from '@ai-sdk/provider';
+
+export type ReasoningLevel = Exclude<
+  LanguageModelV4CallOptions['reasoning'],
+  'none' | 'provider-default' | undefined
+>;
+
+export function isCustomReasoning(
+  reasoning: LanguageModelV4CallOptions['reasoning'],
+): reasoning is Exclude<
+  LanguageModelV4CallOptions['reasoning'],
+  'provider-default' | undefined
+> {
+  return reasoning !== undefined && reasoning !== 'provider-default';
+}
+
+/**
+ * Maps a top-level reasoning level to a provider-specific effort string using
+ * the given effort map. Pushes a compatibility warning if the reasoning level
+ * maps to a different string, or an unsupported warning if the level is not
+ * present in the map.
+ *
+ * @returns The mapped effort string, or `undefined` if the level is not
+ *   supported.
+ */
+export function mapReasoningToProviderEffort<T extends string>({
+  reasoning,
+  effortMap,
+  warnings,
+}: {
+  reasoning: ReasoningLevel;
+  effortMap: Partial<Record<ReasoningLevel, T>>;
+  warnings: SharedV4Warning[];
+}): T | undefined {
+  const mapped = effortMap[reasoning];
+
+  if (mapped == null) {
+    warnings.push({
+      type: 'unsupported',
+      feature: 'reasoning',
+      details: `reasoning "${reasoning}" is not supported by this model.`,
+    });
+    return undefined;
+  }
+
+  if (mapped !== reasoning) {
+    warnings.push({
+      type: 'compatibility',
+      feature: 'reasoning',
+      details: `reasoning "${reasoning}" is not directly supported by this model. mapped to effort "${mapped}".`,
+    });
+  }
+
+  return mapped;
+}
+
+const DEFAULT_REASONING_BUDGET_PERCENTAGES: Record<ReasoningLevel, number> = {
+  minimal: 0.02,
+  low: 0.1,
+  medium: 0.3,
+  high: 0.6,
+  xhigh: 0.9,
+};
+
+/**
+ * Maps a top-level reasoning level to an absolute token budget by multiplying
+ * the model's max output tokens by a percentage from the budget percentages
+ * map. The result is clamped between `minReasoningBudget` (default 1024) and
+ * `maxReasoningBudget`. Pushes an unsupported warning if the level is not
+ * present in the budget percentages map.
+ *
+ * @returns The computed token budget, or `undefined` if the level is not
+ *   supported.
+ */
+export function mapReasoningToProviderBudget({
+  reasoning,
+  maxOutputTokens,
+  maxReasoningBudget,
+  minReasoningBudget = 1024,
+  budgetPercentages = DEFAULT_REASONING_BUDGET_PERCENTAGES,
+  warnings,
+}: {
+  reasoning: ReasoningLevel;
+  maxOutputTokens: number;
+  maxReasoningBudget: number;
+  minReasoningBudget?: number;
+  budgetPercentages?: Partial<Record<ReasoningLevel, number>>;
+  warnings: SharedV4Warning[];
+}): number | undefined {
+  const pct = budgetPercentages[reasoning];
+
+  if (pct == null) {
+    warnings.push({
+      type: 'unsupported',
+      feature: 'reasoning',
+      details: `reasoning "${reasoning}" is not supported by this model.`,
+    });
+    return undefined;
+  }
+
+  return Math.min(
+    maxReasoningBudget,
+    Math.max(minReasoningBudget, Math.round(maxOutputTokens * pct)),
+  );
+}

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-event-stream.ts

@@ -1,9 +1,9 @@
 import {
-  EventSourceMessage,
   EventSourceParserStream,
+  type EventSourceMessage,
 } from 'eventsource-parser/stream';
-import { ParseResult, safeParseJSON } from './parse-json';
-import { FlexibleSchema } from './schema';
+import { safeParseJSON, type ParseResult } from './parse-json';
+import type { FlexibleSchema } from './schema';
 
 /**
  * Parses a JSON event stream into a stream of parsed JSON objects.

package/src/parse-json.ts

@@ -1,11 +1,11 @@
 import {
   JSONParseError,
-  JSONValue,
   TypeValidationError,
+  type JSONValue,
 } from '@ai-sdk/provider';
 import { secureJsonParse } from './secure-json-parse';
 import { safeValidateTypes, validateTypes } from './validate-types';
-import { FlexibleSchema } from './schema';
+import type { FlexibleSchema } from './schema';
 
 /**
  * Parses a JSON string into an unknown object.
@@ -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/parse-provider-options.ts

@@ -1,6 +1,6 @@
 import { InvalidArgumentError } from '@ai-sdk/provider';
 import { safeValidateTypes } from './validate-types';
-import { FlexibleSchema } from './schema';
+import type { FlexibleSchema } from './schema';
 
 export async function parseProviderOptions<OPTIONS>({
   provider,

package/src/post-to-api.ts

@@ -1,9 +1,9 @@
 import { APICallError } from '@ai-sdk/provider';
 import { extractResponseHeaders } from './extract-response-headers';
-import { FetchFunction } from './fetch-function';
+import type { FetchFunction } from './fetch-function';
 import { handleFetchError } from './handle-fetch-error';
 import { isAbortError } from './is-abort-error';
-import { ResponseHandler } from './response-handler';
+import type { ResponseHandler } from './response-handler';
 import { getRuntimeEnvironmentUserAgent } from './get-runtime-environment-user-agent';
 import { withUserAgentSuffix } from './with-user-agent-suffix';
 import { VERSION } from './version';
@@ -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-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>;
+}