@neta-art/generation 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Neta Art
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,235 @@
+# @neta-art/generation
+
+A lightweight multimodal generation SDK with built-in model presets, model declaration files, and adapter-based provider calls.
+
+## Install
+
+```bash
+npm install @neta-art/generation
+```
+
+## Quick start
+
+```ts
+import { createGenerationClient } from "@neta-art/generation";
+
+const client = createGenerationClient({
+  apiKey: process.env.NETA_ROUTER_API_KEY!,
+});
+
+const output = await client.generate({
+  model: "gpt-image-2",
+  content: [
+    { type: "text", text: "a cinematic portrait of a robot florist, 35mm film" },
+  ],
+  parameters: {
+    size: "1024x1024",
+    quality: "high",
+  },
+});
+
+console.log(output);
+```
+
+`baseUrl` defaults to `https://router.neta.art`. Pass a different endpoint when needed:
+
+```ts
+const client = createGenerationClient({
+  apiKey: process.env.NETA_ROUTER_API_KEY!,
+  baseUrl: "https://router.neta.art",
+});
+```
+
+## Local testing with `.env`
+
+`.env` is ignored by Git. Copy `.env.example` to `.env` and fill in your router key:
+
+```bash
+cp .env.example .env
+```
+
+```dotenv
+NETA_ROUTER_API_KEY=your_api_key_here
+```
+
+Node.js does not load `.env` automatically for library code. The example scripts use Node's native `--env-file` flag through npm scripts:
+
+```bash
+pnpm example:basic-image
+pnpm example:image-editing
+pnpm example:text-to-video
+```
+
+## Built-in models
+
+- `gpt-image-2`
+- `gemini-3.1-flash-image-preview`
+- `seedance-2-0`
+- `seedance-2-0-fast`
+
+Built-in model declarations share the same client-level `apiKey` and `baseUrl`.
+
+## Image editing with a reference image
+
+```ts
+const output = await client.generate({
+  model: "gemini-3.1-flash-image-preview",
+  content: [
+    { type: "text", text: "turn this portrait into a watercolor illustration" },
+    { type: "image", source: { type: "url", url: "https://example.com/portrait.jpg" } },
+  ],
+  parameters: {
+    aspect_ratio: "3:4",
+    image_size: "2K",
+  },
+});
+```
+
+## Video generation
+
+```ts
+const output = await client.generate({
+  model: "seedance-2-0-fast",
+  content: [
+    { type: "text", text: "a cat playing piano in a cozy jazz club, cinematic lighting" },
+  ],
+  parameters: {
+    duration: 5,
+    resolution: "720p",
+    aspect_ratio: "16:9",
+  },
+});
+```
+
+Frame and reference-image video modes use `meta.role`:
+
+```ts
+await client.generate({
+  model: "seedance-2-0",
+  content: [
+    { type: "text", text: "create a smooth dramatic transition" },
+    { type: "image", source: { type: "url", url: "https://example.com/start.jpg" }, meta: { role: "first_frame" } },
+    { type: "image", source: { type: "url", url: "https://example.com/end.jpg" }, meta: { role: "last_frame" } },
+  ],
+});
+```
+
+## Load model declarations from files
+
+```ts
+import { createGenerationClientFromDirectory } from "@neta-art/generation";
+
+const client = await createGenerationClientFromDirectory("./models", {
+  apiKey: process.env.NETA_ROUTER_API_KEY!,
+});
+```
+
+Supported declaration formats:
+
+- `.yaml`
+- `.yml`
+- `.json`
+
+Custom declarations are merged with built-in models by default. If the same `model` exists, the custom declaration wins.
+
+## Export model declarations
+
+```ts
+import { exportBuiltinModelConfig } from "@neta-art/generation";
+
+await exportBuiltinModelConfig("gpt-image-2", "./gpt-image-2.yaml");
+```
+
+CLI:
+
+```bash
+neta-generation models list
+neta-generation models export gpt-image-2 --out ./gpt-image-2.yaml
+neta-generation models export-all --out ./models
+```
+
+## Model declaration schema
+
+```yaml
+schema: neta.generation.model.v1
+model: gpt-image-2
+title: GPT Image 2
+adapter:
+  type: openai.images
+content:
+  input:
+    - type: text
+      required: true
+      min: 1
+      max: 16
+      merge: newline
+    - type: image
+      required: false
+      max: 16
+      sources:
+        - url
+        - base64
+parameters:
+  size:
+    type: string
+    optional: true
+    default: 1024x1024
+```
+
+Adapter credentials are intentionally not stored in model declarations. Use client-level or request-level `apiKey` and `baseUrl` instead.
+
+## Content sources
+
+```ts
+type GenerationSource =
+  | { type: "url"; url: string }
+  | { type: "base64"; mediaType: string; data: string };
+```
+
+## Adapter types
+
+Built-in adapters:
+
+- `openai.images`
+- `gemini.generateContent`
+- `ark.videoGenerations`
+
+You can register custom adapters:
+
+```ts
+const client = createGenerationClient({
+  apiKey,
+  adapters: {
+    "custom.adapter": async (input) => {
+      return [];
+    },
+  },
+});
+```
+
+## Validation without provider calls
+
+```ts
+const resolved = client.validate({
+  model: "gpt-image-2",
+  content: [{ type: "text", text: "hello" }],
+});
+
+console.log(resolved.parameters);
+```
+
+## Error handling
+
+```ts
+import { GenerationValidationError, GenerationProviderError } from "@neta-art/generation";
+
+try {
+  await client.generate(request);
+} catch (error) {
+  if (error instanceof GenerationValidationError) {
+    console.error("Invalid request", error.message);
+  } else if (error instanceof GenerationProviderError) {
+    console.error("Provider failed", error.message);
+  }
+}
+```

