@neta-art/generation 0.1.1 → 0.1.2

package/dist/export-config-BPnZYpmN.js

@@ -0,0 +1,884 @@
+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-B1AheaEa.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 = {};
+	for (const key of Object.keys(parameters ?? {})) if (!specs[key]) throw new GenerationValidationError(`Unknown parameter: ${key}`);
+	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;
+		}
+		switch (spec.type) {
+			case "string":
+				if (typeof value !== "string") throw new GenerationValidationError(`Parameter ${key} must be a string`);
+				if (spec.enum && !spec.enum.includes(value)) throw new GenerationValidationError(`Parameter ${key} must be one of: ${spec.enum.join(", ")}`);
+				break;
+			case "number":
+				if (typeof value !== "number" || !Number.isFinite(value)) throw new GenerationValidationError(`Parameter ${key} must be a number`);
+				if (spec.min !== void 0 && value < spec.min) throw new GenerationValidationError(`Parameter ${key} must be >= ${spec.min}`);
+				if (spec.max !== void 0 && value > spec.max) throw new GenerationValidationError(`Parameter ${key} must be <= ${spec.max}`);
+				break;
+			case "integer":
+				if (typeof value !== "number" || !Number.isInteger(value)) throw new GenerationValidationError(`Parameter ${key} must be an integer`);
+				if (spec.min !== void 0 && value < spec.min) throw new GenerationValidationError(`Parameter ${key} must be >= ${spec.min}`);
+				if (spec.max !== void 0 && value > spec.max) throw new GenerationValidationError(`Parameter ${key} must be <= ${spec.max}`);
+				break;
+			case "boolean":
+				if (typeof value !== "boolean") throw new GenerationValidationError(`Parameter ${key} must be a boolean`);
+				break;
+		}
+		resolved[key] = value;
+	}
+	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$2 = 6e4;
+const DEFAULT_POLL_INTERVAL_SEC = 2;
+const DEFAULT_MAX_WAIT_SEC = 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(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function asString(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(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(response) {
+	const taskId = asString(response.task_id) ?? asString(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(asString(native?.status) ?? asString(wrapper.status) ?? "unknown");
+		const videoUrl = asString(wrapper.result_url) ?? asString(native?.content?.video_url);
+		const lastFrameUrl = asString(wrapper.first_frame) ?? asString(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(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$2);
+	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(input.parameters.resolution) ?? "720p";
+	const aspectRatio = asString(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);
+	const maxWaitSec = getIntegerParameter(input.parameters, "max_wait", DEFAULT_MAX_WAIT_SEC);
+	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(await requestJson(input, "/v1/video/generations", {
+		method: "POST",
+		body: JSON.stringify(payload)
+	}));
+	const startedAt = Date.now();
+	while (Date.now() - startedAt <= maxWaitSec * 1e3) {
+		await sleep(pollIntervalSec * 1e3);
+		const rawStatus = await requestJson(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$1 = 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$1);
+	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 = 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);
+	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/index.ts
+const builtinGenerationAdapters = {
+	"ark.videoGenerations": arkVideoGenerationsAdapter,
+	"gemini.generateContent": geminiGenerateContentAdapter,
+	"openai.images": openAiImagesAdapter
+};
+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 isGenerationModelDeclaration(value) {
+	if (!isRecord(value)) return false;
+	const adapter = value.adapter;
+	const content = value.content;
+	const parameters = value.parameters;
+	const examples = value.examples;
+	return value.schema === MODEL_SCHEMA && typeof value.model === "string" && value.model.trim().length > 0 && isRecord(adapter) && typeof adapter.type === "string" && isRecord(content) && Array.isArray(content.input) && (parameters === void 0 || isRecord(parameters) && Object.values(parameters).every(isParameterSpec)) && (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);
+			return {
+				declaration: cloneJson(declaration),
+				request: cloneJson(request),
+				parameters
+			};
+		},
+		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 { GenerationUnsupportedAdapterError as A, mergeTextBlocks as C, GenerationError as D, GenerationConfigError as E, GenerationProviderError as O, arkVideoGenerationsAdapter as S, validateGenerationContent as T, writeGenerationModelDeclarations as _, createGenerationClientFromDirectory as a, openAiImagesAdapter as b, defaultGenerationSourceResolver as c, parseGenerationModelDeclaration as d, readGenerationModelDeclaration as f, writeGenerationModelDeclaration as g, stringifyGenerationModelDeclaration as h, createGenerationClient as i, GenerationValidationError as j, GenerationTimeoutError 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, resolveGenerationParameters as w, geminiGenerateContentAdapter as x, getGenerationAdapter as y };
+//# sourceMappingURL=export-config-BPnZYpmN.js.map