@ai-sdk/provider-utils 5.0.0-beta.9 → 5.0.0-canary.32

package/src/index.ts

@@ -1,37 +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 { loadOptionalSetting } from './load-optional-setting';
-export { loadSetting } from './load-setting';
 export { type MaybePromiseLike } from './maybe-promise-like';
 export { mediaTypeToExtension } from './media-type-to-extension';
 export { normalizeHeaders } from './normalize-headers';
@@ -40,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,
@@ -59,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';
@@ -72,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,4 +1,4 @@
-import {
+import type {
   JSONSchema7,
   LanguageModelV4Message,
   LanguageModelV4Prompt,

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

@@ -1,4 +1,7 @@
-import { LanguageModelV4CallOptions, SharedV4Warning } from '@ai-sdk/provider';
+import type {
+  LanguageModelV4CallOptions,
+  SharedV4Warning,
+} from '@ai-sdk/provider';
 
 export type ReasoningLevel = Exclude<
   LanguageModelV4CallOptions['reasoning'],

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-tool-factory.ts → provider-defined-tool-factory.ts}

@@ -1,8 +1,12 @@
-import { tool, Tool, ToolExecuteFunction } from './types/tool';
-import { FlexibleSchema } from './schema';
-import { Context } from './types/context';
-
-export type ProviderToolFactory<
+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 = {},
@@ -15,9 +19,9 @@ export type ProviderToolFactory<
     onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
     onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
   },
-) => Tool<INPUT, OUTPUT, CONTEXT>;
+) => ProviderDefinedTool<INPUT, OUTPUT, CONTEXT>;
 
-export function createProviderToolFactory<
+export function createProviderDefinedToolFactory<
   INPUT,
   ARGS extends object,
   CONTEXT extends Context = {},
@@ -27,7 +31,7 @@ export function createProviderToolFactory<
 }: {
   id: `${string}.${string}`;
   inputSchema: FlexibleSchema<INPUT>;
-}): ProviderToolFactory<INPUT, ARGS, CONTEXT> {
+}): ProviderDefinedToolFactory<INPUT, ARGS, CONTEXT> {
   return <OUTPUT>({
     execute,
     outputSchema,
@@ -45,9 +49,10 @@ export function createProviderToolFactory<
     onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
     onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
     onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
-  }): Tool<INPUT, OUTPUT, CONTEXT> =>
+  }): ProviderDefinedTool<INPUT, OUTPUT, CONTEXT> =>
     tool({
       type: 'provider',
+      isProviderExecuted: false,
       id,
       args,
       inputSchema,
@@ -58,10 +63,10 @@ export function createProviderToolFactory<
       onInputStart,
       onInputDelta,
       onInputAvailable,
-    });
+    }) as ProviderDefinedTool<INPUT, OUTPUT, CONTEXT>;
 }
 
-export type ProviderToolFactoryWithOutputSchema<
+export type ProviderDefinedToolFactoryWithOutputSchema<
   INPUT,
   OUTPUT,
   ARGS extends object,
@@ -75,9 +80,9 @@ export type ProviderToolFactoryWithOutputSchema<
     onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
     onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
   },
-) => Tool<INPUT, OUTPUT, CONTEXT>;
+) => ProviderDefinedTool<INPUT, OUTPUT, CONTEXT>;
 
-export function createProviderToolFactoryWithOutputSchema<
+export function createProviderDefinedToolFactoryWithOutputSchema<
   INPUT,
   OUTPUT,
   ARGS extends object,
@@ -86,23 +91,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,
@@ -118,9 +111,10 @@ export function createProviderToolFactoryWithOutputSchema<
     onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
     onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
     onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
-  }): Tool<INPUT, OUTPUT, CONTEXT> =>
+  }): ProviderDefinedTool<INPUT, OUTPUT, CONTEXT> =>
     tool({
       type: 'provider',
+      isProviderExecuted: false,
       id,
       args,
       inputSchema,
@@ -131,6 +125,5 @@ export function createProviderToolFactoryWithOutputSchema<
       onInputStart,
       onInputDelta,
       onInputAvailable,
-      supportsDeferredResults,
-    });
+    }) 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/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';

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