package/dist/builtins-BuI-rf8X.d.ts

@@ -0,0 +1,137 @@
+//#region src/types.d.ts
+declare const MODEL_SCHEMA: "neta.generation.model.v1";
+type GenerationSource = {
+  type: "url";
+  url: string;
+} | {
+  type: "base64";
+  mediaType: string;
+  data: string;
+};
+type GenerationContentBlockMeta = Record<string, unknown>;
+type GenerationContentBlock = {
+  type: "text";
+  text: string;
+  meta?: GenerationContentBlockMeta;
+} | {
+  type: "image";
+  source: GenerationSource;
+  meta?: GenerationContentBlockMeta;
+} | {
+  type: "video";
+  source: GenerationSource;
+  meta?: GenerationContentBlockMeta;
+} | {
+  type: "audio";
+  source: GenerationSource;
+  meta?: GenerationContentBlockMeta;
+};
+type GenerationContentSpec = {
+  type: "text" | "image" | "video" | "audio";
+  required?: boolean;
+  min?: number;
+  max?: number;
+  sources?: Array<GenerationSource["type"]>;
+  merge?: "newline" | "space" | "concat";
+  meta?: Record<string, unknown>;
+  description?: string;
+};
+type GenerationParameterSpec = {
+  type: "string";
+  optional?: boolean;
+  default?: string;
+  enum?: string[];
+  description?: string;
+  examples?: string[];
+} | {
+  type: "number";
+  optional?: boolean;
+  default?: number;
+  min?: number;
+  max?: number;
+  description?: string;
+  examples?: number[];
+} | {
+  type: "integer";
+  optional?: boolean;
+  default?: number;
+  min?: number;
+  max?: number;
+  description?: string;
+  examples?: number[];
+} | {
+  type: "boolean";
+  optional?: boolean;
+  default?: boolean;
+  description?: string;
+  examples?: boolean[];
+};
+type GenerationModelDeclaration = {
+  schema: typeof MODEL_SCHEMA;
+  model: string;
+  title?: string;
+  description?: string;
+  adapter: {
+    type: string;
+  };
+  content: {
+    input: GenerationContentSpec[];
+  };
+  parameters?: Record<string, GenerationParameterSpec>;
+  examples?: Array<{
+    title?: string;
+    request: GenerateRequest;
+  }>;
+};
+type GenerateRequest = {
+  model: string;
+  content: GenerationContentBlock[];
+  parameters?: Record<string, unknown>;
+  apiKey?: string;
+  baseUrl?: string;
+  metadata?: Record<string, unknown>;
+};
+type ResolvedGenerationRequest = {
+  declaration: GenerationModelDeclaration;
+  request: GenerateRequest;
+  parameters: Record<string, unknown>;
+};
+type GenerationSourceResolver = (source: GenerationSource) => Promise<string> | string;
+type GenerationAdapterContext = {
+  apiKey: string;
+  baseUrl: string;
+  fetch: typeof fetch;
+  resolveSource: GenerationSourceResolver;
+};
+type GenerationAdapterInput = ResolvedGenerationRequest & {
+  context: GenerationAdapterContext;
+};
+type GenerationAdapter = (input: GenerationAdapterInput) => Promise<GenerationContentBlock[]>;
+type CreateGenerationClientOptions = {
+  apiKey?: string;
+  baseUrl?: string;
+  models?: GenerationModelDeclaration[];
+  includeBuiltinModels?: boolean;
+  fetch?: typeof fetch;
+  sourceResolver?: GenerationSourceResolver;
+  adapters?: Record<string, GenerationAdapter>;
+};
+type GenerationClient = {
+  generate(request: GenerateRequest): Promise<GenerationContentBlock[]>;
+  validate(request: GenerateRequest): ResolvedGenerationRequest;
+  listModels(): GenerationModelDeclaration[];
+  getModel(model: string): GenerationModelDeclaration | null;
+  stringifyModelConfig(model: string, options?: {
+    format?: "yaml" | "json";
+  }): string;
+  exportModelConfig(model: string, filePath: string): Promise<void>;
+  exportModelConfigs(directory: string): Promise<void>;
+};
+//#endregion
+//#region src/builtins.d.ts
+declare const builtinGenerationModels: GenerationModelDeclaration[];
+declare function getBuiltinGenerationModel(model: string): GenerationModelDeclaration | null;
+declare function listBuiltinGenerationModels(): GenerationModelDeclaration[];
+//#endregion
+export { MODEL_SCHEMA as _, GenerateRequest as a, GenerationAdapterInput as c, GenerationContentBlockMeta as d, GenerationContentSpec as f, GenerationSourceResolver as g, GenerationSource as h, CreateGenerationClientOptions as i, GenerationClient as l, GenerationParameterSpec as m, getBuiltinGenerationModel as n, GenerationAdapter as o, GenerationModelDeclaration as p, listBuiltinGenerationModels as r, GenerationAdapterContext as s, builtinGenerationModels as t, GenerationContentBlock as u, ResolvedGenerationRequest as v };
+//# sourceMappingURL=builtins-BuI-rf8X.d.ts.map

