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

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

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

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/to-json-schema/zod3-to-json-schema/options.ts

@@ -1,6 +1,6 @@
-import { ZodSchema, ZodTypeDef } from 'zod/v3';
-import { Refs, Seen } from './refs';
-import { JsonSchema7Type } from './parse-types';
+import type { ZodSchema, ZodTypeDef } from 'zod/v3';
+import type { Refs, Seen } from './refs';
+import type { JsonSchema7Type } from './parse-types';
 
 export type DateStrategy =
   | 'format:date-time'

package/src/to-json-schema/zod3-to-json-schema/parse-def.ts

@@ -1,7 +1,7 @@
-import { ZodTypeDef } from 'zod/v3';
-import { Refs, Seen } from './refs';
+import type { ZodTypeDef } from 'zod/v3';
+import type { Refs, Seen } from './refs';
 import { ignoreOverride } from './options';
-import { JsonSchema7Type } from './parse-types';
+import type { JsonSchema7Type } from './parse-types';
 import { selectParser } from './select-parser';
 import { getRelativePath } from './get-relative-path';
 import { parseAnyDef } from './parsers/any';

package/src/to-json-schema/zod3-to-json-schema/parse-types.ts

@@ -1,25 +1,25 @@
-import { JsonSchema7AnyType } from './parsers/any';
-import { JsonSchema7ArrayType } from './parsers/array';
-import { JsonSchema7BigintType } from './parsers/bigint';
-import { JsonSchema7BooleanType } from './parsers/boolean';
-import { JsonSchema7DateType } from './parsers/date';
-import { JsonSchema7EnumType } from './parsers/enum';
-import { JsonSchema7AllOfType } from './parsers/intersection';
-import { JsonSchema7LiteralType } from './parsers/literal';
-import { JsonSchema7MapType } from './parsers/map';
-import { JsonSchema7NativeEnumType } from './parsers/native-enum';
-import { JsonSchema7NeverType } from './parsers/never';
-import { JsonSchema7NullType } from './parsers/null';
-import { JsonSchema7NullableType } from './parsers/nullable';
-import { JsonSchema7NumberType } from './parsers/number';
-import { JsonSchema7ObjectType } from './parsers/object';
-import { JsonSchema7RecordType } from './parsers/record';
-import { JsonSchema7SetType } from './parsers/set';
-import { JsonSchema7StringType } from './parsers/string';
-import { JsonSchema7TupleType } from './parsers/tuple';
-import { JsonSchema7UndefinedType } from './parsers/undefined';
-import { JsonSchema7UnionType } from './parsers/union';
-import { JsonSchema7UnknownType } from './parsers/unknown';
+import type { JsonSchema7AnyType } from './parsers/any';
+import type { JsonSchema7ArrayType } from './parsers/array';
+import type { JsonSchema7BigintType } from './parsers/bigint';
+import type { JsonSchema7BooleanType } from './parsers/boolean';
+import type { JsonSchema7DateType } from './parsers/date';
+import type { JsonSchema7EnumType } from './parsers/enum';
+import type { JsonSchema7AllOfType } from './parsers/intersection';
+import type { JsonSchema7LiteralType } from './parsers/literal';
+import type { JsonSchema7MapType } from './parsers/map';
+import type { JsonSchema7NativeEnumType } from './parsers/native-enum';
+import type { JsonSchema7NeverType } from './parsers/never';
+import type { JsonSchema7NullType } from './parsers/null';
+import type { JsonSchema7NullableType } from './parsers/nullable';
+import type { JsonSchema7NumberType } from './parsers/number';
+import type { JsonSchema7ObjectType } from './parsers/object';
+import type { JsonSchema7RecordType } from './parsers/record';
+import type { JsonSchema7SetType } from './parsers/set';
+import type { JsonSchema7StringType } from './parsers/string';
+import type { JsonSchema7TupleType } from './parsers/tuple';
+import type { JsonSchema7UndefinedType } from './parsers/undefined';
+import type { JsonSchema7UnionType } from './parsers/union';
+import type { JsonSchema7UnknownType } from './parsers/unknown';
 
 type JsonSchema7RefType = { $ref: string };
 type JsonSchema7Meta = {

package/src/to-json-schema/zod3-to-json-schema/parsers/array.ts

@@ -1,7 +1,7 @@
-import { ZodArrayDef, ZodFirstPartyTypeKind } from 'zod/v3';
+import { ZodFirstPartyTypeKind, type ZodArrayDef } from 'zod/v3';
 import { parseDef } from '../parse-def';
-import { JsonSchema7Type } from '../parse-types';
-import { Refs } from '../refs';
+import type { JsonSchema7Type } from '../parse-types';
+import type { Refs } from '../refs';
 
 export type JsonSchema7ArrayType = {
   type: 'array';

package/src/to-json-schema/zod3-to-json-schema/parsers/bigint.ts

@@ -1,4 +1,4 @@
-import { ZodBigIntDef } from 'zod/v3';
+import type { ZodBigIntDef } from 'zod/v3';
 
 export type JsonSchema7BigintType = {
   type: 'integer';

package/src/to-json-schema/zod3-to-json-schema/parsers/branded.ts

@@ -1,6 +1,6 @@
-import { ZodBrandedDef } from 'zod/v3';
+import type { ZodBrandedDef } from 'zod/v3';
 import { parseDef } from '../parse-def';
-import { Refs } from '../refs';
+import type { Refs } from '../refs';
 
 export function parseBrandedDef(_def: ZodBrandedDef<any>, refs: Refs) {
   return parseDef(_def.type._def, refs);

package/src/to-json-schema/zod3-to-json-schema/parsers/catch.ts

@@ -1,6 +1,6 @@
-import { ZodCatchDef } from 'zod/v3';
+import type { ZodCatchDef } from 'zod/v3';
 import { parseDef } from '../parse-def';
-import { Refs } from '../refs';
+import type { Refs } from '../refs';
 
 export const parseCatchDef = (def: ZodCatchDef<any>, refs: Refs) => {
   return parseDef(def.innerType._def, refs);

package/src/to-json-schema/zod3-to-json-schema/parsers/date.ts

@@ -1,6 +1,6 @@
-import { ZodDateDef } from 'zod/v3';
-import { Refs } from '../refs';
-import { DateStrategy } from '../options';
+import type { ZodDateDef } from 'zod/v3';
+import type { Refs } from '../refs';
+import type { DateStrategy } from '../options';
 
 export type JsonSchema7DateType =
   | {
@@ -22,7 +22,7 @@ export function parseDateDef(
 
   if (Array.isArray(strategy)) {
     return {
-      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item)),
+      anyOf: strategy.map(item => parseDateDef(def, refs, item)),
     };
   }
 

package/src/to-json-schema/zod3-to-json-schema/parsers/default.ts

@@ -1,7 +1,7 @@
-import { ZodDefaultDef } from 'zod/v3';
+import type { ZodDefaultDef } from 'zod/v3';
 import { parseDef } from '../parse-def';
-import { JsonSchema7Type } from '../parse-types';
-import { Refs } from '../refs';
+import type { JsonSchema7Type } from '../parse-types';
+import type { Refs } from '../refs';
 
 export function parseDefaultDef(
   _def: ZodDefaultDef,

package/src/to-json-schema/zod3-to-json-schema/parsers/effects.ts

@@ -1,7 +1,7 @@
-import { ZodEffectsDef } from 'zod/v3';
+import type { ZodEffectsDef } from 'zod/v3';
 import { parseDef } from '../parse-def';
-import { JsonSchema7Type } from '../parse-types';
-import { Refs } from '../refs';
+import type { JsonSchema7Type } from '../parse-types';
+import type { Refs } from '../refs';
 import { parseAnyDef } from './any';
 
 export function parseEffectsDef(

package/src/to-json-schema/zod3-to-json-schema/parsers/enum.ts

@@ -1,4 +1,4 @@
-import { ZodEnumDef } from 'zod/v3';
+import type { ZodEnumDef } from 'zod/v3';
 
 export type JsonSchema7EnumType = {
   type: 'string';

package/src/to-json-schema/zod3-to-json-schema/parsers/intersection.ts

@@ -1,8 +1,8 @@
-import { ZodIntersectionDef } from 'zod/v3';
+import type { ZodIntersectionDef } from 'zod/v3';
 import { parseDef } from '../parse-def';
-import { JsonSchema7Type } from '../parse-types';
-import { Refs } from '../refs';
-import { JsonSchema7StringType } from './string';
+import type { JsonSchema7Type } from '../parse-types';
+import type { Refs } from '../refs';
+import type { JsonSchema7StringType } from './string';
 
 export type JsonSchema7AllOfType = {
   allOf: JsonSchema7Type[];
@@ -42,7 +42,7 @@ export function parseIntersectionDef(
         'additionalProperties' in schema &&
         schema.additionalProperties === false
       ) {
-        const { additionalProperties, ...rest } = schema;
+        const { additionalProperties: _additionalProperties, ...rest } = schema;
         nestedSchema = rest;
       }
       mergedAllOf.push(nestedSchema);