@ai-sdk/topaz 0.0.0 → 2.0.1

package/dist/index.js

@@ -0,0 +1,1348 @@
+// src/topaz-provider.ts
+import {
+  NoSuchModelError
+} from "@ai-sdk/provider";
+import {
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix as withUserAgentSuffix2
+} from "@ai-sdk/provider-utils";
+
+// src/topaz-image-model.ts
+import {
+  AISDKError,
+  InvalidArgumentError,
+  InvalidResponseDataError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  convertBase64ToUint8Array,
+  createBinaryResponseHandler,
+  createJsonResponseHandler,
+  delay,
+  mediaTypeToExtension,
+  parseProviderOptions,
+  postFormDataToApi,
+  removeUndefinedEntries,
+  resolve
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
+
+// src/topaz-error.ts
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var topazErrorDataSchema = z.object({
+  detail: z.union([
+    z.string(),
+    z.array(z.object({ msg: z.string().nullish() }).loose())
+  ]).nullish(),
+  message: z.string().nullish(),
+  error: z.string().nullish(),
+  errorCode: z.string().nullish(),
+  errors: z.array(z.object({ msg: z.string().nullish() }).loose()).nullish()
+});
+function topazErrorToMessage(data) {
+  var _a;
+  const message = baseErrorMessage(data);
+  const withCode = data.errorCode != null ? `${message} (${data.errorCode})` : message;
+  const issues = ((_a = data.errors) != null ? _a : []).map((issue) => issue.msg).filter((msg) => msg != null);
+  return issues.length > 0 ? `${withCode}: ${issues.join("; ")}` : withCode;
+}
+function baseErrorMessage(data) {
+  var _a, _b;
+  const { detail } = data;
+  if (typeof detail === "string") {
+    return detail;
+  }
+  if (Array.isArray(detail)) {
+    const messages = detail.map((issue) => issue.msg).filter((msg) => msg != null);
+    if (messages.length > 0) {
+      return messages.join("; ");
+    }
+  }
+  return (_b = (_a = data.message) != null ? _a : data.error) != null ? _b : "Unknown Topaz API error";
+}
+var topazFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: topazErrorDataSchema,
+  errorToMessage: topazErrorToMessage
+});
+
+// src/topaz-get-from-api.ts
+import {
+  fetchWithValidatedEndpoint,
+  fetchWithValidatedRedirects,
+  getFromApi,
+  isSameOrigin
+} from "@ai-sdk/provider-utils";
+async function topazGetFromApi({
+  validateUrl,
+  credentialedOrigin,
+  trustedOrigin,
+  ...options
+}) {
+  const validatedFetch = (url, init) => {
+    var _a;
+    return fetchWithValidatedRedirects({
+      url: url.toString(),
+      headers: init == null ? void 0 : init.headers,
+      abortSignal: (_a = init == null ? void 0 : init.signal) != null ? _a : void 0,
+      trustedOrigin,
+      fetch: (hopUrl, hopInit) => fetchWithValidatedEndpoint({
+        url: hopUrl.toString(),
+        init: {
+          ...hopInit,
+          headers: credentialedOrigin != null && isSameOrigin(hopUrl.toString(), credentialedOrigin) ? hopInit == null ? void 0 : hopInit.headers : void 0
+        },
+        trustedOrigin,
+        redirect: "manual",
+        fetch: options.fetch
+      })
+    });
+  };
+  const requestOptions = {
+    ...options,
+    validateUrl: false,
+    fetch: validateUrl ? validatedFetch : options.fetch
+  };
+  return getFromApi(requestOptions);
+}
+
+// src/topaz-image-model-options.ts
+import {
+  lazySchema,
+  zodSchema
+} from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod/v4";
+var topazImageModelOptionsSchema = lazySchema(
+  () => zodSchema(
+    z2.object({
+      /**
+       * How aggressively the model enhances the image. Defaults to `high`.
+       */
+      enhancementStrength: z2.enum(["low", "medium", "high"]).optional(),
+      /**
+       * Whether to add grain to the output. Defaults to `false`.
+       */
+      grain: z2.boolean().optional(),
+      /**
+       * Grain intensity, 0.0 to 1.0. Defaults to 0.5.
+       */
+      grainDensity: z2.number().min(0).max(1).optional(),
+      /**
+       * Grain model. Defaults to `silver`.
+       */
+      grainModel: z2.enum(["silver", "gaussian", "grey"]).optional(),
+      /**
+       * Grain particle size, 1 to 5. Defaults to 1.
+       */
+      grainSize: z2.number().min(1).max(5).optional(),
+      /**
+       * Grain effect strength, 0.0 to 1.0. Defaults to 0.5.
+       */
+      grainStrength: z2.number().min(0).max(1).optional(),
+      /**
+       * Width of the input image in pixels. Topaz infers this from the upload when
+       * omitted.
+       */
+      inputWidth: z2.number().int().positive().optional(),
+      /**
+       * Height of the input image in pixels. Topaz infers this from the upload
+       * when omitted.
+       */
+      inputHeight: z2.number().int().positive().optional(),
+      /**
+       * Width of the output image in pixels, 1 to 32000. Takes precedence over the
+       * width derived from the `size` call option.
+       */
+      outputWidth: z2.number().int().min(1).max(32e3).optional(),
+      /**
+       * Height of the output image in pixels, 1 to 32000. Takes precedence over
+       * the height derived from the `size` call option.
+       */
+      outputHeight: z2.number().int().min(1).max(32e3).optional(),
+      /**
+       * Output image format. Defaults to the Topaz API default.
+       */
+      outputFormat: z2.enum(["jpeg", "jpg", "png", "tiff", "tif"]).optional(),
+      /**
+       * Whether to crop the output to fill the requested dimensions. Defaults to
+       * `false`.
+       */
+      cropToFill: z2.boolean().optional(),
+      /**
+       * URL to receive job-status webhooks.
+       */
+      webhookUrl: z2.string().optional(),
+      /**
+       * How often to poll the Topaz status endpoint, in milliseconds. Defaults to
+       * 2000.
+       */
+      pollIntervalMillis: z2.number().int().positive().optional(),
+      /**
+       * How long to wait for the job to finish before failing, in milliseconds.
+       * Defaults to 600000 (10 minutes).
+       */
+      pollTimeoutMillis: z2.number().int().positive().optional()
+    })
+  )
+);
+
+// src/topaz-image-settings.ts
+var topazImageApiModelIds = {
+  "wonder-3.5": "Wonder 3.5"
+};
+function resolveTopazImageApiModelId(modelId) {
+  var _a;
+  return (_a = topazImageApiModelIds[modelId]) != null ? _a : modelId;
+}
+
+// src/topaz-image-model.ts
+var DEFAULT_POLL_INTERVAL_MILLIS = 2e3;
+var DEFAULT_POLL_TIMEOUT_MILLIS = 6e5;
+var TopazImageModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v3";
+    this.maxImagesPerCall = 1;
+    this.supportsFileInputs = true;
+    this.supportsMaskInputs = false;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f;
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const warnings = [];
+    const topazOptions = await parseProviderOptions({
+      provider: "topaz",
+      providerOptions: options.providerOptions,
+      schema: topazImageModelOptionsSchema
+    });
+    const headers = combineHeaders(
+      await resolve(this.config.headers),
+      options.headers
+    );
+    this.addUnsupportedWarnings(options, warnings);
+    const formData = await this.buildFormData(options, topazOptions, warnings);
+    const { value: submitResponse } = await postFormDataToApi({
+      url: `${this.config.baseURL}/image/v1/enhance-gen/async`,
+      headers,
+      formData,
+      successfulResponseHandler: createJsonResponseHandler(
+        topazImageSubmitResponseSchema
+      ),
+      failedResponseHandler: topazFailedResponseHandler,
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const processId = submitResponse.process_id;
+    if (processId == null) {
+      throw new InvalidResponseDataError({
+        data: submitResponse,
+        message: "Topaz did not return a process_id for the enhance request."
+      });
+    }
+    let status;
+    try {
+      status = await this.waitForCompletion({
+        processId,
+        headers,
+        abortSignal: options.abortSignal,
+        pollIntervalMillis: (_d = topazOptions == null ? void 0 : topazOptions.pollIntervalMillis) != null ? _d : DEFAULT_POLL_INTERVAL_MILLIS,
+        pollTimeoutMillis: (_e = topazOptions == null ? void 0 : topazOptions.pollTimeoutMillis) != null ? _e : DEFAULT_POLL_TIMEOUT_MILLIS
+      });
+    } catch (error) {
+      if ((_f = options.abortSignal) == null ? void 0 : _f.aborted) {
+        await this.cancelQuietly(processId, headers);
+      }
+      throw error;
+    }
+    const { image, responseHeaders } = await this.download({
+      processId,
+      headers,
+      abortSignal: options.abortSignal
+    });
+    return {
+      images: [image],
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders
+      },
+      providerMetadata: {
+        topaz: {
+          images: [
+            {
+              processId,
+              // Topaz bills exactly the credits reported on the completed job.
+              ...status.credits != null ? { credits: status.credits } : {},
+              ...status.output_width != null ? { width: status.output_width } : {},
+              ...status.output_height != null ? { height: status.output_height } : {},
+              ...status.output_format != null ? { format: status.output_format } : {}
+            }
+          ]
+        }
+      }
+    };
+  }
+  addUnsupportedWarnings(options, warnings) {
+    if (options.prompt != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "prompt",
+        details: "Topaz image models enhance an existing image and do not take a text prompt. The prompt was ignored."
+      });
+    }
+    if (options.aspectRatio != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "aspectRatio",
+        details: "Topaz image models do not support aspectRatio. Use `size`, or the `outputWidth` / `outputHeight` provider options, to set output dimensions."
+      });
+    }
+    if (options.seed != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "seed",
+        details: "Topaz image models do not support seed."
+      });
+    }
+    if (options.mask != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "mask",
+        details: "Topaz image models do not support masks. The mask was ignored."
+      });
+    }
+    if (options.n > 1) {
+      warnings.push({
+        type: "unsupported",
+        feature: "n",
+        details: "Topaz image models enhance one image per call. Only 1 image will be returned."
+      });
+    }
+  }
+  async buildFormData(options, topazOptions, warnings) {
+    var _a, _b, _c, _d;
+    const file = (_a = options.files) == null ? void 0 : _a[0];
+    if (file == null) {
+      throw new InvalidArgumentError({
+        argument: "files",
+        message: "Topaz image models enhance an existing image. Pass the input image via `prompt.images`."
+      });
+    }
+    if (options.files != null && options.files.length > 1) {
+      warnings.push({
+        type: "unsupported",
+        feature: "files",
+        details: "Topaz image models enhance one image per call. Only the first file was used."
+      });
+    }
+    const formData = new FormData();
+    formData.append("model", resolveTopazImageApiModelId(this.modelId));
+    if (file.type === "url") {
+      formData.append("source_url", file.url);
+    } else {
+      const bytes = typeof file.data === "string" ? convertBase64ToUint8Array(file.data) : file.data;
+      const extension = (_b = mediaTypeToExtension(file.mediaType)) != null ? _b : "png";
+      formData.append(
+        "image",
+        new File([bytes], `image.${extension}`, {
+          type: file.mediaType
+        })
+      );
+    }
+    const { width, height } = parseSize(options.size);
+    appendIfDefined(
+      formData,
+      "output_width",
+      (_c = topazOptions == null ? void 0 : topazOptions.outputWidth) != null ? _c : width
+    );
+    appendIfDefined(
+      formData,
+      "output_height",
+      (_d = topazOptions == null ? void 0 : topazOptions.outputHeight) != null ? _d : height
+    );
+    appendIfDefined(formData, "output_format", topazOptions == null ? void 0 : topazOptions.outputFormat);
+    appendIfDefined(formData, "crop_to_fill", topazOptions == null ? void 0 : topazOptions.cropToFill);
+    appendIfDefined(formData, "webhook_url", topazOptions == null ? void 0 : topazOptions.webhookUrl);
+    appendIfDefined(
+      formData,
+      "enhancementStrength",
+      topazOptions == null ? void 0 : topazOptions.enhancementStrength
+    );
+    appendIfDefined(formData, "grain", topazOptions == null ? void 0 : topazOptions.grain);
+    appendIfDefined(formData, "grainDensity", topazOptions == null ? void 0 : topazOptions.grainDensity);
+    appendIfDefined(formData, "grainModel", topazOptions == null ? void 0 : topazOptions.grainModel);
+    appendIfDefined(formData, "grainSize", topazOptions == null ? void 0 : topazOptions.grainSize);
+    appendIfDefined(formData, "grainStrength", topazOptions == null ? void 0 : topazOptions.grainStrength);
+    appendIfDefined(formData, "inputWidth", topazOptions == null ? void 0 : topazOptions.inputWidth);
+    appendIfDefined(formData, "inputHeight", topazOptions == null ? void 0 : topazOptions.inputHeight);
+    return formData;
+  }
+  async waitForCompletion({
+    processId,
+    headers,
+    abortSignal,
+    pollIntervalMillis,
+    pollTimeoutMillis
+  }) {
+    var _a;
+    const deadline = Date.now() + pollTimeoutMillis;
+    while (true) {
+      const { value: status } = await topazGetFromApi({
+        url: `${this.config.baseURL}/image/v1/status/${processId}`,
+        // Built from the configured baseURL, not from response data.
+        validateUrl: false,
+        headers,
+        successfulResponseHandler: createJsonResponseHandler(
+          topazImageStatusResponseSchema
+        ),
+        failedResponseHandler: topazFailedResponseHandler,
+        abortSignal,
+        fetch: this.config.fetch
+      });
+      if (status.status === "Completed") {
+        return status;
+      }
+      if (status.status === "Failed" || status.status === "Cancelled") {
+        throw new AISDKError({
+          name: "TOPAZ_IMAGE_ENHANCEMENT_FAILED",
+          message: `Topaz image enhancement ${status.status.toLowerCase()} for process ${processId}.`
+        });
+      }
+      if (Date.now() + pollIntervalMillis > deadline) {
+        await this.cancelQuietly(processId, headers != null ? headers : {});
+        throw new AISDKError({
+          name: "TOPAZ_IMAGE_ENHANCEMENT_TIMEOUT",
+          message: `Topaz image enhancement did not finish within ${pollTimeoutMillis}ms (process ${processId}, last status ${(_a = status.status) != null ? _a : "unknown"}). Increase the \`pollTimeoutMillis\` provider option if the job needs longer.`
+        });
+      }
+      await delay(pollIntervalMillis, { abortSignal });
+    }
+  }
+  async cancelQuietly(processId, headers) {
+    var _a;
+    const fetchImpl = (_a = this.config.fetch) != null ? _a : globalThis.fetch;
+    try {
+      await fetchImpl(`${this.config.baseURL}/image/v1/cancel/${processId}`, {
+        method: "DELETE",
+        headers: removeUndefinedEntries(headers)
+      });
+    } catch (e) {
+    }
+  }
+  async download({
+    processId,
+    headers,
+    abortSignal
+  }) {
+    const { value: downloadResponse } = await topazGetFromApi({
+      url: `${this.config.baseURL}/image/v1/download/${processId}`,
+      // Built from the configured baseURL, not from response data.
+      validateUrl: false,
+      headers,
+      successfulResponseHandler: createJsonResponseHandler(
+        topazImageDownloadResponseSchema
+      ),
+      failedResponseHandler: topazFailedResponseHandler,
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    const downloadUrl = downloadResponse.download_url;
+    if (downloadUrl == null) {
+      throw new InvalidResponseDataError({
+        data: downloadResponse,
+        message: `Topaz did not return a download URL for process ${processId}.`
+      });
+    }
+    const { value: image, responseHeaders } = await topazGetFromApi({
+      url: downloadUrl,
+      // Comes from the Topaz response body and normally points at object
+      // storage, so it is validated and the API key is withheld off-origin.
+      validateUrl: true,
+      credentialedOrigin: this.config.baseURL,
+      trustedOrigin: this.config.baseURL,
+      headers,
+      successfulResponseHandler: createBinaryResponseHandler(),
+      failedResponseHandler: topazFailedResponseHandler,
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    return { image, responseHeaders };
+  }
+};
+function parseSize(size) {
+  if (size == null) {
+    return { width: void 0, height: void 0 };
+  }
+  const [width, height] = size.split("x").map(Number);
+  return { width, height };
+}
+function appendIfDefined(formData, key, value) {
+  if (value !== void 0) {
+    formData.append(key, String(value));
+  }
+}
+var topazImageSubmitResponseSchema = z3.object({
+  process_id: z3.string().nullish()
+});
+var topazImageStatusResponseSchema = z3.object({
+  // Documented values are Pending, Processing, Completed, Cancelled and Failed.
+  // Unknown values keep polling rather than failing the parse.
+  status: z3.string().nullish(),
+  credits: z3.number().nullish(),
+  output_width: z3.number().nullish(),
+  output_height: z3.number().nullish(),
+  output_format: z3.string().nullish()
+});
+var topazImageDownloadResponseSchema = z3.object({
+  download_url: z3.string().nullish()
+});
+
+// src/topaz-video-model.ts
+import {
+  AISDKError as AISDKError2,
+  APICallError,
+  InvalidArgumentError as InvalidArgumentError2,
+  InvalidResponseDataError as InvalidResponseDataError2
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders2,
+  convertBase64ToUint8Array as convertBase64ToUint8Array2,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  delay as delay2,
+  isSameOrigin as isSameOrigin2,
+  parseProviderOptions as parseProviderOptions2,
+  postJsonToApi,
+  removeUndefinedEntries as removeUndefinedEntries2,
+  resolve as resolve2,
+  validateDownloadUrl,
+  withUserAgentSuffix
+} from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
+
+// src/topaz-video-model-options.ts
+import {
+  lazySchema as lazySchema2,
+  zodSchema as zodSchema2
+} from "@ai-sdk/provider-utils";
+import { z as z4 } from "zod/v4";
+var topazSourceContainers = [
+  "3gp",
+  "avi",
+  "dv",
+  "flv",
+  "m1v",
+  "m2t",
+  "m2ts",
+  "m2v",
+  "m4v",
+  "mkv",
+  "mov",
+  "mp4",
+  "mpeg",
+  "mpg",
+  "mts",
+  "mxf",
+  "ser",
+  "ts",
+  "vob",
+  "webm",
+  "wmv"
+];
+var topazOutputContainers = [
+  "mp4",
+  "mov",
+  "mkv",
+  "avi",
+  "webm"
+];
+var topazVideoSourceSchema = z4.object({
+  /**
+   * Width of the input video in pixels.
+   */
+  width: z4.number().int().positive().optional(),
+  /**
+   * Height of the input video in pixels.
+   */
+  height: z4.number().int().positive().optional(),
+  /**
+   * Duration of the input video in seconds.
+   */
+  duration: z4.number().positive().optional(),
+  /**
+   * Frame rate of the input video.
+   */
+  frameRate: z4.number().positive().optional(),
+  /**
+   * Total number of frames in the input video. Derived from
+   * `duration * frameRate` when omitted, which is only correct for
+   * constant-frame-rate input, so set it explicitly for variable-frame-rate
+   * sources.
+   */
+  frameCount: z4.number().int().positive().optional(),
+  /**
+   * Container of the input video. Detected from the input file's media type
+   * or URL extension when omitted.
+   */
+  container: z4.enum(topazSourceContainers).optional()
+});
+var topazVideoOutputSchema = z4.object({
+  /**
+   * Width of the output video in pixels. Takes precedence over the
+   * `resolution` call option.
+   */
+  width: z4.number().int().positive().optional(),
+  /**
+   * Height of the output video in pixels. Takes precedence over the
+   * `resolution` call option.
+   */
+  height: z4.number().int().positive().optional(),
+  /**
+   * Frame rate of the output video. Takes precedence over the `fps` call
+   * option. Topaz only changes the frame rate when a frame-interpolation
+   * filter is present.
+   */
+  frameRate: z4.number().positive().optional(),
+  /**
+   * Audio codec of the output video. Defaults to `AAC`.
+   */
+  audioCodec: z4.enum(["AAC", "AC3", "PCM"]).optional(),
+  /**
+   * Audio bitrate, e.g. `192k`. Topaz uses the codec default when omitted.
+   */
+  audioBitrate: z4.string().optional(),
+  /**
+   * How to handle the input audio track. Defaults to `Copy`.
+   */
+  audioTransfer: z4.enum(["Copy", "Convert", "None"]).optional(),
+  /**
+   * Video encoder. Topaz defaults to `H265`. `ProRes` forces a `mov`
+   * container, `AV1` and `VP9` force `mp4`.
+   */
+  videoEncoder: z4.enum(["AV1", "H264", "H265", "ProRes", "VP9"]).optional(),
+  /**
+   * Encoder profile, e.g. `Main10` for H265 or `422 HQ` for ProRes. Topaz uses
+   * the encoder's default profile when omitted.
+   */
+  videoProfile: z4.string().optional(),
+  /**
+   * Constant bitrate, e.g. `20m`. Required for `VP9`. Mutually exclusive with
+   * `dynamicCompressionLevel`.
+   */
+  videoBitrate: z4.string().optional(),
+  /**
+   * Automatic constant-quality compression level. Topaz defaults to `High`
+   * unless `videoBitrate` is set.
+   */
+  dynamicCompressionLevel: z4.enum(["Low", "Mid", "High"]).optional(),
+  /**
+   * Center-crop to fit the output dimensions.
+   */
+  cropToFit: z4.boolean().optional(),
+  /**
+   * Container of the output video. Defaults to the input container when Topaz
+   * can produce it, otherwise `mp4`.
+   */
+  container: z4.enum(topazOutputContainers).optional()
+});
+var topazVideoModelOptionsSchema = lazySchema2(
+  () => zodSchema2(
+    z4.object({
+      /** Interval between status polls, in milliseconds. Defaults to 2000. */
+      pollIntervalMillis: z4.number().positive().optional(),
+      /** Maximum time to poll, in milliseconds. Defaults to 3600000 (1 hour). */
+      pollTimeoutMillis: z4.number().positive().optional(),
+      source: topazVideoSourceSchema.optional(),
+      output: topazVideoOutputSchema.optional(),
+      /**
+       * Extra `filters[]` entries to send alongside the model's own filter, e.g. a
+       * frame-interpolation filter. Each entry must include a `model` key.
+       */
+      additionalFilters: z4.array(z4.record(z4.string(), z4.unknown())).optional(),
+      /**
+       * Escape hatch for filter settings this package does not model yet. Merged
+       * into the model's filter entry, taking precedence over the typed options
+       * below.
+       */
+      filter: z4.record(z4.string(), z4.unknown()).optional(),
+      // ---------------------------------------------------------------------------
+      // Proteus (`proteus`)
+      // ---------------------------------------------------------------------------
+      /** Proteus: how the input frames are encoded. */
+      videoType: z4.enum(["Progressive", "Interlaced", "ProgressiveInterlaced"]).optional(),
+      /** Proteus: parameter estimation mode. */
+      auto: z4.enum(["Auto", "Manual", "Relative"]).optional(),
+      /** Proteus: field order for interlaced input. */
+      fieldOrder: z4.enum(["TopFirst", "BottomFirst", "Auto"]).optional(),
+      /** Proteus: focus-fix strength. */
+      focusFixLevel: z4.enum(["None", "Normal", "Strong"]).optional(),
+      /** Proteus: compression artifact removal, -1 to 1. */
+      compression: z4.number().min(-1).max(1).optional(),
+      /** Proteus: detail recovery, -1 to 1. */
+      details: z4.number().min(-1).max(1).optional(),
+      /** Proteus: pre-processing noise reduction, 0 to 0.1. */
+      prenoise: z4.number().min(0).max(0.1).optional(),
+      /** Proteus: noise reduction, -1 to 1. */
+      noise: z4.number().min(-1).max(1).optional(),
+      /** Proteus: halo suppression, -1 to 1. */
+      halo: z4.number().min(-1).max(1).optional(),
+      /** Proteus: pre-processing blur, -1 to 1. */
+      preblur: z4.number().min(-1).max(1).optional(),
+      /** Proteus: sharpening, -1 to 1. */
+      blur: z4.number().min(-1).max(1).optional(),
+      /** Proteus: grain amount, 0 to 0.1. */
+      grain: z4.number().min(0).max(0.1).optional(),
+      /** Proteus: grain sigma, 0 to 1. */
+      grainSigma: z4.number().min(0).max(1).optional(),
+      /** Proteus: grain size, 0 to 5. */
+      grainSize: z4.number().min(0).max(5).optional(),
+      /** Proteus: grain model. */
+      grainType: z4.enum(["silver_rich", "gaussian", "grey"]).optional(),
+      /** Proteus: original detail recovery, 0 to 1. */
+      recoverOriginalDetailValue: z4.number().min(0).max(1).optional(),
+      // ---------------------------------------------------------------------------
+      // Starlight Precise (`starlight-precise-2.6`)
+      // ---------------------------------------------------------------------------
+      /** Starlight: sharpening applied to the output, 1.0 to 5.0. Defaults to 5.0. */
+      sharpness: z4.number().min(1).max(5).optional(),
+      /** Starlight: output bit depth. */
+      videoBitDepth: z4.number().int().positive().optional(),
+      /** Starlight: output video codec. */
+      videoCodec: z4.enum(["ffv1", "prores", "vp9"]).optional(),
+      /** Starlight: output chroma subsampling profile. */
+      videoProfile: z4.enum(["420", "422", "444"]).optional(),
+      /** Starlight: whether to watermark the output. Defaults to `false`. */
+      watermark: z4.boolean().optional()
+    })
+  )
+);
+var TOPAZ_NON_FILTER_OPTION_KEYS = [
+  "pollIntervalMillis",
+  "pollTimeoutMillis",
+  "source",
+  "output",
+  "additionalFilters",
+  "filter"
+];
+
+// src/topaz-video-settings.ts
+var topazVideoApiModelIds = {
+  proteus: "prob-4",
+  "starlight-precise-2.6": "slp-2.6"
+};
+function resolveTopazVideoApiModelId(modelId) {
+  var _a;
+  return (_a = topazVideoApiModelIds[modelId]) != null ? _a : modelId;
+}
+
+// src/version.ts
+var VERSION = true ? "2.0.1" : "0.0.0-test";
+
+// src/topaz-video-model.ts
+var DEFAULT_POLL_INTERVAL_MILLIS2 = 2e3;
+var DEFAULT_POLL_TIMEOUT_MILLIS2 = 36e5;
+var mediaTypeContainers = {
+  "video/mp4": "mp4",
+  "video/quicktime": "mov",
+  "video/mov": "mov",
+  "video/x-matroska": "mkv",
+  "video/matroska": "mkv",
+  "video/webm": "webm",
+  "video/x-msvideo": "avi",
+  "video/avi": "avi",
+  "video/mpeg": "mpeg",
+  "video/mp2t": "ts",
+  "video/x-ms-wmv": "wmv",
+  "video/x-flv": "flv",
+  "video/3gpp": "3gp",
+  "video/x-m4v": "m4v",
+  "application/mxf": "mxf"
+};
+var extensionContainers = {
+  ...Object.fromEntries(topazSourceContainers.map((c) => [c, c])),
+  qt: "mov"
+};
+var containerMediaTypes = {
+  mp4: "video/mp4",
+  m4v: "video/mp4",
+  mov: "video/quicktime",
+  mkv: "video/x-matroska",
+  webm: "video/webm",
+  avi: "video/x-msvideo",
+  mpeg: "video/mpeg",
+  mpg: "video/mpeg",
+  ts: "video/mp2t",
+  wmv: "video/x-ms-wmv",
+  flv: "video/x-flv",
+  "3gp": "video/3gpp",
+  mxf: "application/mxf"
+};
+var TopazVideoModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v3";
+    this.maxVideosPerCall = 1;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate(options) {
+    var _a, _b, _c;
+    const topazOptions = await parseProviderOptions2({
+      provider: "topaz",
+      providerOptions: options.providerOptions,
+      schema: topazVideoModelOptionsSchema
+    });
+    const started = await this.start(options);
+    const pollIntervalMillis = (_a = topazOptions == null ? void 0 : topazOptions.pollIntervalMillis) != null ? _a : DEFAULT_POLL_INTERVAL_MILLIS2;
+    const pollTimeoutMillis = (_b = topazOptions == null ? void 0 : topazOptions.pollTimeoutMillis) != null ? _b : DEFAULT_POLL_TIMEOUT_MILLIS2;
+    const deadline = Date.now() + pollTimeoutMillis;
+    try {
+      while (true) {
+        const result = await this.getStatus({
+          operation: started.operation,
+          headers: options.headers,
+          abortSignal: options.abortSignal
+        });
+        if (result != null) {
+          return {
+            ...result,
+            warnings: [...started.warnings, ...result.warnings],
+            response: {
+              ...result.response,
+              timestamp: started.response.timestamp
+            }
+          };
+        }
+        if (Date.now() + pollIntervalMillis > deadline) {
+          const headers = combineHeaders2(
+            await resolve2(this.config.headers),
+            options.headers
+          );
+          await this.cancelQuietly(started.operation.requestId, headers);
+          throw new AISDKError2({
+            name: "TOPAZ_VIDEO_ENHANCEMENT_TIMEOUT",
+            message: `Topaz video enhancement did not finish within ${pollTimeoutMillis}ms (request ${started.operation.requestId}). Increase the \`pollTimeoutMillis\` provider option if the job needs longer.`
+          });
+        }
+        await delay2(pollIntervalMillis, { abortSignal: options.abortSignal });
+      }
+    } catch (error) {
+      if ((_c = options.abortSignal) == null ? void 0 : _c.aborted) {
+        const headers = combineHeaders2(
+          await resolve2(this.config.headers),
+          options.headers
+        );
+        await this.cancelQuietly(started.operation.requestId, headers);
+      }
+      throw error;
+    }
+  }
+  async start(options) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const warnings = [];
+    const topazOptions = await parseProviderOptions2({
+      provider: "topaz",
+      providerOptions: options.providerOptions,
+      schema: topazVideoModelOptionsSchema
+    });
+    const headers = combineHeaders2(
+      await resolve2(this.config.headers),
+      options.headers
+    );
+    this.addUnsupportedWarnings(options, warnings);
+    const input = this.selectInputVideo(options, warnings);
+    const container = resolveContainer(input, (_d = topazOptions == null ? void 0 : topazOptions.source) == null ? void 0 : _d.container);
+    const source = resolveSource(topazOptions, container);
+    const output = buildOutput({ options, topazOptions, source });
+    const filters = [
+      buildFilter(this.modelId, topazOptions),
+      ...(_e = topazOptions == null ? void 0 : topazOptions.additionalFilters) != null ? _e : []
+    ];
+    const contentType = (_f = containerMediaTypes[source.container]) != null ? _f : "application/octet-stream";
+    const metadata = source.metadata;
+    const bytes = input.type === "file" ? fileBytes(input) : void 0;
+    let requestId;
+    try {
+      const { value: created, responseHeaders } = await postJsonToApi({
+        url: `${this.config.baseURL}/video/express`,
+        headers,
+        body: {
+          source: {
+            container: source.container,
+            ...metadata != null ? {
+              duration: metadata.duration,
+              frameCount: metadata.frameCount,
+              frameRate: metadata.frameRate,
+              resolution: {
+                width: metadata.width,
+                height: metadata.height
+              }
+            } : {},
+            ...input.type === "url" ? (
+              // Topaz fetches URL inputs itself, so, like other providers,
+              // the SDK never downloads them.
+              { external: { provider: "s3", presignedUrl: input.url } }
+            ) : { size: bytes == null ? void 0 : bytes.byteLength }
+          },
+          output,
+          filters
+        },
+        successfulResponseHandler: createJsonResponseHandler2(
+          topazVideoExpressResponseSchema
+        ),
+        failedResponseHandler: topazFailedResponseHandler,
+        abortSignal: options.abortSignal,
+        fetch: this.config.fetch
+      });
+      requestId = requireRequestId(created.requestId);
+      if (bytes != null) {
+        await this.uploadVideo({
+          requestId,
+          bytes,
+          urls: created.uploadUrls,
+          contentType,
+          abortSignal: options.abortSignal
+        });
+      }
+      return {
+        // The output container travels with the operation so the polling code can
+        // report the right media type without re-deriving it.
+        operation: { requestId, outputContainer: output.container },
+        warnings,
+        providerMetadata: {
+          topaz: {
+            requestId,
+            // Preliminary: Topaz estimates up front only when it gets source
+            // metadata, and the completed status carries the billed value.
+            ...((_g = created.estimates) == null ? void 0 : _g.cost) != null ? { estimatedCredits: created.estimates.cost } : {}
+          }
+        },
+        response: {
+          timestamp: currentDate,
+          modelId: this.modelId,
+          headers: responseHeaders
+        }
+      };
+    } catch (error) {
+      if (requestId != null) {
+        await this.cancelQuietly(requestId, headers);
+      }
+      throw error;
+    }
+  }
+  async getStatus(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const { requestId, outputContainer } = options.operation;
+    const { value: status, responseHeaders } = await topazGetFromApi({
+      url: `${this.config.baseURL}/video/${requestId}/status`,
+      // Built from the configured baseURL, not from response data.
+      validateUrl: false,
+      headers: combineHeaders2(
+        await resolve2(this.config.headers),
+        options.headers
+      ),
+      successfulResponseHandler: createJsonResponseHandler2(
+        topazVideoStatusResponseSchema
+      ),
+      failedResponseHandler: topazFailedResponseHandler,
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const response = {
+      timestamp: currentDate,
+      modelId: this.modelId,
+      headers: responseHeaders
+    };
+    if (status.status === "complete") {
+      const credits = lowerBoundCredits((_d = status.estimates) == null ? void 0 : _d.cost);
+      const url = (_e = status.download) == null ? void 0 : _e.url;
+      if (url == null) {
+        throw new InvalidResponseDataError2({
+          data: status,
+          message: `Topaz reported request ${requestId} complete but returned no download URL.`
+        });
+      }
+      return {
+        videos: [
+          {
+            type: "url",
+            url,
+            mediaType: (_f = outputContainer != null ? containerMediaTypes[outputContainer] : void 0) != null ? _f : "video/mp4"
+          }
+        ],
+        warnings: [],
+        response,
+        providerMetadata: {
+          topaz: {
+            requestId,
+            ...credits != null ? { credits } : {},
+            ...((_g = status.estimates) == null ? void 0 : _g.cost) != null ? { estimatedCredits: status.estimates.cost } : {},
+            ...status.outputSize != null ? { outputSize: status.outputSize } : {},
+            ...((_h = status.download) == null ? void 0 : _h.expiresAt) != null ? { expiresAt: status.download.expiresAt } : {}
+          }
+        }
+      };
+    }
+    if (status.status === "failed" || status.status === "canceled") {
+      throw new AISDKError2({
+        name: "TOPAZ_VIDEO_ENHANCEMENT_FAILED",
+        message: `Topaz video request ${requestId} ${status.status}` + (status.errorCode != null ? ` (${status.errorCode})` : "") + (status.message != null ? `: ${status.message}` : ".")
+      });
+    }
+    return void 0;
+  }
+  addUnsupportedWarnings(options, warnings) {
+    if (options.prompt != null && options.prompt.trim() !== "") {
+      warnings.push({
+        type: "unsupported",
+        feature: "prompt",
+        details: "Topaz video models enhance an existing video and do not take a text prompt. The prompt was ignored."
+      });
+    }
+    if (options.aspectRatio != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "aspectRatio",
+        details: "Topaz video models do not support aspectRatio. Use `resolution`, or the `output` provider option, to set the output dimensions."
+      });
+    }
+    if (options.seed != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "seed",
+        details: "Topaz video models do not support seed."
+      });
+    }
+    if (options.duration != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "duration",
+        details: "Topaz video models enhance the whole input video, so duration was ignored. Pass the input duration via the `source.duration` provider option instead."
+      });
+    }
+    if (options.generateAudio != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "generateAudio",
+        details: "Topaz video models do not generate audio. Use the `output.audioTransfer` provider option to control how the input audio track is carried over."
+      });
+    }
+    if (options.frameImages != null && options.frameImages.length > 0) {
+      warnings.push({
+        type: "unsupported",
+        feature: "frameImages",
+        details: "Topaz video models do not support first/last frame generation. The frame images were ignored."
+      });
+    }
+    if (options.n > 1) {
+      warnings.push({
+        type: "unsupported",
+        feature: "n",
+        details: "Topaz video models enhance one video per call. Only 1 video will be produced."
+      });
+    }
+  }
+  selectInputVideo(options, warnings) {
+    var _a;
+    const references = (_a = options.inputReferences) != null ? _a : [];
+    const videos = references.filter(isVideoReference);
+    if (videos.length === 0) {
+      if (options.image != null) {
+        throw new InvalidArgumentError2({
+          argument: "image",
+          message: "Topaz video models enhance an existing video, not a still image. Pass the input video via `inputReferences`."
+        });
+      }
+      throw new InvalidArgumentError2({
+        argument: "inputReferences",
+        message: 'Topaz video models require an input video. Pass it via `inputReferences`, e.g. `inputReferences: [{ type: "file", mediaType: "video/mp4", data: bytes }]`. For URL references, include `mediaType` so the reference is recognized as a video.'
+      });
+    }
+    if (references.length > 1) {
+      warnings.push({
+        type: "unsupported",
+        feature: "inputReferences",
+        details: "Topaz video models enhance a single video. Only the first video reference was used."
+      });
+    }
+    return videos[0];
+  }
+  async uploadVideo({
+    requestId,
+    bytes,
+    urls,
+    contentType,
+    abortSignal
+  }) {
+    var _a;
+    const url = urls == null ? void 0 : urls[0];
+    if (url == null) {
+      throw new InvalidResponseDataError2({
+        data: urls,
+        message: `Topaz returned no upload URL for request ${requestId}.`
+      });
+    }
+    if (!isSameOrigin2(url, this.config.baseURL)) {
+      validateDownloadUrl(url);
+    }
+    const fetchImpl = (_a = this.config.fetch) != null ? _a : globalThis.fetch;
+    const response = await fetchImpl(url, {
+      method: "PUT",
+      headers: withUserAgentSuffix(
+        { "Content-Type": contentType },
+        `ai-sdk-topaz/${VERSION}`
+      ),
+      body: bytes,
+      signal: abortSignal
+    });
+    if (!response.ok) {
+      throw new APICallError({
+        message: `Uploading the input video failed with status ${response.status}.`,
+        url,
+        requestBodyValues: {},
+        statusCode: response.status,
+        responseHeaders: Object.fromEntries(response.headers.entries()),
+        responseBody: await response.text()
+      });
+    }
+  }
+  async cancelQuietly(requestId, headers) {
+    var _a;
+    const fetchImpl = (_a = this.config.fetch) != null ? _a : globalThis.fetch;
+    try {
+      await fetchImpl(`${this.config.baseURL}/video/${requestId}`, {
+        method: "DELETE",
+        headers: removeUndefinedEntries2(headers)
+      });
+    } catch (e) {
+    }
+  }
+};
+function lowerBoundCredits(cost) {
+  return cost != null && cost.length > 0 ? Math.min(...cost) : void 0;
+}
+function fileBytes(input) {
+  return typeof input.data === "string" ? convertBase64ToUint8Array2(input.data) : input.data;
+}
+function resolveContainer(input, declaredContainer) {
+  var _a;
+  if (declaredContainer != null) {
+    return declaredContainer;
+  }
+  if (input.type === "file") {
+    const container2 = mediaTypeContainers[input.mediaType.toLowerCase()];
+    if (container2 == null) {
+      throw new InvalidArgumentError2({
+        argument: "inputReferences",
+        message: `Could not map the media type "${input.mediaType}" onto a Topaz container. Set the \`source.container\` provider option explicitly.`
+      });
+    }
+    return container2;
+  }
+  const container = (_a = input.mediaType != null ? mediaTypeContainers[input.mediaType.toLowerCase()] : void 0) != null ? _a : containerFromUrl(input.url);
+  if (container == null) {
+    throw new InvalidArgumentError2({
+      argument: "inputReferences",
+      message: `Could not determine the container of the input video at "${input.url}". Set the \`source.container\` provider option, or pass \`mediaType\` on the reference.`
+    });
+  }
+  return container;
+}
+function isVideoReference(reference) {
+  if (reference.type === "file") {
+    return reference.mediaType.toLowerCase().startsWith("video/");
+  }
+  if (reference.mediaType != null) {
+    return reference.mediaType.toLowerCase().startsWith("video/");
+  }
+  return containerFromUrl(reference.url) != null;
+}
+function containerFromUrl(url) {
+  var _a;
+  const withoutQuery = url.split(/[?#]/)[0];
+  const extension = (_a = withoutQuery.split(".").pop()) == null ? void 0 : _a.toLowerCase();
+  return extension != null ? extensionContainers[extension] : void 0;
+}
+function resolveSource(topazOptions, container) {
+  var _a;
+  const source = topazOptions == null ? void 0 : topazOptions.source;
+  const { width, height, duration, frameRate } = source != null ? source : {};
+  if (width == null && height == null && duration == null && frameRate == null && (source == null ? void 0 : source.frameCount) == null) {
+    return { container, metadata: void 0 };
+  }
+  const frameCount = (_a = source == null ? void 0 : source.frameCount) != null ? _a : duration != null && frameRate != null ? Math.round(duration * frameRate) : void 0;
+  const missing = [
+    width == null ? "source.width" : void 0,
+    height == null ? "source.height" : void 0,
+    duration == null ? "source.duration" : void 0,
+    frameRate == null ? "source.frameRate" : void 0
+  ].filter((field) => field != null);
+  if (width == null || height == null || duration == null || frameRate == null || frameCount == null) {
+    throw new InvalidArgumentError2({
+      argument: "providerOptions.topaz.source",
+      message: `Source metadata must be complete. Missing: ${missing.join(", ")}.`
+    });
+  }
+  return {
+    container,
+    metadata: { duration, frameRate, frameCount, width, height }
+  };
+}
+function parseResolution(resolution) {
+  if (resolution == null) {
+    return { width: void 0, height: void 0 };
+  }
+  const [width, height] = resolution.split("x").map(Number);
+  return { width, height };
+}
+function buildOutput({
+  options,
+  topazOptions,
+  source
+}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const output = topazOptions == null ? void 0 : topazOptions.output;
+  const resolution = parseResolution(options.resolution);
+  const width = (_c = (_a = output == null ? void 0 : output.width) != null ? _a : resolution.width) != null ? _c : (_b = source.metadata) == null ? void 0 : _b.width;
+  const height = (_f = (_d = output == null ? void 0 : output.height) != null ? _d : resolution.height) != null ? _f : (_e = source.metadata) == null ? void 0 : _e.height;
+  if (width == null || height == null) {
+    throw new InvalidArgumentError2({
+      argument: "resolution",
+      message: "Topaz needs the output resolution. Set the `resolution` call option or the `output.width` / `output.height` provider options."
+    });
+  }
+  const frameRate = (_i = (_g = output == null ? void 0 : output.frameRate) != null ? _g : options.fps) != null ? _i : (_h = source.metadata) == null ? void 0 : _h.frameRate;
+  const audioTransfer = (_j = output == null ? void 0 : output.audioTransfer) != null ? _j : "Copy";
+  return {
+    resolution: { width, height },
+    ...frameRate != null ? { frameRate } : {},
+    audioTransfer,
+    ...audioTransfer !== "None" ? { audioCodec: (_k = output == null ? void 0 : output.audioCodec) != null ? _k : "AAC" } : (output == null ? void 0 : output.audioCodec) != null ? { audioCodec: output.audioCodec } : {},
+    ...(output == null ? void 0 : output.audioBitrate) != null ? { audioBitrate: output.audioBitrate } : {},
+    ...(output == null ? void 0 : output.videoEncoder) != null ? { videoEncoder: output.videoEncoder } : {},
+    ...(output == null ? void 0 : output.videoProfile) != null ? { videoProfile: output.videoProfile } : {},
+    ...(output == null ? void 0 : output.videoBitrate) != null ? { videoBitrate: output.videoBitrate } : {},
+    ...(output == null ? void 0 : output.dynamicCompressionLevel) != null ? { dynamicCompressionLevel: output.dynamicCompressionLevel } : {},
+    ...(output == null ? void 0 : output.cropToFit) != null ? { cropToFit: output.cropToFit } : {},
+    container: resolveOutputContainer(output, source.container)
+  };
+}
+function resolveOutputContainer(output, sourceContainer) {
+  switch (output == null ? void 0 : output.videoEncoder) {
+    case "ProRes":
+      return "mov";
+    case "AV1":
+    case "VP9":
+      return "mp4";
+  }
+  if ((output == null ? void 0 : output.container) != null) {
+    return output.container;
+  }
+  return sourceContainer === "mov" || sourceContainer === "mkv" ? sourceContainer : "mp4";
+}
+function requireRequestId(requestId) {
+  if (requestId == null) {
+    throw new InvalidResponseDataError2({
+      data: requestId,
+      message: "Topaz did not return a requestId for the video request."
+    });
+  }
+  return requestId;
+}
+function buildFilter(modelId, topazOptions) {
+  var _a;
+  const filter = {
+    model: resolveTopazVideoApiModelId(modelId)
+  };
+  if (topazOptions != null) {
+    const nonFilterKeys = new Set(TOPAZ_NON_FILTER_OPTION_KEYS);
+    for (const [key, value] of Object.entries(topazOptions)) {
+      if (!nonFilterKeys.has(key) && value !== void 0) {
+        filter[key] = value;
+      }
+    }
+    Object.assign(filter, (_a = topazOptions.filter) != null ? _a : {});
+  }
+  return filter;
+}
+var topazVideoEstimatesSchema = z5.object({
+  cost: z5.array(z5.number()).nullish(),
+  time: z5.array(z5.number()).nullish()
+}).nullish();
+var topazVideoExpressResponseSchema = z5.object({
+  requestId: z5.string().nullish(),
+  uploadUrls: z5.array(z5.string()).nullish(),
+  estimates: topazVideoEstimatesSchema
+});
+var topazVideoStatusResponseSchema = z5.object({
+  status: z5.string().nullish(),
+  message: z5.string().nullish(),
+  errorCode: z5.string().nullish(),
+  // Documented as a string, accepted as a number too.
+  outputSize: z5.union([z5.string(), z5.number()]).nullish(),
+  estimates: topazVideoEstimatesSchema,
+  download: z5.object({
+    url: z5.string().nullish(),
+    expiresAt: z5.union([z5.string(), z5.number()]).nullish()
+  }).nullish()
+});
+
+// src/topaz-provider.ts
+var defaultBaseURL = "https://api.topazlabs.com";
+function createTopaz(options = {}) {
+  var _a, _b;
+  const baseURL = (_b = withoutTrailingSlash((_a = options.baseURL) != null ? _a : defaultBaseURL)) != null ? _b : defaultBaseURL;
+  const getHeaders = () => withUserAgentSuffix2(
+    {
+      "X-API-Key": loadApiKey({
+        apiKey: options.apiKey,
+        environmentVariableName: "TOPAZ_API_KEY",
+        description: "Topaz Labs"
+      }),
+      accept: "application/json",
+      ...options.headers
+    },
+    `ai-sdk-topaz/${VERSION}`
+  );
+  const createImageModel = (modelId) => new TopazImageModel(modelId, {
+    provider: "topaz.image",
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const createVideoModel = (modelId) => new TopazVideoModel(modelId, {
+    provider: "topaz.video",
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const noSuchModel = (modelId, modelType) => {
+    throw new NoSuchModelError({ modelId, modelType });
+  };
+  const provider = {
+    specificationVersion: "v3",
+    image: createImageModel,
+    imageModel: createImageModel,
+    video: createVideoModel,
+    videoModel: createVideoModel,
+    languageModel: (modelId) => noSuchModel(modelId, "languageModel"),
+    embeddingModel: (modelId) => noSuchModel(modelId, "embeddingModel")
+  };
+  return provider;
+}
+var topaz = createTopaz();
+export {
+  VERSION,
+  createTopaz,
+  topaz
+};
+//# sourceMappingURL=index.js.map