@neta-art/generation 0.1.1 → 0.1.3

package/dist/export-config-D8By2_r7.js

@@ -0,0 +1,1263 @@
+import { a as compactArray, c as slugifyFileName, i as cloneJson, l as MODEL_SCHEMA, n as getBuiltinGenerationModel, o as compactObject, r as listBuiltinGenerationModels, s as getBlockMeta, t as builtinGenerationModels } from "./builtins-FumzmWvj.js";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { extname, join } from "node:path";
+import { parse, stringify } from "yaml";
+
+//#region src/errors.ts
+var GenerationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "GenerationError";
+	}
+};
+var GenerationConfigError = class extends GenerationError {
+	constructor(message) {
+		super(message);
+		this.name = "GenerationConfigError";
+	}
+};
+var GenerationValidationError = class extends GenerationError {
+	constructor(message) {
+		super(message);
+		this.name = "GenerationValidationError";
+	}
+};
+var GenerationUnsupportedAdapterError = class extends GenerationError {
+	constructor(adapterType) {
+		super(`Unsupported generation adapter: ${adapterType}`);
+		this.name = "GenerationUnsupportedAdapterError";
+	}
+};
+var GenerationProviderError = class extends GenerationError {
+	status;
+	body;
+	details;
+	constructor(message = "Generation provider request failed", options) {
+		super(message);
+		this.name = "GenerationProviderError";
+		this.status = options?.status;
+		this.body = options?.body;
+		this.details = options?.details;
+	}
+};
+var GenerationTimeoutError = class extends GenerationProviderError {
+	constructor(message = "Generation request timed out", details) {
+		super(message, details ? { details } : void 0);
+		this.name = "GenerationTimeoutError";
+	}
+};
+
+//#endregion
+//#region src/http.ts
+function headersToRecord(headers) {
+	if (!headers) return {};
+	if (headers instanceof Headers) {
+		const output = {};
+		headers.forEach((value, key) => {
+			output[key] = value;
+		});
+		return output;
+	}
+	if (Array.isArray(headers)) return Object.fromEntries(headers.map(([key, value]) => [key, value]));
+	return { ...headers };
+}
+function parseJsonBody(body) {
+	try {
+		return JSON.parse(body);
+	} catch {
+		return body;
+	}
+}
+function parseDebugBody(body) {
+	if (typeof body !== "string") return body ? "[non-string body]" : void 0;
+	return parseJsonBody(body);
+}
+const TRACE_HEADER_PATTERN = /(^|[-_])(request|trace|span|correlation|cf-ray|x-tt-logid)([-_]|$)|^(x-request-id|x-trace-id|x-correlation-id|traceparent|tracestate|cf-ray|server-timing)$/i;
+function pickTraceHeaders(headers) {
+	const output = {};
+	for (const [key, value] of Object.entries(headers)) if (TRACE_HEADER_PATTERN.test(key)) output[key] = value;
+	return output;
+}
+function emitDebugRequest(debug, url, init) {
+	debug.logger({
+		type: "request",
+		url,
+		method: init.method ?? "GET",
+		headers: headersToRecord(init.headers),
+		body: parseDebugBody(init.body)
+	});
+	return Date.now();
+}
+async function readDebugResponseBody(response) {
+	const contentType = response.headers.get("content-type") ?? "";
+	if (contentType.includes("application/json") || contentType.includes("+json")) return parseJsonBody(await response.clone().text());
+	if (contentType.startsWith("text/")) return response.clone().text();
+	return "[non-text body]";
+}
+async function emitDebugResponse(debug, url, response, startedAt) {
+	const headers = headersToRecord(response.headers);
+	debug.logger({
+		type: "response",
+		url,
+		status: response.status,
+		statusText: response.statusText,
+		headers,
+		trace: pickTraceHeaders(headers),
+		elapsedMs: Date.now() - startedAt,
+		...debug.includeResponseBody ? { body: await readDebugResponseBody(response) } : {}
+	});
+}
+function createDebugFetch(fetchFn, debug) {
+	return (async (input, init) => {
+		const url = String(input instanceof Request ? input.url : input);
+		const startedAt = emitDebugRequest(debug, url, init ?? (input instanceof Request ? input : {}));
+		const response = await fetchFn(input, init);
+		await emitDebugResponse(debug, url, response, startedAt);
+		return response;
+	});
+}
+async function fetchWithTimeout(fetchFn, url, init, timeoutMs) {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		return await fetchFn(url, {
+			...init,
+			signal: controller.signal
+		});
+	} catch (error) {
+		if (error instanceof Error && error.name === "AbortError") throw new GenerationTimeoutError();
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+function joinUrl(baseUrl, path) {
+	return `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+
+//#endregion
+//#region src/validation.ts
+function specsByType(specs) {
+	const map = /* @__PURE__ */ new Map();
+	for (const spec of specs) map.set(spec.type, spec);
+	return map;
+}
+function validateGenerationContent(declaration, content) {
+	const inputSpecs = specsByType(declaration.content.input);
+	const counts = /* @__PURE__ */ new Map();
+	for (const block of content) {
+		const spec = inputSpecs.get(block.type);
+		if (!spec) throw new GenerationValidationError(`Content block type is not supported by ${declaration.model}: ${block.type}`);
+		counts.set(block.type, (counts.get(block.type) ?? 0) + 1);
+		if ("source" in block && spec.sources && !spec.sources.includes(block.source.type)) throw new GenerationValidationError(`${block.type} source is not supported by ${declaration.model}: ${block.source.type}`);
+	}
+	for (const spec of declaration.content.input) {
+		const count = counts.get(spec.type) ?? 0;
+		if (spec.required && count === 0) throw new GenerationValidationError(`Missing required ${spec.type} content block`);
+		if (spec.min !== void 0 && count < spec.min) throw new GenerationValidationError(`Expected at least ${spec.min} ${spec.type} content block(s)`);
+		if (spec.max !== void 0 && count > spec.max) throw new GenerationValidationError(`Expected at most ${spec.max} ${spec.type} content block(s)`);
+	}
+}
+function resolveGenerationParameters(declaration, parameters) {
+	const specs = declaration.parameters ?? {};
+	const resolved = {};
+	const allowUnknownParameters = declaration.allowUnknownParameters ?? false;
+	for (const key of Object.keys(parameters ?? {})) if (!specs[key]) {
+		if (!allowUnknownParameters) throw new GenerationValidationError(`Unknown parameter: ${key}`);
+		const value = parameters?.[key];
+		if (value !== void 0) resolved[key] = value;
+	}
+	for (const [key, spec] of Object.entries(specs)) {
+		const value = parameters?.[key];
+		if (value === void 0) {
+			if (spec.default !== void 0) resolved[key] = spec.default;
+			else if (!spec.optional) throw new GenerationValidationError(`Missing required parameter: ${key}`);
+			continue;
+		}
+		validateSpecValue(`Parameter ${key}`, spec, value);
+		resolved[key] = value;
+	}
+	return resolved;
+}
+function mergeGenerationMeta(requestMeta, content) {
+	const merged = {};
+	mergeMetaFields(merged, requestMeta);
+	for (const block of content) mergeMetaFields(merged, block.meta);
+	return merged;
+}
+function normalizeMetaKey(key) {
+	return key === "metadataParams" ? "metadata_params" : key;
+}
+function mergeMetaFields(target, meta) {
+	for (const [key, value] of Object.entries(meta ?? {})) {
+		const normalizedKey = normalizeMetaKey(key);
+		if (value !== void 0 && target[normalizedKey] === void 0) target[normalizedKey] = value;
+	}
+}
+function validateSpecValue(label, spec, value) {
+	switch (spec.type) {
+		case "string":
+			if (typeof value !== "string") throw new GenerationValidationError(`${label} must be a string`);
+			if (spec.enum && !spec.enum.includes(value)) throw new GenerationValidationError(`${label} must be one of: ${spec.enum.join(", ")}`);
+			break;
+		case "number":
+			if (typeof value !== "number" || !Number.isFinite(value)) throw new GenerationValidationError(`${label} must be a number`);
+			if (spec.min !== void 0 && value < spec.min) throw new GenerationValidationError(`${label} must be >= ${spec.min}`);
+			if (spec.max !== void 0 && value > spec.max) throw new GenerationValidationError(`${label} must be <= ${spec.max}`);
+			break;
+		case "integer":
+			if (typeof value !== "number" || !Number.isInteger(value)) throw new GenerationValidationError(`${label} must be an integer`);
+			if (spec.min !== void 0 && value < spec.min) throw new GenerationValidationError(`${label} must be >= ${spec.min}`);
+			if (spec.max !== void 0 && value > spec.max) throw new GenerationValidationError(`${label} must be <= ${spec.max}`);
+			break;
+		case "boolean":
+			if (typeof value !== "boolean") throw new GenerationValidationError(`${label} must be a boolean`);
+			break;
+		case "object":
+			if (!value || typeof value !== "object" || Array.isArray(value)) throw new GenerationValidationError(`${label} must be an object`);
+			break;
+	}
+}
+function resolveGenerationMeta(declaration, meta, content) {
+	const specs = declaration.meta?.fields ?? {};
+	const resolved = {};
+	for (const key of Object.keys(meta ?? {})) if (!specs[key]) {
+		const value = meta?.[key];
+		if (value !== void 0) resolved[key] = value;
+	}
+	for (const [key, spec] of Object.entries(specs)) {
+		const value = meta?.[key];
+		if (value === void 0) {
+			if (!spec.optional) throw new GenerationValidationError(`Missing required meta: ${key}`);
+			continue;
+		}
+		validateSpecValue(`meta.${key}`, spec, value);
+		resolved[key] = value;
+	}
+	const taskField = declaration.meta?.taskField;
+	const task = taskField && typeof resolved[taskField] === "string" ? resolved[taskField] : void 0;
+	if (!task) return resolved;
+	const variant = declaration.meta?.taskVariants?.[task];
+	if (!variant) throw new GenerationValidationError(`Unsupported meta.${taskField}: ${task}`);
+	for (const key of variant.required ?? []) if (resolved[key] === void 0 || resolved[key] === null || resolved[key] === "") throw new GenerationValidationError(`meta.${taskField} ${task} requires meta.${key}`);
+	for (const type of variant.requiredContent ?? []) if (!content.some((block) => block.type === type)) throw new GenerationValidationError(`meta.${taskField} ${task} requires ${type} content`);
+	return resolved;
+}
+function mergeTextBlocks(declaration, content) {
+	const textSpec = declaration.content.input.find((spec) => spec.type === "text");
+	const separator = textSpec?.merge === "space" ? " " : textSpec?.merge === "concat" ? "" : "\n";
+	return content.filter((block) => block.type === "text").map((block) => block.text).join(separator).trim();
+}
+
+//#endregion
+//#region src/adapters/ark-video-generations.ts
+const REQUEST_TIMEOUT_MS$3 = 6e4;
+const DEFAULT_POLL_INTERVAL_SEC$1 = 2;
+const DEFAULT_MAX_WAIT_SEC$1 = 600;
+const RESOLUTION_SHORT_EDGE = {
+	"480p": 480,
+	"720p": 720,
+	"1080p": 1080,
+	"2K": 1440
+};
+const ASPECT_RATIOS = {
+	"16:9": [16, 9],
+	"9:16": [9, 16],
+	"1:1": [1, 1],
+	"4:3": [4, 3],
+	"3:2": [3, 2],
+	"2:3": [2, 3],
+	"3:4": [3, 4],
+	"21:9": [21, 9],
+	adaptive: null
+};
+function sleep$1(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function asString$1(value) {
+	return typeof value === "string" && value ? value : void 0;
+}
+function asNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asBoolean(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function normalizeStatus$1(value) {
+	const status = value.toLowerCase();
+	return status === "success" ? "succeeded" : status;
+}
+function getIntegerParameter(parameters, key, fallback) {
+	const value = parameters[key];
+	return typeof value === "number" && Number.isInteger(value) ? value : fallback;
+}
+function resolveSize(resolution, aspectRatio) {
+	const ratio = ASPECT_RATIOS[aspectRatio];
+	if (!ratio) return null;
+	const shortEdge = RESOLUTION_SHORT_EDGE[resolution];
+	if (!shortEdge) throw new GenerationValidationError(`Unsupported resolution: ${resolution}`);
+	const [wRatio, hRatio] = ratio;
+	const width = wRatio >= hRatio ? Math.round(shortEdge * wRatio / hRatio) : shortEdge;
+	const height = wRatio >= hRatio ? shortEdge : Math.round(shortEdge * hRatio / wRatio);
+	return {
+		width: width % 2 === 0 ? width : width + 1,
+		height: height % 2 === 0 ? height : height + 1
+	};
+}
+function getImageRole(block) {
+	const role = getBlockMeta(block)?.role;
+	return typeof role === "string" && role ? role : void 0;
+}
+function classifyImages(images) {
+	if (images.length === 0) return null;
+	const hasFirstOrLast = images.some((image) => image.role === "first_frame" || image.role === "last_frame");
+	const hasReference = images.some((image) => image.role === "reference_image");
+	if ([
+		images.some((image) => !image.role),
+		hasFirstOrLast,
+		hasReference
+	].filter(Boolean).length > 1) throw new GenerationValidationError("Cannot mix video image modes: use only plain image, first_frame/last_frame, or reference_image");
+	if (hasReference) return "reference";
+	if (hasFirstOrLast) return "frame";
+	return "image";
+}
+function buildMetadataContent(prompt, images, mode) {
+	const content = [{
+		type: "text",
+		text: prompt
+	}];
+	for (const image of images) {
+		if (mode === "frame" && image.role !== "first_frame" && image.role !== "last_frame") throw new GenerationValidationError("Frame mode images must use meta.role first_frame or last_frame");
+		if (mode === "reference" && image.role !== "reference_image") throw new GenerationValidationError("Reference mode images must use meta.role reference_image");
+		content.push({
+			type: "image_url",
+			image_url: { url: image.url },
+			role: image.role
+		});
+	}
+	return content;
+}
+function extractTaskId$1(response) {
+	const taskId = asString$1(response.task_id) ?? asString$1(response.id);
+	if (!taskId) throw new GenerationProviderError("Video generation provider did not return a task id", { details: { response } });
+	return taskId;
+}
+function normalizeTaskStatus(response) {
+	if (response.data) {
+		const wrapper = response.data;
+		const native = wrapper.data;
+		const status = normalizeStatus$1(asString$1(native?.status) ?? asString$1(wrapper.status) ?? "unknown");
+		const videoUrl = asString$1(wrapper.result_url) ?? asString$1(native?.content?.video_url);
+		const lastFrameUrl = asString$1(wrapper.first_frame) ?? asString$1(native?.content?.first_frame);
+		const metadata = {
+			progress: wrapper.progress,
+			resolution: native?.resolution,
+			ratio: native?.ratio,
+			duration: native?.duration,
+			framespersecond: native?.framespersecond,
+			seed: native?.seed,
+			generate_audio: native?.generate_audio,
+			model: native?.model,
+			usage: native?.usage
+		};
+		for (const key of Object.keys(metadata)) if (metadata[key] === void 0) delete metadata[key];
+		return {
+			status,
+			videoUrl,
+			lastFrameUrl,
+			metadata
+		};
+	}
+	return {
+		status: "unknown",
+		videoUrl: void 0,
+		lastFrameUrl: void 0,
+		metadata: {}
+	};
+}
+async function requestJson$1(input, path, init) {
+	const response = await fetchWithTimeout(input.context.fetch, joinUrl(input.context.baseUrl, path), {
+		...init,
+		headers: {
+			Authorization: `Bearer ${input.context.apiKey}`,
+			"Content-Type": "application/json",
+			...init.headers
+		}
+	}, REQUEST_TIMEOUT_MS$3);
+	if (!response.ok) {
+		const body = await response.text().catch(() => response.statusText);
+		throw new GenerationProviderError("Video generation provider request failed", {
+			status: response.status,
+			body
+		});
+	}
+	return response.json();
+}
+async function arkVideoGenerationsAdapter(input) {
+	const prompt = mergeTextBlocks(input.declaration, input.request.content);
+	if (!prompt) throw new GenerationValidationError("Prompt text is required");
+	const imageBlocks = input.request.content.filter((block) => block.type === "image");
+	const images = await Promise.all(imageBlocks.map(async (block) => ({
+		url: await input.context.resolveSource(block.source),
+		role: getImageRole(block)
+	})));
+	const mode = classifyImages(images);
+	const resolution = asString$1(input.parameters.resolution) ?? "720p";
+	const aspectRatio = asString$1(input.parameters.aspect_ratio) ?? "16:9";
+	const duration = getIntegerParameter(input.parameters, "duration", 5);
+	const fps = getIntegerParameter(input.parameters, "fps", 30);
+	const pollIntervalSec = getIntegerParameter(input.parameters, "poll_interval", DEFAULT_POLL_INTERVAL_SEC$1);
+	const maxWaitSec = getIntegerParameter(input.parameters, "max_wait", DEFAULT_MAX_WAIT_SEC$1);
+	const generateAudio = asBoolean(input.parameters.generate_audio) ?? true;
+	const returnLastFrame = asBoolean(input.parameters.return_last_frame) ?? true;
+	const cameraFixed = asBoolean(input.parameters.camera_fixed) ?? false;
+	const watermark = asBoolean(input.parameters.watermark) ?? false;
+	const seed = asNumber(input.parameters.seed);
+	const payload = {
+		model: input.declaration.model,
+		prompt
+	};
+	const metadata = {
+		duration,
+		fps,
+		generate_audio: generateAudio
+	};
+	if (seed !== void 0) metadata.seed = seed;
+	if (returnLastFrame) metadata.return_last_frame = true;
+	if (cameraFixed) metadata.camera_fixed = true;
+	if (watermark) metadata.watermark = true;
+	if (mode === "frame" || mode === "reference") {
+		metadata.content = buildMetadataContent(prompt, images, mode);
+		metadata.resolution = resolution;
+		metadata.ratio = aspectRatio;
+	} else {
+		const size = resolveSize(resolution, aspectRatio);
+		if (size) {
+			payload.width = size.width;
+			payload.height = size.height;
+		}
+		if (images[0]) payload.image = images[0].url;
+	}
+	payload.metadata = metadata;
+	const taskId = extractTaskId$1(await requestJson$1(input, "/v1/video/generations", {
+		method: "POST",
+		body: JSON.stringify(payload)
+	}));
+	const startedAt = Date.now();
+	while (Date.now() - startedAt <= maxWaitSec * 1e3) {
+		await sleep$1(pollIntervalSec * 1e3);
+		const rawStatus = await requestJson$1(input, `/v1/video/generations/${encodeURIComponent(taskId)}`, { method: "GET" });
+		const status = normalizeTaskStatus(rawStatus);
+		if (status.status === "succeeded") {
+			if (!status.videoUrl) throw new GenerationProviderError("Video generation succeeded but returned no video URL", { details: compactObject({
+				taskId,
+				rawStatus,
+				metadata: status.metadata
+			}) });
+			const output = [{
+				type: "video",
+				source: {
+					type: "url",
+					url: status.videoUrl
+				},
+				meta: {
+					task_id: taskId,
+					status: status.status,
+					...status.metadata
+				}
+			}];
+			if (status.lastFrameUrl) output.push({
+				type: "image",
+				source: {
+					type: "url",
+					url: status.lastFrameUrl
+				},
+				meta: {
+					role: "last_frame",
+					task_id: taskId
+				}
+			});
+			return output;
+		}
+		if ([
+			"failed",
+			"expired",
+			"cancelled"
+		].includes(status.status)) throw new GenerationProviderError(`Video generation ${status.status}`, { details: {
+			taskId,
+			rawStatus
+		} });
+	}
+	throw new GenerationTimeoutError("Timed out waiting for video generation", { taskId });
+}
+
+//#endregion
+//#region src/adapters/gemini-generate-content.ts
+const REQUEST_TIMEOUT_MS$2 = 3e5;
+const IMAGE_FETCH_TIMEOUT_MS = 6e4;
+const MAX_REFERENCE_IMAGE_BYTES = 10 * 1024 * 1024;
+const DATA_URI_PATTERN = /^data:([^;]+);base64,(.+)$/s;
+const MARKDOWN_IMAGE_DATA_URI_PATTERN = /!\[[^\]]*\]\(data:([^;]+);base64,([^)]+)\)/;
+function dataUriToInlineData(value) {
+	const match = DATA_URI_PATTERN.exec(value);
+	if (!match) return null;
+	const [, mimeType, data] = match;
+	if (!mimeType || !data) return null;
+	return { inlineData: {
+		mimeType,
+		data
+	} };
+}
+async function urlToInlineData(fetchFn, url) {
+	const response = await fetchWithTimeout(fetchFn, url, {
+		method: "GET",
+		headers: { "User-Agent": "NetaGeneration/1.0" }
+	}, IMAGE_FETCH_TIMEOUT_MS);
+	if (!response.ok) throw new GenerationProviderError("Failed to fetch reference image", { status: response.status });
+	const contentLength = response.headers.get("content-length");
+	if (contentLength && Number(contentLength) > MAX_REFERENCE_IMAGE_BYTES) throw new GenerationValidationError("Reference image is too large");
+	const bytes = Buffer.from(await response.arrayBuffer());
+	if (bytes.byteLength > MAX_REFERENCE_IMAGE_BYTES) throw new GenerationValidationError("Reference image is too large");
+	const contentType = response.headers.get("content-type")?.split(";")[0]?.trim();
+	return { inlineData: {
+		mimeType: contentType?.startsWith("image/") ? contentType : "image/png",
+		data: bytes.toString("base64")
+	} };
+}
+async function sourceToInlineData(input, value) {
+	const inline = dataUriToInlineData(value);
+	if (inline) return inline;
+	if (value.startsWith("http://") || value.startsWith("https://")) return urlToInlineData(input.context.fetch, value);
+	throw new GenerationValidationError("Unsupported image source for Gemini image generation");
+}
+function extractMarkdownDataUriImage(text) {
+	const match = MARKDOWN_IMAGE_DATA_URI_PATTERN.exec(text);
+	if (!match) return null;
+	const [, mediaType, data] = match;
+	if (!mediaType || !data) return null;
+	return {
+		type: "image",
+		source: {
+			type: "base64",
+			mediaType,
+			data
+		}
+	};
+}
+function collectGeminiNoOutputDetails(raw) {
+	const candidates = raw.candidates ?? [];
+	return compactObject({
+		finishReasons: compactArray(candidates.map((candidate) => candidate.finishReason).filter((value) => value !== void 0)),
+		finishMessages: compactArray(candidates.map((candidate) => candidate.finishMessage).filter((value) => value !== void 0)),
+		safetyRatings: compactArray(candidates.flatMap((candidate) => candidate.safetyRatings ?? [])),
+		promptFeedback: raw.promptFeedback,
+		usageMetadata: raw.usageMetadata,
+		modelVersion: raw.modelVersion,
+		responseId: raw.responseId,
+		candidateCount: candidates.length,
+		candidates: compactArray(candidates.map((candidate) => compactObject({
+			index: candidate.index,
+			finishReason: candidate.finishReason,
+			finishMessage: candidate.finishMessage,
+			safetyRatings: candidate.safetyRatings,
+			citationMetadata: candidate.citationMetadata,
+			groundingMetadata: candidate.groundingMetadata,
+			avgLogprobs: candidate.avgLogprobs,
+			contentRole: candidate.content?.role,
+			partCount: candidate.content?.parts?.length
+		})))
+	});
+}
+function appendGeminiFileDataOutput(output, fileData) {
+	if (typeof fileData?.fileUri !== "string" || !fileData.fileUri) return false;
+	const mediaType = typeof fileData.mimeType === "string" ? fileData.mimeType : "image/png";
+	output.push({
+		type: "image",
+		source: {
+			type: "url",
+			url: fileData.fileUri
+		},
+		meta: { mediaType }
+	});
+	return true;
+}
+function appendGeminiPartOutput(output, part) {
+	if (typeof part.text === "string" && part.text.trim()) {
+		const image = extractMarkdownDataUriImage(part.text);
+		if (image) {
+			output.push(image);
+			return;
+		}
+		output.push({
+			type: "text",
+			text: part.text
+		});
+		return;
+	}
+	if (part.inlineData && typeof part.inlineData.data === "string" && part.inlineData.data) {
+		output.push({
+			type: "image",
+			source: {
+				type: "base64",
+				mediaType: typeof part.inlineData.mimeType === "string" ? part.inlineData.mimeType : "image/png",
+				data: part.inlineData.data
+			}
+		});
+		return;
+	}
+	appendGeminiFileDataOutput(output, part.fileData);
+}
+async function geminiGenerateContentAdapter(input) {
+	const prompt = mergeTextBlocks(input.declaration, input.request.content);
+	if (!prompt) throw new GenerationValidationError("Prompt text is required");
+	const imageParts = await Promise.all(input.request.content.filter((block) => block.type === "image").map(async (block) => sourceToInlineData(input, await input.context.resolveSource(block.source))));
+	const generationConfig = { responseModalities: ["IMAGE"] };
+	const aspectRatio = input.parameters.aspect_ratio;
+	const imageSize = input.parameters.image_size;
+	if (typeof aspectRatio === "string" || typeof imageSize === "string") {
+		const image = {};
+		if (typeof aspectRatio === "string") image.aspectRatio = aspectRatio;
+		if (typeof imageSize === "string") image.imageSize = imageSize;
+		generationConfig.responseFormat = { image };
+	}
+	const payload = {
+		contents: [{ parts: [{ text: prompt }, ...imageParts] }],
+		generationConfig
+	};
+	const response = await fetchWithTimeout(input.context.fetch, joinUrl(input.context.baseUrl, `/v1beta/models/${encodeURIComponent(input.declaration.model)}:generateContent`), {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${input.context.apiKey}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify(payload)
+	}, REQUEST_TIMEOUT_MS$2);
+	if (!response.ok) {
+		const body = await response.text().catch(() => response.statusText);
+		throw new GenerationProviderError("Gemini generation provider request failed", {
+			status: response.status,
+			body
+		});
+	}
+	const raw = await response.json();
+	const output = [];
+	for (const candidate of raw.candidates ?? []) for (const part of candidate.content?.parts ?? []) appendGeminiPartOutput(output, part);
+	if (output.length === 0) throw new GenerationProviderError("Gemini generation returned no output", { details: collectGeminiNoOutputDetails(raw) });
+	return output;
+}
+
+//#endregion
+//#region src/adapters/openai-images.ts
+const REQUEST_TIMEOUT_MS$1 = 3e5;
+function collectOpenAiImagesNoOutputDetails(raw) {
+	const data = raw.data ?? [];
+	return compactObject({
+		created: raw.created,
+		usage: raw.usage,
+		background: raw.background,
+		outputFormat: raw.output_format,
+		quality: raw.quality,
+		size: raw.size,
+		dataCount: data.length,
+		data: compactArray(data.map((item) => compactObject({
+			hasUrl: typeof item.url === "string" && item.url.length > 0,
+			hasBase64Json: typeof item.b64_json === "string" && item.b64_json.length > 0,
+			revisedPrompt: item.revised_prompt
+		})))
+	});
+}
+async function openAiImagesAdapter(input) {
+	const prompt = mergeTextBlocks(input.declaration, input.request.content);
+	if (!prompt) throw new GenerationValidationError("Prompt text is required");
+	const images = await Promise.all(input.request.content.filter((block) => block.type === "image").map((block) => input.context.resolveSource(block.source)));
+	const payload = {
+		model: input.declaration.model,
+		prompt,
+		...input.parameters
+	};
+	if (images.length > 0) payload.image = images;
+	const response = await fetchWithTimeout(input.context.fetch, joinUrl(input.context.baseUrl, "/v1/images/generations"), {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${input.context.apiKey}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify(payload)
+	}, REQUEST_TIMEOUT_MS$1);
+	if (!response.ok) {
+		const body = await response.text().catch(() => response.statusText);
+		throw new GenerationProviderError("Image generation provider request failed", {
+			status: response.status,
+			body
+		});
+	}
+	const raw = await response.json();
+	const output = [];
+	for (const item of raw.data ?? []) {
+		if (typeof item.url === "string" && item.url) output.push({
+			type: "image",
+			source: {
+				type: "url",
+				url: item.url
+			}
+		});
+		if (typeof item.b64_json === "string" && item.b64_json) output.push({
+			type: "image",
+			source: {
+				type: "base64",
+				mediaType: "image/png",
+				data: item.b64_json
+			}
+		});
+		if (typeof item.revised_prompt === "string" && item.revised_prompt.trim()) output.push({
+			type: "text",
+			text: item.revised_prompt,
+			meta: { role: "revised_prompt" }
+		});
+	}
+	if (output.length === 0) throw new GenerationProviderError("Image generation returned no output", { details: collectOpenAiImagesNoOutputDetails(raw) });
+	return output;
+}
+
+//#endregion
+//#region src/adapters/suno-tasks.ts
+const REQUEST_TIMEOUT_MS = 6e4;
+const DEFAULT_POLL_INTERVAL_SEC = 5;
+const DEFAULT_MAX_WAIT_SEC = 600;
+const DEFAULT_MUSIC_VERSION = "chirp-v5-5";
+const OPERATION_PATHS = {
+	music: {
+		path: "/suno/submit/music",
+		poll: true,
+		defaultMusicVersion: true,
+		textField: "prompt"
+	},
+	lyrics: {
+		path: "/suno/submit/lyrics",
+		poll: true,
+		textField: "prompt",
+		requireText: true
+	},
+	concat: {
+		path: "/suno/submit/concat",
+		poll: true
+	},
+	upsample_tags: {
+		path: "/suno/submit/upsample-tags",
+		poll: false,
+		textField: "original_tags",
+		requireText: true
+	},
+	upload_audio: {
+		path: "/suno/uploads/audio",
+		poll: true
+	}
+};
+const FINAL_SUCCESS_STATUSES = new Set([
+	"success",
+	"succeeded",
+	"completed"
+]);
+const FINAL_FAILURE_STATUSES = new Set([
+	"failure",
+	"failed",
+	"error",
+	"cancelled",
+	"canceled",
+	"expired"
+]);
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRecord$1(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function asString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function asInteger(value, fallback) {
+	return typeof value === "number" && Number.isInteger(value) ? value : fallback;
+}
+function successCode(value) {
+	const code = String(value ?? "").trim().toLowerCase();
+	return code === "success" || code === "200" || code === "0";
+}
+function requireSuccess(response, fallbackMessage) {
+	if (!successCode(response.code)) throw new GenerationProviderError(fallbackMessage, { details: {
+		code: response.code,
+		message: response.message,
+		data: response.data
+	} });
+	return response.data;
+}
+function extractTaskId(value) {
+	if (typeof value === "string" && value.trim()) return value.trim();
+	if (!isRecord$1(value)) return void 0;
+	for (const key of [
+		"task_id",
+		"id",
+		"taskBatchId"
+	]) {
+		const taskId = asString(value[key]);
+		if (taskId) return taskId;
+	}
+}
+function normalizeStatus(value) {
+	return String(value ?? "").trim().toLowerCase();
+}
+function normalizeTask(operation, data) {
+	if (Array.isArray(data)) return data.length > 0 ? normalizeTask(operation, data[0]) : null;
+	if (!isRecord$1(data)) return null;
+	if ("status" in data || "task_id" in data) return data;
+	if (Array.isArray(data.data) && data.data.length > 0) return normalizeTask(operation, data.data[0]);
+	return {
+		action: operation,
+		status: "SUCCESS",
+		data
+	};
+}
+function getOperation(input) {
+	const operation = asString(input.parameters.operation) ?? "music";
+	if (!OPERATION_PATHS[operation]) throw new GenerationValidationError(`Unsupported Suno operation: ${operation}`);
+	return operation;
+}
+async function buildPayload(input, operation) {
+	const payload = { ...input.meta };
+	const config = OPERATION_PATHS[operation];
+	const prompt = mergeTextBlocks(input.declaration, input.request.content);
+	if (prompt && config?.textField && payload[config.textField] === void 0) payload[config.textField] = prompt;
+	if (config?.textField && config.textField !== "prompt" && payload[config.textField] === void 0 && payload.prompt !== void 0) payload[config.textField] = payload.prompt;
+	const audioBlock = input.request.content.find((block) => block.type === "audio");
+	if (audioBlock && payload.url === void 0) payload.url = await input.context.resolveSource(audioBlock.source);
+	const imageBlock = input.request.content.find((block) => block.type === "image");
+	if (imageBlock && payload.image_url === void 0) payload.image_url = await input.context.resolveSource(imageBlock.source);
+	const videoBlock = input.request.content.find((block) => block.type === "video");
+	if (videoBlock && payload.video_url === void 0) payload.video_url = await input.context.resolveSource(videoBlock.source);
+	normalizeMusicTaskPayload(input, operation, payload);
+	if (config?.defaultMusicVersion && payload.mv === void 0 && payload.model_name === void 0) payload.mv = DEFAULT_MUSIC_VERSION;
+	validateSunoPayload(operation, payload);
+	return payload;
+}
+function contentCount(content, type) {
+	return content.filter((block) => block.type === type).length;
+}
+function normalizeMusicTaskPayload(input, operation, payload) {
+	if (operation !== "music") return;
+	const taskField = input.declaration.meta?.taskField ?? "task";
+	const task = asString(payload[taskField]);
+	if (!task) return;
+	const taskVariant = input.declaration.meta?.taskVariants?.[task];
+	if (!taskVariant) throw new GenerationValidationError(`Unsupported Suno music task: ${task}`);
+	for (const key of taskVariant.required ?? []) if (payload[key] === void 0 || payload[key] === null || payload[key] === "") throw new GenerationValidationError(`Suno task ${task} requires meta.${key}`);
+	for (const type of taskVariant.requiredContent ?? []) if (contentCount(input.request.content, type) === 0) throw new GenerationValidationError(`Suno task ${task} requires ${type} content`);
+	if (taskVariant.sendTask === false) delete payload[taskField];
+}
+function validateSunoPayload(operation, payload) {
+	const config = OPERATION_PATHS[operation];
+	const task = asString(payload.task);
+	if (operation === "music" && task) {
+		if (task === "lyrics") throw new GenerationValidationError("Use operation=lyrics instead of task=lyrics");
+	}
+	if (config?.requireText && !asString(payload[config.textField ?? "prompt"])) throw new GenerationValidationError(`${config.textField ?? "prompt"} text is required`);
+	if (operation === "upload_audio" && !asString(payload.url)) throw new GenerationValidationError("Audio url is required for Suno upload_audio");
+	if (operation === "concat" && !asString(payload.clip_id)) throw new GenerationValidationError("clip_id is required for Suno concat");
+}
+async function requestJson(input, path, init) {
+	const response = await fetchWithTimeout(input.context.fetch, joinUrl(input.context.baseUrl, path), {
+		...init,
+		headers: {
+			Authorization: `Bearer ${input.context.apiKey}`,
+			"Content-Type": "application/json",
+			...init.headers
+		}
+	}, REQUEST_TIMEOUT_MS);
+	const body = await response.text();
+	let parsed;
+	try {
+		parsed = body ? JSON.parse(body) : {};
+	} catch {
+		throw new GenerationProviderError("Suno provider returned invalid JSON", {
+			status: response.status,
+			body
+		});
+	}
+	if (!response.ok) throw new GenerationProviderError("Suno provider request failed", {
+		status: response.status,
+		details: { body: parsed }
+	});
+	return parsed;
+}
+function appendUrlBlock(output, type, url, meta) {
+	const value = asString(url);
+	if (!value) return;
+	output.push({
+		type,
+		source: {
+			type: "url",
+			url: value
+		},
+		meta: compactObject(meta)
+	});
+}
+function appendSunoContent(output, value, meta = {}) {
+	if (Array.isArray(value)) {
+		for (const item of value) appendSunoContent(output, item, meta);
+		return;
+	}
+	if (!isRecord$1(value)) return;
+	if (isRecord$1(value.clips)) for (const clip of Object.values(value.clips)) appendSunoContent(output, clip, meta);
+	if (Array.isArray(value.items)) for (const item of value.items) appendSunoContent(output, item, meta);
+	const itemMeta = compactObject({
+		...meta,
+		id: value.id,
+		clip_id: value.clipId ?? value.clip_id ?? meta.clip_id,
+		task_id: value.task_id ?? value.taskId ?? meta.task_id,
+		title: value.title,
+		status: value.status ?? meta.status,
+		model: value.model_name ?? value.modelName,
+		duration: value.duration ?? (isRecord$1(value.metadata) ? value.metadata.duration : void 0),
+		tags: value.tags ?? (isRecord$1(value.metadata) ? value.metadata.tags : void 0),
+		prompt: value.prompt ?? (isRecord$1(value.metadata) ? value.metadata.prompt : void 0),
+		progress: value.progress ?? meta.progress,
+		progress_message: value.progressMsg ?? value.progress_msg,
+		task_batch_id: value.taskBatchId ?? value.task_batch_id,
+		continue_clip_id: value.continueClipId ?? value.continue_clip_id,
+		input_type: value.inputType ?? value.input_type,
+		make_instrumental: value.makeInstrumental ?? value.make_instrumental,
+		created_at: value.createTime ?? value.created_at
+	});
+	appendUrlBlock(output, "audio", value.audio_url ?? value.audioUrl ?? value.cld2AudioUrl ?? value.cld2_audio_url, itemMeta);
+	appendUrlBlock(output, "audio", value.vocal_audio_url ?? value.vocalAudioUrl, itemMeta);
+	appendUrlBlock(output, "audio", value.instrumental_audio_url ?? value.instrumentalAudioUrl, itemMeta);
+	appendUrlBlock(output, "audio", value.source_audio_url ?? value.sourceAudioUrl, itemMeta);
+	appendUrlBlock(output, "video", value.video_url ?? value.videoUrl ?? value.cld2VideoUrl ?? value.cld2_video_url, itemMeta);
+	appendUrlBlock(output, "image", value.image_large_url ?? value.image_url ?? value.imageUrl ?? value.cld2ImageUrl ?? value.cld2_image_url, itemMeta);
+	const text = asString(value.upsampled_tags) ?? asString(value.text) ?? asString(value.lyrics);
+	if (text) output.push({
+		type: "text",
+		text,
+		meta: itemMeta
+	});
+	if (isRecord$1(value.data)) appendSunoContent(output, value.data, itemMeta);
+}
+function buildImmediateResult(operation, data, raw) {
+	const output = [];
+	const metadata = compactObject({
+		operation,
+		raw
+	});
+	appendSunoContent(output, data, metadata);
+	if (output.length > 0) return output;
+	const value = extractTaskId(data) ?? asString(data);
+	if (value) output.push({
+		type: "text",
+		text: value,
+		meta: metadata
+	});
+	return requireSunoOutput(output, "Suno provider returned no output", {
+		operation,
+		raw
+	});
+}
+function requireSunoOutput(output, message, details) {
+	if (output.length === 0) throw new GenerationProviderError(message, { details });
+	return output;
+}
+function buildResult(operation, task, raw) {
+	const output = [];
+	const metadata = compactObject({
+		operation,
+		task_id: task.task_id,
+		action: task.action,
+		status: task.status,
+		fail_reason: task.fail_reason,
+		progress: task.progress,
+		submit_time: task.submit_time,
+		start_time: task.start_time,
+		finish_time: task.finish_time,
+		raw
+	});
+	appendSunoContent(output, task.data, metadata);
+	appendUrlBlock(output, "audio", task.result_url, metadata);
+	return requireSunoOutput(output, "Suno task succeeded but returned no output", {
+		operation,
+		task,
+		raw
+	});
+}
+async function pollSunoTask(input, operation, taskId, pollIntervalSec, maxWaitSec) {
+	const startedAt = Date.now();
+	while (Date.now() - startedAt <= maxWaitSec * 1e3) {
+		await sleep(pollIntervalSec * 1e3);
+		let raw;
+		try {
+			raw = await requestJson(input, `/suno/fetch/${encodeURIComponent(taskId)}`, { method: "GET" });
+		} catch (error) {
+			if (error instanceof GenerationProviderError) throw error;
+			continue;
+		}
+		const data = requireSuccess(raw, "Suno task fetch failed");
+		const task = normalizeTask(operation, data);
+		if (!task) throw new GenerationProviderError("Suno task fetch returned invalid task data", { details: { data } });
+		const status = normalizeStatus(task.status);
+		if (FINAL_SUCCESS_STATUSES.has(status)) return buildResult(operation, task, data);
+		if (FINAL_FAILURE_STATUSES.has(status)) throw new GenerationProviderError("Suno task failed", { details: {
+			task_id: taskId,
+			status: task.status,
+			fail_reason: task.fail_reason
+		} });
+	}
+	throw new GenerationTimeoutError("Timed out waiting for Suno task", {
+		task_id: taskId,
+		operation
+	});
+}
+async function sunoTasksAdapter(input) {
+	const operation = getOperation(input);
+	const payload = await buildPayload(input, operation);
+	const config = OPERATION_PATHS[operation];
+	if (!config) throw new GenerationValidationError(`Unsupported Suno operation: ${operation}`);
+	const raw = await requestJson(input, config.path, {
+		method: "POST",
+		body: JSON.stringify(payload)
+	});
+	const data = requireSuccess(raw, "Suno task submit failed");
+	if (!config.poll) return buildImmediateResult(operation, data, raw);
+	const taskId = extractTaskId(data);
+	if (!taskId) return buildImmediateResult(operation, data, raw);
+	return pollSunoTask(input, operation, taskId, asInteger(input.parameters.poll_interval, DEFAULT_POLL_INTERVAL_SEC), asInteger(input.parameters.max_wait, DEFAULT_MAX_WAIT_SEC));
+}
+
+//#endregion
+//#region src/adapters/index.ts
+const builtinGenerationAdapters = {
+	"ark.videoGenerations": arkVideoGenerationsAdapter,
+	"gemini.generateContent": geminiGenerateContentAdapter,
+	"openai.images": openAiImagesAdapter,
+	"suno.tasks": sunoTasksAdapter
+};
+function getGenerationAdapter(type, adapters = {}) {
+	const adapter = adapters[type] ?? builtinGenerationAdapters[type];
+	if (!adapter) throw new GenerationUnsupportedAdapterError(type);
+	return adapter;
+}
+
+//#endregion
+//#region src/config.ts
+const DECLARATION_EXTENSIONS = new Set([
+	".yaml",
+	".yml",
+	".json"
+]);
+function isRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isParameterSpec(value) {
+	if (!isRecord(value)) return false;
+	return [
+		"string",
+		"number",
+		"integer",
+		"boolean"
+	].includes(String(value.type));
+}
+function isMetaFieldSpec(value) {
+	if (!isRecord(value)) return false;
+	return isParameterSpec(value) || String(value.type) === "object";
+}
+function isMetaTaskVariantSpec(value) {
+	if (!isRecord(value)) return false;
+	return (value.description === void 0 || typeof value.description === "string") && (value.required === void 0 || Array.isArray(value.required) && value.required.every((item) => typeof item === "string")) && (value.requiredContent === void 0 || Array.isArray(value.requiredContent) && value.requiredContent.every((item) => typeof item === "string")) && (value.sendTask === void 0 || typeof value.sendTask === "boolean");
+}
+function isMetaSpec(value) {
+	if (!isRecord(value)) return false;
+	return (value.fields === void 0 || isRecord(value.fields) && Object.values(value.fields).every((field) => isMetaFieldSpec(field))) && (value.taskField === void 0 || typeof value.taskField === "string") && (value.taskVariants === void 0 || isRecord(value.taskVariants) && Object.values(value.taskVariants).every((variant) => isMetaTaskVariantSpec(variant)));
+}
+function isGenerationModelDeclaration(value) {
+	if (!isRecord(value)) return false;
+	const adapter = value.adapter;
+	const content = value.content;
+	const parameters = value.parameters;
+	const meta = value.meta;
+	const examples = value.examples;
+	return value.schema === MODEL_SCHEMA && typeof value.model === "string" && value.model.trim().length > 0 && (value.allowUnknownParameters === void 0 || typeof value.allowUnknownParameters === "boolean") && isRecord(adapter) && typeof adapter.type === "string" && isRecord(content) && Array.isArray(content.input) && (parameters === void 0 || isRecord(parameters) && Object.values(parameters).every(isParameterSpec)) && (meta === void 0 || isMetaSpec(meta)) && (examples === void 0 || Array.isArray(examples));
+}
+function parseGenerationModelDeclaration(rawText, filePath = "model.yaml") {
+	const parsed = extname(filePath) === ".json" ? JSON.parse(rawText) : parse(rawText);
+	if (!isGenerationModelDeclaration(parsed)) throw new GenerationConfigError(`Invalid model declaration: ${filePath}`);
+	return parsed;
+}
+function stringifyGenerationModelDeclaration(declaration, options = {}) {
+	const value = cloneJson(declaration);
+	if (options.format === "json") return `${JSON.stringify(value, null, 2)}\n`;
+	return stringify(value, { lineWidth: 120 });
+}
+async function readGenerationModelDeclaration(filePath) {
+	return parseGenerationModelDeclaration(await readFile(filePath, "utf-8"), filePath);
+}
+async function readGenerationModelDeclarationsFromFiles(filePaths) {
+	return mergeGenerationModelDeclarations(await Promise.all(filePaths.map((filePath) => readGenerationModelDeclaration(filePath))));
+}
+async function readGenerationModelDeclarationsFromDirectory(directory) {
+	return readGenerationModelDeclarationsFromFiles((await readdir(directory)).filter((entry) => DECLARATION_EXTENSIONS.has(extname(entry))).sort().map((entry) => join(directory, entry)));
+}
+function mergeGenerationModelDeclarations(declarations) {
+	const byModel = /* @__PURE__ */ new Map();
+	for (const declaration of declarations) byModel.set(declaration.model, declaration);
+	return [...byModel.values()].sort((a, b) => a.model.localeCompare(b.model));
+}
+async function writeGenerationModelDeclaration(declaration, filePath, options = {}) {
+	await writeFile(filePath, stringifyGenerationModelDeclaration(declaration, options));
+}
+async function writeGenerationModelDeclarations(declarations, directory, options = {}) {
+	await mkdir(directory, { recursive: true });
+	const ext = options.format === "json" ? "json" : "yaml";
+	await Promise.all(declarations.map((declaration) => writeGenerationModelDeclaration(declaration, join(directory, `${slugifyFileName(declaration.model)}.${ext}`), options)));
+}
+
+//#endregion
+//#region src/source.ts
+const defaultGenerationSourceResolver = (source) => {
+	switch (source.type) {
+		case "url": return source.url;
+		case "base64": return `data:${source.mediaType};base64,${source.data}`;
+	}
+};
+
+//#endregion
+//#region src/client.ts
+const DEFAULT_BASE_URL = "https://router.neta.art";
+function redactDebugEvent(value) {
+	if (Array.isArray(value)) return value.map((item) => redactDebugEvent(item));
+	if (!value || typeof value !== "object") return value;
+	const output = {};
+	for (const [key, child] of Object.entries(value)) if (/^(authorization|api[-_]?key|token|b64_json|thoughtSignature)$/i.test(key) || key === "data") output[key] = "[REDACTED]";
+	else output[key] = redactDebugEvent(child);
+	return output;
+}
+function defaultDebugLogger(event) {
+	console.error(JSON.stringify(event, null, 2));
+}
+function resolveDebugConfig(debug) {
+	if (!debug) return void 0;
+	if (debug === true) return {
+		enabled: true,
+		includeSensitive: false,
+		includeResponseBody: true,
+		logger: (event) => defaultDebugLogger(redactDebugEvent(event))
+	};
+	if (!debug.enabled) return void 0;
+	const includeSensitive = debug.includeSensitive ?? false;
+	const logger = debug.logger ?? defaultDebugLogger;
+	return {
+		enabled: true,
+		includeSensitive,
+		includeResponseBody: debug.includeResponseBody ?? true,
+		logger: (event) => logger(includeSensitive ? event : redactDebugEvent(event))
+	};
+}
+function resolveModels(options) {
+	const models = [...options.includeBuiltinModels ?? !options.models ? builtinGenerationModels : [], ...options.models ?? []];
+	const byModel = /* @__PURE__ */ new Map();
+	for (const model of models) byModel.set(model.model, cloneJson(model));
+	return [...byModel.values()].sort((a, b) => a.model.localeCompare(b.model));
+}
+function createGenerationClient(options = {}) {
+	const models = resolveModels(options);
+	const byModel = new Map(models.map((declaration) => [declaration.model, declaration]));
+	const fetchFn = options.fetch ?? globalThis.fetch;
+	if (!fetchFn) throw new GenerationConfigError("A fetch implementation is required");
+	const debug = resolveDebugConfig(options.debug);
+	const adapterFetch = debug ? createDebugFetch(fetchFn, debug) : fetchFn;
+	function requireModel(model) {
+		const declaration = byModel.get(model);
+		if (!declaration) throw new GenerationConfigError(`Generation model is unavailable: ${model}`);
+		return declaration;
+	}
+	return {
+		validate(request) {
+			const declaration = requireModel(request.model);
+			validateGenerationContent(declaration, request.content);
+			const parameters = resolveGenerationParameters(declaration, request.parameters);
+			const meta = resolveGenerationMeta(declaration, mergeGenerationMeta({
+				...request.metadata ?? {},
+				...request.meta ?? {}
+			}, request.content), request.content);
+			return {
+				declaration: cloneJson(declaration),
+				request: cloneJson(request),
+				parameters,
+				meta
+			};
+		},
+		async generate(request) {
+			const resolved = this.validate(request);
+			const apiKey = request.apiKey ?? options.apiKey;
+			if (!apiKey) throw new GenerationConfigError("apiKey is required");
+			return getGenerationAdapter(resolved.declaration.adapter.type, options.adapters)({
+				...resolved,
+				context: {
+					apiKey,
+					baseUrl: request.baseUrl ?? options.baseUrl ?? DEFAULT_BASE_URL,
+					fetch: adapterFetch,
+					resolveSource: options.sourceResolver ?? defaultGenerationSourceResolver
+				}
+			});
+		},
+		listModels() {
+			return cloneJson(models);
+		},
+		getModel(model) {
+			const declaration = byModel.get(model);
+			return declaration ? cloneJson(declaration) : null;
+		},
+		stringifyModelConfig(model, stringifyOptions = {}) {
+			return stringifyGenerationModelDeclaration(requireModel(model), stringifyOptions);
+		},
+		exportModelConfig(model, filePath) {
+			return writeGenerationModelDeclaration(requireModel(model), filePath);
+		},
+		exportModelConfigs(directory) {
+			return writeGenerationModelDeclarations(models, directory);
+		}
+	};
+}
+async function createGenerationClientFromFiles(filePaths, options = {}) {
+	const models = await readGenerationModelDeclarationsFromFiles(filePaths);
+	return createGenerationClient({
+		...options,
+		models,
+		includeBuiltinModels: options.includeBuiltinModels ?? true
+	});
+}
+async function createGenerationClientFromDirectory(directory, options = {}) {
+	const models = await readGenerationModelDeclarationsFromDirectory(directory);
+	return createGenerationClient({
+		...options,
+		models,
+		includeBuiltinModels: options.includeBuiltinModels ?? true
+	});
+}
+async function createGenerationClientFromFile(filePath, options = {}) {
+	return createGenerationClientFromFiles([filePath], options);
+}
+
+//#endregion
+//#region src/export-config.ts
+function stringifyBuiltinModelConfig(model, options = {}) {
+	const declaration = getBuiltinGenerationModel(model);
+	if (!declaration) throw new GenerationConfigError(`Built-in model is unavailable: ${model}`);
+	return stringifyGenerationModelDeclaration(declaration, options);
+}
+async function exportBuiltinModelConfig(model, filePath) {
+	const declaration = getBuiltinGenerationModel(model);
+	if (!declaration) throw new GenerationConfigError(`Built-in model is unavailable: ${model}`);
+	await writeGenerationModelDeclaration(declaration, filePath);
+}
+async function exportBuiltinModelConfigs(directory) {
+	await writeGenerationModelDeclarations(listBuiltinGenerationModels(), directory);
+}
+
+//#endregion
+export { GenerationError as A, arkVideoGenerationsAdapter as C, resolveGenerationParameters as D, resolveGenerationMeta as E, GenerationTimeoutError as M, GenerationUnsupportedAdapterError as N, validateGenerationContent as O, GenerationValidationError as P, geminiGenerateContentAdapter as S, mergeTextBlocks as T, writeGenerationModelDeclarations as _, createGenerationClientFromDirectory as a, sunoTasksAdapter as b, defaultGenerationSourceResolver as c, parseGenerationModelDeclaration as d, readGenerationModelDeclaration as f, writeGenerationModelDeclaration as g, stringifyGenerationModelDeclaration as h, createGenerationClient as i, GenerationProviderError as j, GenerationConfigError as k, isGenerationModelDeclaration as l, readGenerationModelDeclarationsFromFiles as m, exportBuiltinModelConfigs as n, createGenerationClientFromFile as o, readGenerationModelDeclarationsFromDirectory as p, stringifyBuiltinModelConfig as r, createGenerationClientFromFiles as s, exportBuiltinModelConfig as t, mergeGenerationModelDeclarations as u, builtinGenerationAdapters as v, mergeGenerationMeta as w, openAiImagesAdapter as x, getGenerationAdapter as y };
+//# sourceMappingURL=export-config-D8By2_r7.js.map