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

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

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

@@ -1,4 +1,4 @@
-import { ZodLiteralDef } from 'zod/v3';
+import type { ZodLiteralDef } from 'zod/v3';
 
 export type JsonSchema7LiteralType =
   | {

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

@@ -1,10 +1,9 @@
-import { ZodMapDef } from 'zod/v3';
+import type { ZodMapDef } 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';
-import { JsonSchema7RecordType, parseRecordDef } from './record';
-
+import { parseRecordDef, type JsonSchema7RecordType } from './record';
 export type JsonSchema7MapType = {
   type: 'array';
   maxItems: 125;

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

@@ -1,4 +1,4 @@
-import { ZodNativeEnumDef } from 'zod/v3';
+import type { ZodNativeEnumDef } from 'zod/v3';
 
 export type JsonSchema7NativeEnumType = {
   type: 'string' | 'number' | ['string', 'number'];

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

@@ -1,5 +1,4 @@
-import { JsonSchema7AnyType, parseAnyDef } from './any';
-
+import { parseAnyDef, type JsonSchema7AnyType } from './any';
 export type JsonSchema7NeverType = {
   not: JsonSchema7AnyType;
 };

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

@@ -1,8 +1,8 @@
-import { ZodNullableDef } from 'zod/v3';
+import type { ZodNullableDef } from 'zod/v3';
 import { parseDef } from '../parse-def';
-import { JsonSchema7Type } from '../parse-types';
-import { Refs } from '../refs';
-import { JsonSchema7NullType } from './null';
+import type { JsonSchema7Type } from '../parse-types';
+import type { Refs } from '../refs';
+import type { JsonSchema7NullType } from './null';
 import { primitiveMappings } from './union';
 
 export type JsonSchema7NullableType =

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

@@ -1,4 +1,4 @@
-import { ZodNumberDef } from 'zod/v3';
+import type { ZodNumberDef } from 'zod/v3';
 
 export type JsonSchema7NumberType = {
   type: 'number' | 'integer';

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

@@ -1,7 +1,7 @@
-import { ZodObjectDef, ZodTypeAny } from 'zod/v3';
+import type { ZodObjectDef, ZodTypeAny } 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 JsonSchema7ObjectType = {
   type: 'object';

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

@@ -1,7 +1,7 @@
-import { ZodOptionalDef } from 'zod/v3';
+import type { ZodOptionalDef } 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 const parseOptionalDef = (

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

@@ -1,8 +1,8 @@
-import { ZodPipelineDef } from 'zod/v3';
+import type { ZodPipelineDef } from 'zod/v3';
 import { parseDef } from '../parse-def';
-import { JsonSchema7Type } from '../parse-types';
-import { Refs } from '../refs';
-import { JsonSchema7AllOfType } from './intersection';
+import type { JsonSchema7Type } from '../parse-types';
+import type { Refs } from '../refs';
+import type { JsonSchema7AllOfType } from './intersection';
 
 export const parsePipelineDef = (
   def: ZodPipelineDef<any, any>,

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

@@ -1,7 +1,7 @@
-import { ZodPromiseDef } from 'zod/v3';
+import type { ZodPromiseDef } 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 parsePromiseDef(
   def: ZodPromiseDef,

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

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