@ai-sdk/topaz 0.0.0 → 3.0.0

package/dist/index.js

@@ -0,0 +1,1154 @@
+import { AISDKError, APICallError, InvalidArgumentError, InvalidResponseDataError, NoSuchModelError } from "@ai-sdk/provider";
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, convertBase64ToUint8Array, createBinaryResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, delay, getFromApi, isSameOrigin, lazySchema, loadApiKey, mediaTypeToExtension, parseProviderOptions, postFormDataToApi, postJsonToApi, removeUndefinedEntries, resolve, serializeModelOptions, validateDownloadUrl, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+//#region src/topaz-error.ts
+/**
+* The image API reports errors as `{ "message": ... }` and the video API as
+* `{ "message": ..., "errorCode": ... }`. `detail` (a message or FastAPI's
+* array of validation issues) and `error` are accepted as well because a few
+* endpoints use them instead.
+*/
+const 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) {
+	const message = baseErrorMessage(data);
+	const withCode = data.errorCode != null ? `${message} (${data.errorCode})` : message;
+	const issues = (data.errors ?? []).map((issue) => issue.msg).filter((msg) => msg != null);
+	return issues.length > 0 ? `${withCode}: ${issues.join("; ")}` : withCode;
+}
+function baseErrorMessage(data) {
+	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 data.message ?? data.error ?? "Unknown Topaz API error";
+}
+const topazFailedResponseHandler = createJsonErrorResponseHandler({
+	errorSchema: topazErrorDataSchema,
+	errorToMessage: topazErrorToMessage
+});
+//#endregion
+//#region src/topaz-image-model-options.ts
+/**
+* Provider options for Topaz generative image models (Wonder 3.5).
+*
+* The documented request schema fields are sent in snake_case
+* (`output_width`, `output_format`, ...); model-specific settings are sent in
+* camelCase, matching the Topaz model reference.
+*
+* @see https://developer.topazlabs.com/image-models/wonder/wonder-3.5-new
+*/
+const topazImageModelOptionsSchema = lazySchema(() => zodSchema(z.object({
+	/**
+	* How aggressively the model enhances the image. Defaults to `high`.
+	*/
+	enhancementStrength: z.enum([
+		"low",
+		"medium",
+		"high"
+	]).optional(),
+	/**
+	* Whether to add grain to the output. Defaults to `false`.
+	*/
+	grain: z.boolean().optional(),
+	/**
+	* Grain intensity, 0.0 to 1.0. Defaults to 0.5.
+	*/
+	grainDensity: z.number().min(0).max(1).optional(),
+	/**
+	* Grain model. Defaults to `silver`.
+	*/
+	grainModel: z.enum([
+		"silver",
+		"gaussian",
+		"grey"
+	]).optional(),
+	/**
+	* Grain particle size, 1 to 5. Defaults to 1.
+	*/
+	grainSize: z.number().min(1).max(5).optional(),
+	/**
+	* Grain effect strength, 0.0 to 1.0. Defaults to 0.5.
+	*/
+	grainStrength: z.number().min(0).max(1).optional(),
+	/**
+	* Width of the input image in pixels. Topaz infers this from the upload when
+	* omitted.
+	*/
+	inputWidth: z.number().int().positive().optional(),
+	/**
+	* Height of the input image in pixels. Topaz infers this from the upload
+	* when omitted.
+	*/
+	inputHeight: z.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: z.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: z.number().int().min(1).max(32e3).optional(),
+	/**
+	* Output image format. Defaults to the Topaz API default.
+	*/
+	outputFormat: z.enum([
+		"jpeg",
+		"jpg",
+		"png",
+		"tiff",
+		"tif"
+	]).optional(),
+	/**
+	* Whether to crop the output to fill the requested dimensions. Defaults to
+	* `false`.
+	*/
+	cropToFill: z.boolean().optional(),
+	/**
+	* URL to receive job-status webhooks.
+	*/
+	webhookUrl: z.string().optional(),
+	/**
+	* How often to poll the Topaz status endpoint, in milliseconds. Defaults to
+	* 2000.
+	*/
+	pollIntervalMillis: z.number().int().positive().optional(),
+	/**
+	* How long to wait for the job to finish before failing, in milliseconds.
+	* Defaults to 600000 (10 minutes).
+	*/
+	pollTimeoutMillis: z.number().int().positive().optional()
+})));
+//#endregion
+//#region src/topaz-image-settings.ts
+/**
+* Maps AI SDK image model ids onto Topaz API model names.
+*
+* @see https://developer.topazlabs.com/image-models/wonder/wonder-3.5-new
+*/
+const topazImageApiModelIds = { "wonder-3.5": "Wonder 3.5" };
+function resolveTopazImageApiModelId(modelId) {
+	return topazImageApiModelIds[modelId] ?? modelId;
+}
+//#endregion
+//#region src/topaz-image-model.ts
+const DEFAULT_POLL_INTERVAL_MILLIS = 2e3;
+const DEFAULT_POLL_TIMEOUT_MILLIS = 6e5;
+/**
+* Topaz enhances an image that the caller supplies, so `files` is required and
+* exactly one image is processed per call.
+*/
+var TopazImageModel = class TopazImageModel {
+	get provider() {
+		return this.config.provider;
+	}
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new TopazImageModel(options.modelId, options.config);
+	}
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v4";
+		this.maxImagesPerCall = 1;
+		this.supportsFileInputs = true;
+		this.supportsMaskInputs = false;
+	}
+	async doGenerate(options) {
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__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: topazOptions?.pollIntervalMillis ?? DEFAULT_POLL_INTERVAL_MILLIS,
+				pollTimeoutMillis: topazOptions?.pollTimeoutMillis ?? DEFAULT_POLL_TIMEOUT_MILLIS
+			});
+		} catch (error) {
+			if (options.abortSignal?.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,
+				...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) {
+		const file = options.files?.[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 = mediaTypeToExtension(file.mediaType) ?? "png";
+			formData.append("image", new File([bytes], `image.${extension}`, { type: file.mediaType }));
+		}
+		const { width, height } = parseSize(options.size);
+		appendIfDefined(formData, "output_width", topazOptions?.outputWidth ?? width);
+		appendIfDefined(formData, "output_height", topazOptions?.outputHeight ?? height);
+		appendIfDefined(formData, "output_format", topazOptions?.outputFormat);
+		appendIfDefined(formData, "crop_to_fill", topazOptions?.cropToFill);
+		appendIfDefined(formData, "webhook_url", topazOptions?.webhookUrl);
+		appendIfDefined(formData, "enhancementStrength", topazOptions?.enhancementStrength);
+		appendIfDefined(formData, "grain", topazOptions?.grain);
+		appendIfDefined(formData, "grainDensity", topazOptions?.grainDensity);
+		appendIfDefined(formData, "grainModel", topazOptions?.grainModel);
+		appendIfDefined(formData, "grainSize", topazOptions?.grainSize);
+		appendIfDefined(formData, "grainStrength", topazOptions?.grainStrength);
+		appendIfDefined(formData, "inputWidth", topazOptions?.inputWidth);
+		appendIfDefined(formData, "inputHeight", topazOptions?.inputHeight);
+		return formData;
+	}
+	async waitForCompletion({ processId, headers, abortSignal, pollIntervalMillis, pollTimeoutMillis }) {
+		const deadline = Date.now() + pollTimeoutMillis;
+		while (true) {
+			const { value: status } = await getFromApi({
+				url: `${this.config.baseURL}/image/v1/status/${processId}`,
+				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 ?? {});
+				throw new AISDKError({
+					name: "TOPAZ_IMAGE_ENHANCEMENT_TIMEOUT",
+					message: `Topaz image enhancement did not finish within ${pollTimeoutMillis}ms (process ${processId}, last status ${status.status ?? "unknown"}). Increase the \`pollTimeoutMillis\` provider option if the job needs longer.`
+				});
+			}
+			await delay(pollIntervalMillis, { abortSignal });
+		}
+	}
+	async cancelQuietly(processId, headers) {
+		const fetchImpl = this.config.fetch ?? globalThis.fetch;
+		try {
+			await fetchImpl(`${this.config.baseURL}/image/v1/cancel/${processId}`, {
+				method: "DELETE",
+				headers: removeUndefinedEntries(headers)
+			});
+		} catch {}
+	}
+	async download({ processId, headers, abortSignal }) {
+		const { value: downloadResponse } = await getFromApi({
+			url: `${this.config.baseURL}/image/v1/download/${processId}`,
+			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 getFromApi({
+			url: downloadUrl,
+			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));
+}
+const topazImageSubmitResponseSchema = z.object({ process_id: z.string().nullish() });
+const topazImageStatusResponseSchema = z.object({
+	status: z.string().nullish(),
+	credits: z.number().nullish(),
+	output_width: z.number().nullish(),
+	output_height: z.number().nullish(),
+	output_format: z.string().nullish()
+});
+const topazImageDownloadResponseSchema = z.object({ download_url: z.string().nullish() });
+//#endregion
+//#region src/topaz-video-model-options.ts
+/**
+* Containers Topaz accepts for the input video.
+*/
+const topazSourceContainers = [
+	"3gp",
+	"avi",
+	"dv",
+	"flv",
+	"m1v",
+	"m2t",
+	"m2ts",
+	"m2v",
+	"m4v",
+	"mkv",
+	"mov",
+	"mp4",
+	"mpeg",
+	"mpg",
+	"mts",
+	"mxf",
+	"ser",
+	"ts",
+	"vob",
+	"webm",
+	"wmv"
+];
+/**
+* Containers Topaz can produce for the enhanced video.
+*/
+const topazOutputContainers = [
+	"mp4",
+	"mov",
+	"mkv",
+	"avi",
+	"webm"
+];
+/**
+* Metadata about the input video.
+*
+* Starlight models require `width`, `height`, `duration` and `frameRate`
+* (Topaz prices them from these values), and for other models they let Topaz
+* estimate the cost before it has the video. The AI SDK does not inspect
+* media files, so the values come from the caller. Setting any of them
+* requires all four.
+*/
+const topazVideoSourceSchema = z.object({
+	/**
+	* Width of the input video in pixels.
+	*/
+	width: z.number().int().positive().optional(),
+	/**
+	* Height of the input video in pixels.
+	*/
+	height: z.number().int().positive().optional(),
+	/**
+	* Duration of the input video in seconds.
+	*/
+	duration: z.number().positive().optional(),
+	/**
+	* Frame rate of the input video.
+	*/
+	frameRate: z.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: z.number().int().positive().optional(),
+	/**
+	* Container of the input video. Detected from the input file's media type
+	* or URL extension when omitted.
+	*/
+	container: z.enum(topazSourceContainers).optional()
+});
+/**
+* Output settings for the enhanced video.
+*/
+const topazVideoOutputSchema = z.object({
+	/**
+	* Width of the output video in pixels. Takes precedence over the
+	* `resolution` call option.
+	*/
+	width: z.number().int().positive().optional(),
+	/**
+	* Height of the output video in pixels. Takes precedence over the
+	* `resolution` call option.
+	*/
+	height: z.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: z.number().positive().optional(),
+	/**
+	* Audio codec of the output video. Defaults to `AAC`.
+	*/
+	audioCodec: z.enum([
+		"AAC",
+		"AC3",
+		"PCM"
+	]).optional(),
+	/**
+	* Audio bitrate, e.g. `192k`. Topaz uses the codec default when omitted.
+	*/
+	audioBitrate: z.string().optional(),
+	/**
+	* How to handle the input audio track. Defaults to `Copy`.
+	*/
+	audioTransfer: z.enum([
+		"Copy",
+		"Convert",
+		"None"
+	]).optional(),
+	/**
+	* Video encoder. Topaz defaults to `H265`. `ProRes` forces a `mov`
+	* container, `AV1` and `VP9` force `mp4`.
+	*/
+	videoEncoder: z.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: z.string().optional(),
+	/**
+	* Constant bitrate, e.g. `20m`. Required for `VP9`. Mutually exclusive with
+	* `dynamicCompressionLevel`.
+	*/
+	videoBitrate: z.string().optional(),
+	/**
+	* Automatic constant-quality compression level. Topaz defaults to `High`
+	* unless `videoBitrate` is set.
+	*/
+	dynamicCompressionLevel: z.enum([
+		"Low",
+		"Mid",
+		"High"
+	]).optional(),
+	/**
+	* Center-crop to fit the output dimensions.
+	*/
+	cropToFit: z.boolean().optional(),
+	/**
+	* Container of the output video. Defaults to the input container when Topaz
+	* can produce it, otherwise `mp4`.
+	*/
+	container: z.enum(topazOutputContainers).optional()
+});
+/**
+* Provider options for Topaz video models.
+*
+* @see https://developer.topazlabs.com/video-models/proteus/proteus-1
+* @see https://developer.topazlabs.com/video-models/starlight/starlight-precise-2.6
+*/
+const topazVideoModelOptionsSchema = lazySchema(() => zodSchema(z.object({
+	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: z.array(z.record(z.string(), z.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: z.record(z.string(), z.unknown()).optional(),
+	/** Proteus: how the input frames are encoded. */
+	videoType: z.enum([
+		"Progressive",
+		"Interlaced",
+		"ProgressiveInterlaced"
+	]).optional(),
+	/** Proteus: parameter estimation mode. */
+	auto: z.enum([
+		"Auto",
+		"Manual",
+		"Relative"
+	]).optional(),
+	/** Proteus: field order for interlaced input. */
+	fieldOrder: z.enum([
+		"TopFirst",
+		"BottomFirst",
+		"Auto"
+	]).optional(),
+	/** Proteus: focus-fix strength. */
+	focusFixLevel: z.enum([
+		"None",
+		"Normal",
+		"Strong"
+	]).optional(),
+	/** Proteus: compression artifact removal, -1 to 1. */
+	compression: z.number().min(-1).max(1).optional(),
+	/** Proteus: detail recovery, -1 to 1. */
+	details: z.number().min(-1).max(1).optional(),
+	/** Proteus: pre-processing noise reduction, 0 to 0.1. */
+	prenoise: z.number().min(0).max(.1).optional(),
+	/** Proteus: noise reduction, -1 to 1. */
+	noise: z.number().min(-1).max(1).optional(),
+	/** Proteus: halo suppression, -1 to 1. */
+	halo: z.number().min(-1).max(1).optional(),
+	/** Proteus: pre-processing blur, -1 to 1. */
+	preblur: z.number().min(-1).max(1).optional(),
+	/** Proteus: sharpening, -1 to 1. */
+	blur: z.number().min(-1).max(1).optional(),
+	/** Proteus: grain amount, 0 to 0.1. */
+	grain: z.number().min(0).max(.1).optional(),
+	/** Proteus: grain sigma, 0 to 1. */
+	grainSigma: z.number().min(0).max(1).optional(),
+	/** Proteus: grain size, 0 to 5. */
+	grainSize: z.number().min(0).max(5).optional(),
+	/** Proteus: grain model. */
+	grainType: z.enum([
+		"silver_rich",
+		"gaussian",
+		"grey"
+	]).optional(),
+	/** Proteus: original detail recovery, 0 to 1. */
+	recoverOriginalDetailValue: z.number().min(0).max(1).optional(),
+	/** Starlight: sharpening applied to the output, 1.0 to 5.0. Defaults to 5.0. */
+	sharpness: z.number().min(1).max(5).optional(),
+	/** Starlight: output bit depth. */
+	videoBitDepth: z.number().int().positive().optional(),
+	/** Starlight: output video codec. */
+	videoCodec: z.enum([
+		"ffv1",
+		"prores",
+		"vp9"
+	]).optional(),
+	/** Starlight: output chroma subsampling profile. */
+	videoProfile: z.enum([
+		"420",
+		"422",
+		"444"
+	]).optional(),
+	/** Starlight: whether to watermark the output. Defaults to `false`. */
+	watermark: z.boolean().optional()
+})));
+/**
+* Option keys that are structural rather than filter settings, so they are not
+* forwarded into the `filters[]` entry.
+*/
+const TOPAZ_NON_FILTER_OPTION_KEYS = [
+	"source",
+	"output",
+	"additionalFilters",
+	"filter"
+];
+//#endregion
+//#region src/topaz-video-settings.ts
+/**
+* Maps AI SDK video model ids onto Topaz API model names.
+*
+* @see https://developer.topazlabs.com/video-models/proteus/proteus-1
+* @see https://developer.topazlabs.com/video-models/starlight/starlight-precise-2.6
+*/
+const topazVideoApiModelIds = {
+	proteus: "prob-4",
+	"starlight-precise-2.6": "slp-2.6"
+};
+function resolveTopazVideoApiModelId(modelId) {
+	return topazVideoApiModelIds[modelId] ?? modelId;
+}
+//#endregion
+//#region src/version.ts
+const VERSION = "3.0.0";
+//#endregion
+//#region src/topaz-video-model.ts
+const 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"
+};
+const extensionContainers = {
+	...Object.fromEntries(topazSourceContainers.map((c) => [c, c])),
+	qt: "mov"
+};
+const 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"
+};
+/**
+* Topaz video models enhance a video the caller supplies, passed through
+* `inputReferences`. `doStart` creates an express request: Topaz fetches URL
+* inputs itself, and file inputs are uploaded to the returned URL. Processing
+* starts once Topaz has the video, and `doStatus` polls.
+*/
+var TopazVideoModel = class TopazVideoModel {
+	get provider() {
+		return this.config.provider;
+	}
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new TopazVideoModel(options.modelId, options.config);
+	}
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v4";
+		this.maxVideosPerCall = 1;
+	}
+	async doStart(options) {
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+		const warnings = [];
+		const topazOptions = await parseProviderOptions({
+			provider: "topaz",
+			providerOptions: options.providerOptions,
+			schema: topazVideoModelOptionsSchema
+		});
+		const headers = combineHeaders(await resolve(this.config.headers), options.headers);
+		this.addUnsupportedWarnings(options, warnings);
+		const input = this.selectInputVideo(options, warnings);
+		const source = resolveSource(topazOptions, resolveContainer(input, topazOptions?.source?.container));
+		const output = buildOutput({
+			options,
+			topazOptions,
+			source
+		});
+		const filters = [buildFilter(this.modelId, topazOptions), ...topazOptions?.additionalFilters ?? []];
+		const contentType = containerMediaTypes[source.container] ?? "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" ? { external: {
+							provider: "s3",
+							presignedUrl: input.url
+						} } : { size: bytes?.byteLength }
+					},
+					output,
+					filters
+				},
+				successfulResponseHandler: createJsonResponseHandler(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 {
+				operation: {
+					requestId,
+					outputContainer: output.container
+				},
+				warnings,
+				providerMetadata: { topaz: {
+					requestId,
+					...created.estimates?.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 doStatus(options) {
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+		const { requestId, outputContainer } = options.operation;
+		const { value: status, responseHeaders } = await getFromApi({
+			url: `${this.config.baseURL}/video/${requestId}/status`,
+			validateUrl: false,
+			headers: combineHeaders(await resolve(this.config.headers), options.headers),
+			successfulResponseHandler: createJsonResponseHandler(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(status.estimates?.cost);
+			const url = status.download?.url;
+			if (url == null) throw new InvalidResponseDataError({
+				data: status,
+				message: `Topaz reported request ${requestId} complete but returned no download URL.`
+			});
+			return {
+				status: "completed",
+				videos: [{
+					type: "url",
+					url,
+					mediaType: (outputContainer != null ? containerMediaTypes[outputContainer] : void 0) ?? "video/mp4"
+				}],
+				warnings: [],
+				response,
+				providerMetadata: { topaz: {
+					requestId,
+					...credits != null ? { credits } : {},
+					...status.estimates?.cost != null ? { estimatedCredits: status.estimates.cost } : {},
+					...status.outputSize != null ? { outputSize: status.outputSize } : {},
+					...status.download?.expiresAt != null ? { expiresAt: status.download.expiresAt } : {}
+				} }
+			};
+		}
+		if (status.status === "failed" || status.status === "canceled") return {
+			status: "error",
+			error: `Topaz video request ${requestId} ${status.status}` + (status.errorCode != null ? ` (${status.errorCode})` : "") + (status.message != null ? `: ${status.message}` : "."),
+			providerMetadata: { topaz: {
+				requestId,
+				...status.errorCode != null ? { errorCode: status.errorCode } : {}
+			} },
+			response
+		};
+		return {
+			status: "pending",
+			response
+		};
+	}
+	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) {
+		const references = options.inputReferences ?? [];
+		const videos = references.filter(isVideoReference);
+		if (videos.length === 0) {
+			if (options.image != null) throw new InvalidArgumentError({
+				argument: "image",
+				message: "Topaz video models enhance an existing video, not a still image. Pass the input video via `inputReferences`."
+			});
+			throw new InvalidArgumentError({
+				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 }) {
+		const url = urls?.[0];
+		if (url == null) throw new InvalidResponseDataError({
+			data: urls,
+			message: `Topaz returned no upload URL for request ${requestId}.`
+		});
+		if (!isSameOrigin(url, this.config.baseURL)) validateDownloadUrl(url);
+		const response = await (this.config.fetch ?? globalThis.fetch)(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) {
+		const fetchImpl = this.config.fetch ?? globalThis.fetch;
+		try {
+			await fetchImpl(`${this.config.baseURL}/video/${requestId}`, {
+				method: "DELETE",
+				headers: removeUndefinedEntries(headers)
+			});
+		} catch {}
+	}
+};
+function lowerBoundCredits(cost) {
+	return cost != null && cost.length > 0 ? Math.min(...cost) : void 0;
+}
+function fileBytes(input) {
+	return typeof input.data === "string" ? convertBase64ToUint8Array(input.data) : input.data;
+}
+function resolveContainer(input, declaredContainer) {
+	if (declaredContainer != null) return declaredContainer;
+	if (input.type === "file") {
+		const container = mediaTypeContainers[input.mediaType.toLowerCase()];
+		if (container == null) throw new InvalidArgumentError({
+			argument: "inputReferences",
+			message: `Could not map the media type "${input.mediaType}" onto a Topaz container. Set the \`source.container\` provider option explicitly.`
+		});
+		return container;
+	}
+	const container = (input.mediaType != null ? mediaTypeContainers[input.mediaType.toLowerCase()] : void 0) ?? containerFromUrl(input.url);
+	if (container == null) throw new InvalidArgumentError({
+		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) {
+	const extension = url.split(/[?#]/)[0].split(".").pop()?.toLowerCase();
+	return extension != null ? extensionContainers[extension] : void 0;
+}
+/**
+* Reads the optional source metadata, which is all or nothing. Starlight
+* models require it, and it lets Topaz estimate the cost up front. Nothing is
+* read out of the video bytes: no provider package inspects media files.
+*/
+function resolveSource(topazOptions, container) {
+	const source = topazOptions?.source;
+	const { width, height, duration, frameRate } = source ?? {};
+	if (width == null && height == null && duration == null && frameRate == null && source?.frameCount == null) return {
+		container,
+		metadata: void 0
+	};
+	const frameCount = source?.frameCount ?? (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 InvalidArgumentError({
+		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 }) {
+	const output = topazOptions?.output;
+	const resolution = parseResolution(options.resolution);
+	const width = output?.width ?? resolution.width ?? source.metadata?.width;
+	const height = output?.height ?? resolution.height ?? source.metadata?.height;
+	if (width == null || height == null) throw new InvalidArgumentError({
+		argument: "resolution",
+		message: "Topaz needs the output resolution. Set the `resolution` call option or the `output.width` / `output.height` provider options."
+	});
+	const frameRate = output?.frameRate ?? options.fps ?? source.metadata?.frameRate;
+	const audioTransfer = output?.audioTransfer ?? "Copy";
+	return {
+		resolution: {
+			width,
+			height
+		},
+		...frameRate != null ? { frameRate } : {},
+		audioTransfer,
+		...audioTransfer !== "None" ? { audioCodec: output?.audioCodec ?? "AAC" } : output?.audioCodec != null ? { audioCodec: output.audioCodec } : {},
+		...output?.audioBitrate != null ? { audioBitrate: output.audioBitrate } : {},
+		...output?.videoEncoder != null ? { videoEncoder: output.videoEncoder } : {},
+		...output?.videoProfile != null ? { videoProfile: output.videoProfile } : {},
+		...output?.videoBitrate != null ? { videoBitrate: output.videoBitrate } : {},
+		...output?.dynamicCompressionLevel != null ? { dynamicCompressionLevel: output.dynamicCompressionLevel } : {},
+		...output?.cropToFit != null ? { cropToFit: output.cropToFit } : {},
+		container: resolveOutputContainer(output, source.container)
+	};
+}
+/**
+* Mirrors Topaz's container rules so `doStatus` can report the media type of
+* the file Topaz will actually produce.
+*/
+function resolveOutputContainer(output, sourceContainer) {
+	switch (output?.videoEncoder) {
+		case "ProRes": return "mov";
+		case "AV1":
+		case "VP9": return "mp4";
+	}
+	if (output?.container != null) return output.container;
+	return sourceContainer === "mov" || sourceContainer === "mkv" ? sourceContainer : "mp4";
+}
+function requireRequestId(requestId) {
+	if (requestId == null) throw new InvalidResponseDataError({
+		data: requestId,
+		message: "Topaz did not return a requestId for the video request."
+	});
+	return requestId;
+}
+function buildFilter(modelId, topazOptions) {
+	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, topazOptions.filter ?? {});
+	}
+	return filter;
+}
+const topazVideoEstimatesSchema = z.object({
+	cost: z.array(z.number()).nullish(),
+	time: z.array(z.number()).nullish()
+}).nullish();
+const topazVideoExpressResponseSchema = z.object({
+	requestId: z.string().nullish(),
+	uploadUrls: z.array(z.string()).nullish(),
+	estimates: topazVideoEstimatesSchema
+});
+const topazVideoStatusResponseSchema = z.object({
+	status: z.string().nullish(),
+	message: z.string().nullish(),
+	errorCode: z.string().nullish(),
+	outputSize: z.union([z.string(), z.number()]).nullish(),
+	estimates: topazVideoEstimatesSchema,
+	download: z.object({
+		url: z.string().nullish(),
+		expiresAt: z.union([z.string(), z.number()]).nullish()
+	}).nullish()
+});
+//#endregion
+//#region src/topaz-provider.ts
+const defaultBaseURL = "https://api.topazlabs.com";
+/**
+* Create a Topaz Labs provider instance.
+*/
+function createTopaz(options = {}) {
+	const baseURL = withoutTrailingSlash(options.baseURL ?? defaultBaseURL) ?? defaultBaseURL;
+	const getHeaders = () => withUserAgentSuffix({
+		"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
+		});
+	};
+	return {
+		specificationVersion: "v4",
+		image: createImageModel,
+		imageModel: createImageModel,
+		video: createVideoModel,
+		videoModel: createVideoModel,
+		languageModel: (modelId) => noSuchModel(modelId, "languageModel"),
+		embeddingModel: (modelId) => noSuchModel(modelId, "embeddingModel")
+	};
+}
+/**
+* Default Topaz Labs provider instance.
+*/
+const topaz = createTopaz();
+//#endregion
+export { VERSION, createTopaz, topaz };
+
+//# sourceMappingURL=index.js.map