package/dist/builtins-BuI-rf8X.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtins-BuI-rf8X.d.ts","names":[],"sources":["../src/types.ts","../src/builtins.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/builtins-hmNIcYXN.js

@@ -0,0 +1,311 @@
+//#region src/types.ts
+const MODEL_SCHEMA = "neta.generation.model.v1";
+
+//#endregion
+//#region src/utils.ts
+function cloneJson(value) {
+	return JSON.parse(JSON.stringify(value));
+}
+function slugifyFileName(value) {
+	return value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "model";
+}
+function getBlockMeta(block) {
+	return "meta" in block ? block.meta : void 0;
+}
+
+//#endregion
+//#region src/builtins.ts
+const imageSizeParameters = {
+	size: {
+		type: "string",
+		optional: true,
+		default: "1024x1024",
+		description: "Output image size.",
+		examples: [
+			"auto",
+			"1024x1024",
+			"1536x1024",
+			"1024x1536",
+			"2048x2048",
+			"2048x1152",
+			"3840x2160",
+			"2160x3840"
+		]
+	},
+	quality: {
+		type: "string",
+		optional: true,
+		default: "auto",
+		enum: [
+			"auto",
+			"low",
+			"medium",
+			"high"
+		],
+		description: "Image quality."
+	}
+};
+function videoParameters(defaults) {
+	return {
+		duration: {
+			type: "integer",
+			optional: true,
+			default: 5,
+			min: 4,
+			max: 15,
+			description: "Video duration in seconds."
+		},
+		resolution: {
+			type: "string",
+			optional: true,
+			default: defaults.resolution,
+			enum: [
+				"480p",
+				"720p",
+				"1080p",
+				"2K"
+			],
+			description: "Output video resolution."
+		},
+		aspect_ratio: {
+			type: "string",
+			optional: true,
+			default: "16:9",
+			enum: [
+				"16:9",
+				"9:16",
+				"1:1",
+				"4:3",
+				"3:2",
+				"2:3",
+				"3:4",
+				"21:9",
+				"adaptive"
+			],
+			description: "Output aspect ratio. Use adaptive to let the model choose."
+		},
+		fps: {
+			type: "integer",
+			optional: true,
+			default: 30,
+			min: 1,
+			max: 60,
+			description: "Frames per second."
+		},
+		seed: {
+			type: "integer",
+			optional: true,
+			description: "Random seed for reproducibility."
+		},
+		generate_audio: {
+			type: "boolean",
+			optional: true,
+			default: true,
+			description: "Generate synchronized audio."
+		},
+		return_last_frame: {
+			type: "boolean",
+			optional: true,
+			default: true,
+			description: "Return the last frame as an image for chaining video segments."
+		},
+		camera_fixed: {
+			type: "boolean",
+			optional: true,
+			default: false,
+			description: "Fix camera position when supported."
+		},
+		watermark: {
+			type: "boolean",
+			optional: true,
+			default: false,
+			description: "Add AI Generated watermark."
+		},
+		poll_interval: {
+			type: "integer",
+			optional: true,
+			default: 2,
+			min: 1,
+			max: 30,
+			description: "Seconds between task status checks."
+		},
+		max_wait: {
+			type: "integer",
+			optional: true,
+			default: defaults.maxWait,
+			min: 30,
+			max: 1800,
+			description: "Maximum seconds to wait for task completion."
+		}
+	};
+}
+const builtinModels = [
+	{
+		schema: MODEL_SCHEMA,
+		model: "gpt-image-2",
+		title: "GPT Image 2",
+		description: "Image generation model with optional reference images. Good for photorealistic scenes, detailed images, and image editing with references.",
+		adapter: { type: "openai.images" },
+		content: { input: [{
+			type: "text",
+			required: true,
+			min: 1,
+			max: 16,
+			merge: "newline",
+			description: "Prompt text."
+		}, {
+			type: "image",
+			required: false,
+			max: 16,
+			sources: ["url", "base64"],
+			description: "Optional reference images."
+		}] },
+		parameters: imageSizeParameters,
+		examples: [{
+			title: "Basic image",
+			request: {
+				model: "gpt-image-2",
+				content: [{
+					type: "text",
+					text: "a cyberpunk cat in neon rain"
+				}],
+				parameters: {
+					size: "1024x1024",
+					quality: "auto"
+				}
+			}
+		}]
+	},
+	{
+		schema: MODEL_SCHEMA,
+		model: "gemini-3.1-flash-image-preview",
+		title: "Gemini 3.1 Flash Image Preview",
+		description: "Gemini image generation and editing model. Good for text rendering, infographics, style transfer, and iterative image editing with references.",
+		adapter: { type: "gemini.generateContent" },
+		content: { input: [{
+			type: "text",
+			required: true,
+			min: 1,
+			max: 16,
+			merge: "newline",
+			description: "Prompt text."
+		}, {
+			type: "image",
+			required: false,
+			max: 14,
+			sources: ["url", "base64"],
+			description: "Optional reference images."
+		}] },
+		parameters: {
+			aspect_ratio: {
+				type: "string",
+				optional: true,
+				default: "1:1",
+				enum: [
+					"1:1",
+					"16:9",
+					"4:3",
+					"3:2",
+					"3:4",
+					"2:3",
+					"9:16",
+					"5:4",
+					"4:5",
+					"21:9",
+					"1:4",
+					"4:1",
+					"1:8",
+					"8:1"
+				],
+				description: "Output aspect ratio."
+			},
+			image_size: {
+				type: "string",
+				optional: true,
+				default: "2K",
+				enum: [
+					"512",
+					"1K",
+					"2K",
+					"4K"
+				],
+				description: "Output image resolution."
+			}
+		},
+		examples: [{
+			title: "Basic image",
+			request: {
+				model: "gemini-3.1-flash-image-preview",
+				content: [{
+					type: "text",
+					text: "a vibrant infographic explaining photosynthesis with clear readable labels"
+				}],
+				parameters: {
+					aspect_ratio: "16:9",
+					image_size: "1K"
+				}
+			}
+		}]
+	},
+	{
+		schema: MODEL_SCHEMA,
+		model: "seedance-2-0",
+		title: "Seedance 2.0",
+		description: "Higher quality Ark video generation model for final production outputs.",
+		adapter: { type: "ark.videoGenerations" },
+		content: { input: [{
+			type: "text",
+			required: true,
+			min: 1,
+			max: 16,
+			merge: "newline",
+			description: "Video prompt."
+		}, {
+			type: "image",
+			required: false,
+			max: 9,
+			sources: ["url", "base64"],
+			description: "Optional image input. Use meta.role as first_frame, last_frame, or reference_image."
+		}] },
+		parameters: videoParameters({
+			resolution: "1080p",
+			maxWait: 900
+		})
+	},
+	{
+		schema: MODEL_SCHEMA,
+		model: "seedance-2-0-fast",
+		title: "Seedance 2.0 Fast",
+		description: "Fast Ark video generation model for drafts, rapid iteration, text-to-video, image-to-video, and reference-guided video generation.",
+		adapter: { type: "ark.videoGenerations" },
+		content: { input: [{
+			type: "text",
+			required: true,
+			min: 1,
+			max: 16,
+			merge: "newline",
+			description: "Video prompt."
+		}, {
+			type: "image",
+			required: false,
+			max: 9,
+			sources: ["url", "base64"],
+			description: "Optional image input. Use meta.role as first_frame, last_frame, or reference_image."
+		}] },
+		parameters: videoParameters({
+			resolution: "720p",
+			maxWait: 600
+		})
+	}
+];
+const builtinGenerationModels = cloneJson(builtinModels);
+function getBuiltinGenerationModel(model) {
+	return cloneJson(builtinModels.find((declaration) => declaration.model === model) ?? null);
+}
+function listBuiltinGenerationModels() {
+	return cloneJson(builtinModels);
+}
+
+//#endregion
+export { getBlockMeta as a, cloneJson as i, getBuiltinGenerationModel as n, slugifyFileName as o, listBuiltinGenerationModels as r, MODEL_SCHEMA as s, builtinGenerationModels as t };
+//# sourceMappingURL=builtins-hmNIcYXN.js.map