@neta-art/generation 0.1.0

package/dist/index.js

@@ -0,0 +1,602 @@
+import { a as getBlockMeta, i as cloneJson, n as getBuiltinGenerationModel, r as listBuiltinGenerationModels, s as MODEL_SCHEMA, t as builtinGenerationModels } from "./builtins-hmNIcYXN.js";
+import { _ as GenerationUnsupportedAdapterError, a as mergeGenerationModelDeclarations, c as readGenerationModelDeclarationsFromDirectory, d as writeGenerationModelDeclaration, f as writeGenerationModelDeclarations, g as GenerationTimeoutError, h as GenerationProviderError, i as isGenerationModelDeclaration, l as readGenerationModelDeclarationsFromFiles, m as GenerationError, n as exportBuiltinModelConfigs, o as parseGenerationModelDeclaration, p as GenerationConfigError, r as stringifyBuiltinModelConfig, s as readGenerationModelDeclaration, t as exportBuiltinModelConfig, u as stringifyGenerationModelDeclaration, v as GenerationValidationError } from "./export-config-ZxwkQoZ6.js";
+
+//#region src/http.ts
+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 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");
+	return taskId;
+}
+function normalizeTaskStatus(response) {
+	if (response.data) {
+		const wrapper = response.data;
+		const native = wrapper.data;
+		const status = (asString(native?.status) ?? asString(wrapper.status) ?? "unknown").toLowerCase();
+		const videoUrl = asString(wrapper.result_url) ?? asString(native?.content?.video_url);
+		const lastFrameUrl = asString(native?.content?.last_frame_url);
+		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: (asString(response.status) ?? "unknown").toLowerCase(),
+		videoUrl: asString(response.url),
+		lastFrameUrl: asString(response.last_frame_url),
+		metadata: response.metadata && typeof response.metadata === "object" ? response.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");
+			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 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;
+	}
+	const inline = part.inline_data;
+	if (!inline || typeof inline.data !== "string" || !inline.data) return;
+	const mediaType = typeof inline.mime_type === "string" ? inline.mime_type : typeof inline.mimeType === "string" ? inline.mimeType : "image/png";
+	output.push({
+		type: "image",
+		source: {
+			type: "base64",
+			mediaType,
+			data: inline.data
+		}
+	});
+}
+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");
+	return output;
+}
+
+//#endregion
+//#region src/adapters/openai-images.ts
+const REQUEST_TIMEOUT_MS = 3e5;
+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.revised_prompt === "string" && item.revised_prompt.trim()) output.push({
+			type: "text",
+			text: item.revised_prompt,
+			meta: { role: "revised_prompt" }
+		});
+	}
+	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/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 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");
+	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: fetchFn,
+					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
+export { GenerationConfigError, GenerationError, GenerationProviderError, GenerationTimeoutError, GenerationUnsupportedAdapterError, GenerationValidationError, MODEL_SCHEMA, arkVideoGenerationsAdapter, builtinGenerationAdapters, builtinGenerationModels, createGenerationClient, createGenerationClientFromDirectory, createGenerationClientFromFile, createGenerationClientFromFiles, defaultGenerationSourceResolver, exportBuiltinModelConfig, exportBuiltinModelConfigs, geminiGenerateContentAdapter, getBuiltinGenerationModel, getGenerationAdapter, isGenerationModelDeclaration, listBuiltinGenerationModels, mergeGenerationModelDeclarations, mergeTextBlocks, openAiImagesAdapter, parseGenerationModelDeclaration, readGenerationModelDeclaration, readGenerationModelDeclarationsFromDirectory, readGenerationModelDeclarationsFromFiles, resolveGenerationParameters, stringifyBuiltinModelConfig, stringifyGenerationModelDeclaration, validateGenerationContent, writeGenerationModelDeclaration, writeGenerationModelDeclarations };
+//# sourceMappingURL=index.js.map