vargai 0.3.0

package/src/definitions/models/nano-banana-pro.ts

@@ -0,0 +1,102 @@
+/**
+ * Nano Banana Pro image generation model (Google Gemini 3 Pro Image)
+ * High-quality image generation and editing from text or images
+ */
+
+import { z } from "zod";
+import type { ModelDefinition, ZodSchema } from "../../core/schema/types";
+
+// Nano Banana Pro resolution options
+const nanoBananaResolutionSchema = z.enum(["1K", "2K", "4K"]);
+
+// Nano Banana Pro aspect ratio options (fal.ai API does not support "auto")
+const nanoBananaAspectRatioSchema = z.enum([
+  "21:9",
+  "16:9",
+  "3:2",
+  "4:3",
+  "5:4",
+  "1:1",
+  "4:5",
+  "3:4",
+  "2:3",
+  "9:16",
+]);
+
+// Output format options
+const nanoBananaOutputFormatSchema = z.enum(["png", "jpeg", "webp"]);
+
+// Safety filter level options
+const nanoBananaSafetyFilterSchema = z.enum([
+  "block_only_high",
+  "block_medium_and_above",
+  "block_low_and_above",
+  "block_none",
+]);
+
+// Input schema with Zod
+const nanoBananaProInputSchema = z.object({
+  prompt: z.string().describe("Text description for generation or editing"),
+  image_urls: z
+    .array(z.string().url())
+    .optional()
+    .describe(
+      "Input image URLs for image-to-image editing (up to 14 images). If omitted, generates new image from prompt.",
+    ),
+  resolution: nanoBananaResolutionSchema
+    .default("1K")
+    .describe("Output resolution: 1K (1024px), 2K (2048px), or 4K"),
+  aspect_ratio: nanoBananaAspectRatioSchema
+    .default("1:1")
+    .describe("Output aspect ratio"),
+  output_format: nanoBananaOutputFormatSchema
+    .default("png")
+    .describe("Output image format"),
+  safety_filter_level: nanoBananaSafetyFilterSchema
+    .default("block_only_high")
+    .describe("Safety filter strictness level"),
+  num_images: z
+    .number()
+    .int()
+    .min(1)
+    .max(4)
+    .default(1)
+    .describe("Number of images to generate (1-4)"),
+});
+
+// Output schema with Zod
+const nanoBananaProOutputSchema = z.object({
+  images: z.array(
+    z.object({
+      url: z.string(),
+      file_name: z.string().optional(),
+      content_type: z.string().optional(),
+    }),
+  ),
+  description: z.string().optional(),
+});
+
+// Schema object for the definition
+const schema: ZodSchema<
+  typeof nanoBananaProInputSchema,
+  typeof nanoBananaProOutputSchema
+> = {
+  input: nanoBananaProInputSchema,
+  output: nanoBananaProOutputSchema,
+};
+
+export const definition: ModelDefinition<typeof schema> = {
+  type: "model",
+  name: "nano-banana-pro",
+  description:
+    "Google Nano Banana Pro (Gemini 3 Pro Image) for text-to-image generation and image editing. Provide image_urls for editing, omit for generation.",
+  providers: ["fal", "replicate"],
+  defaultProvider: "fal",
+  providerModels: {
+    fal: "fal-ai/nano-banana-pro",
+    replicate: "google/nano-banana-pro",
+  },
+  schema,
+};
+
+export default definition;

package/src/definitions/models/sonauto.ts

@@ -0,0 +1,68 @@
+/**
+ * Sonauto music generation model
+ * Text-to-music generation
+ */
+
+import { z } from "zod";
+import { audioFormatSchema } from "../../core/schema/shared";
+import type { ModelDefinition, ZodSchema } from "../../core/schema/types";
+
+// Input schema with Zod
+const sonautoInputSchema = z.object({
+  prompt: z.string().optional().describe("Music description"),
+  tags: z.array(z.string()).optional().describe("Style tags"),
+  lyrics_prompt: z.string().optional().describe("Lyrics to generate"),
+  num_songs: z
+    .union([z.literal(1), z.literal(2)])
+    .default(1)
+    .describe("Number of songs"),
+  output_format: audioFormatSchema.default("mp3").describe("Output format"),
+  bpm: z
+    .union([z.number(), z.literal("auto")])
+    .default("auto")
+    .describe("Beats per minute"),
+});
+
+// Output schema with Zod
+const sonautoOutputSchema = z.object({
+  seed: z.number(),
+  tags: z.array(z.string()).optional(),
+  lyrics: z.string().optional(),
+  audio: z.union([
+    z.array(
+      z.object({
+        url: z.string(),
+        file_name: z.string(),
+        content_type: z.string(),
+        file_size: z.number(),
+      }),
+    ),
+    z.object({
+      url: z.string(),
+      file_name: z.string(),
+      content_type: z.string(),
+      file_size: z.number(),
+    }),
+  ]),
+});
+
+// Schema object for the definition
+const schema: ZodSchema<typeof sonautoInputSchema, typeof sonautoOutputSchema> =
+  {
+    input: sonautoInputSchema,
+    output: sonautoOutputSchema,
+  };
+
+export const definition: ModelDefinition<typeof schema> = {
+  type: "model",
+  name: "sonauto",
+  description: "Sonauto model for text-to-music generation",
+  providers: ["fal"],
+  defaultProvider: "fal",
+  providerModels: {
+    fal: "fal-ai/sonauto/bark",
+  },
+  schema,
+};
+
+export default definition;

package/src/definitions/models/soul.ts

@@ -0,0 +1,65 @@
+/**
+ * Higgsfield Soul image generation model
+ * Character-focused image generation
+ */
+
+import { z } from "zod";
+import { soulQualitySchema } from "../../core/schema/shared";
+import type { ModelDefinition, ZodSchema } from "../../core/schema/types";
+
+// Soul-specific dimension schema
+const soulDimensionSchema = z.enum([
+  "SQUARE_1024x1024",
+  "PORTRAIT_1152x2048",
+  "LANDSCAPE_2048x1152",
+]);
+
+// Soul-specific batch size schema
+const soulBatchSizeSchema = z.union([z.literal(1), z.literal(2), z.literal(4)]);
+
+// Input schema with Zod
+const soulInputSchema = z.object({
+  prompt: z.string().describe("Character description"),
+  width_and_height: soulDimensionSchema
+    .default("PORTRAIT_1152x2048")
+    .describe("Output dimensions"),
+  quality: soulQualitySchema.default("HD").describe("Output quality"),
+  style_id: z.string().optional().describe("Style preset ID"),
+  batch_size: soulBatchSizeSchema
+    .default(1)
+    .describe("Number of images to generate"),
+  enhance_prompt: z.boolean().default(false).describe("Enhance prompt with AI"),
+});
+
+// Output schema with Zod
+const soulOutputSchema = z.object({
+  jobs: z.array(
+    z.object({
+      results: z.object({
+        raw: z.object({
+          url: z.string(),
+        }),
+      }),
+    }),
+  ),
+});
+
+// Schema object for the definition
+const schema: ZodSchema<typeof soulInputSchema, typeof soulOutputSchema> = {
+  input: soulInputSchema,
+  output: soulOutputSchema,
+};
+
+export const definition: ModelDefinition<typeof schema> = {
+  type: "model",
+  name: "soul",
+  description: "Higgsfield Soul model for character-focused image generation",
+  providers: ["higgsfield"],
+  defaultProvider: "higgsfield",
+  providerModels: {
+    higgsfield: "/v1/text2image/soul",
+  },
+  schema,
+};
+
+export default definition;

package/src/definitions/models/wan.ts

@@ -0,0 +1,54 @@
+/**
+ * Wan-25 lip sync model
+ * Audio-driven video generation with lip sync
+ */
+
+import { z } from "zod";
+import {
+  resolutionSchema,
+  videoDurationStringSchema,
+} from "../../core/schema/shared";
+import type { ModelDefinition, ZodSchema } from "../../core/schema/types";
+
+// Input schema with Zod
+const wanInputSchema = z.object({
+  prompt: z.string().describe("Scene description"),
+  image_url: z.string().url().describe("Input image of the character"),
+  audio_url: z.string().url().describe("Audio file for lip sync"),
+  duration: videoDurationStringSchema
+    .default("5")
+    .describe("Video duration in seconds"),
+  resolution: resolutionSchema.default("480p").describe("Output resolution"),
+  negative_prompt: z
+    .string()
+    .optional()
+    .describe("What to avoid in generation"),
+});
+
+// Output schema with Zod
+const wanOutputSchema = z.object({
+  video: z.object({
+    url: z.string(),
+  }),
+});
+
+// Schema object for the definition
+const schema: ZodSchema<typeof wanInputSchema, typeof wanOutputSchema> = {
+  input: wanInputSchema,
+  output: wanOutputSchema,
+};
+
+export const definition: ModelDefinition<typeof schema> = {
+  type: "model",
+  name: "wan",
+  description: "Wan-25 model for audio-driven video generation with lip sync",
+  providers: ["fal", "replicate"],
+  defaultProvider: "fal",
+  providerModels: {
+    fal: "fal-ai/wan-25-preview/image-to-video",
+    replicate: "wan-video/wan-2.5-i2v",
+  },
+  schema,
+};
+
+export default definition;

package/src/definitions/models/whisper.ts

@@ -0,0 +1,44 @@
+/**
+ * Whisper transcription model
+ * Speech-to-text transcription
+ */
+
+import { z } from "zod";
+import { filePathSchema } from "../../core/schema/shared";
+import type { ModelDefinition, ZodSchema } from "../../core/schema/types";
+
+// Input schema with Zod
+const whisperInputSchema = z.object({
+  file: filePathSchema.describe("Audio file to transcribe"),
+  language: z.string().optional().describe("Language code (e.g., 'en', 'es')"),
+  prompt: z
+    .string()
+    .optional()
+    .describe("Optional prompt to guide transcription"),
+  temperature: z.number().default(0).describe("Sampling temperature"),
+});
+
+// Output schema with Zod
+const whisperOutputSchema = z.string().describe("Transcribed text");
+
+// Schema object for the definition
+const schema: ZodSchema<typeof whisperInputSchema, typeof whisperOutputSchema> =
+  {
+    input: whisperInputSchema,
+    output: whisperOutputSchema,
+  };
+
+export const definition: ModelDefinition<typeof schema> = {
+  type: "model",
+  name: "whisper",
+  description: "OpenAI Whisper model for speech-to-text transcription",
+  providers: ["groq", "fireworks"],
+  defaultProvider: "groq",
+  providerModels: {
+    groq: "whisper-large-v3",
+    fireworks: "whisper-v3-large",
+  },
+  schema,
+};
+
+export default definition;

package/src/definitions/skills/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Skill definitions index
+ */
+
+export { definition as talkingCharacter } from "./talking-character";
+export { definition as textToTiktok } from "./text-to-tiktok";
+
+// All skill definitions for auto-loading
+import { definition as talkingCharacterDefinition } from "./talking-character";
+import { definition as textToTiktokDefinition } from "./text-to-tiktok";
+
+export const allSkills = [talkingCharacterDefinition, textToTiktokDefinition];

package/src/definitions/skills/talking-character.ts

@@ -0,0 +1,87 @@
+/**
+ * Talking Character Skill
+ * Create a talking character video with lipsync and captions
+ */
+
+import { z } from "zod";
+import {
+  captionStyleSchema,
+  simpleVoiceSchema,
+  videoDurationSchema,
+} from "../../core/schema/shared";
+import type { SkillDefinition, ZodSchema } from "../../core/schema/types";
+
+// Input schema with Zod
+const talkingCharacterInputSchema = z.object({
+  text: z.string().describe("Script/text for the character to say"),
+  characterPrompt: z
+    .string()
+    .default("professional headshot of a friendly person, studio lighting")
+    .describe("Prompt to generate the character"),
+  voice: simpleVoiceSchema.default("sam").describe("Voice to use for speech"),
+  duration: videoDurationSchema.default(5).describe("Video duration"),
+  style: captionStyleSchema.default("tiktok").describe("Caption style"),
+});
+
+// Output schema with Zod
+const talkingCharacterOutputSchema = z.object({
+  videoUrl: z.string(),
+  characterImageUrl: z.string().optional(),
+  audioPath: z.string().optional(),
+});
+
+// Schema object for the definition
+const schema: ZodSchema<
+  typeof talkingCharacterInputSchema,
+  typeof talkingCharacterOutputSchema
+> = {
+  input: talkingCharacterInputSchema,
+  output: talkingCharacterOutputSchema,
+};
+
+export const definition: SkillDefinition<typeof schema> = {
+  type: "skill",
+  name: "talking-character",
+  description: "Create a talking character video with lipsync and captions",
+  schema,
+  steps: [
+    {
+      name: "generate-character",
+      run: "image",
+      inputs: {
+        prompt: "$inputs.characterPrompt",
+        provider: "higgsfield",
+      },
+    },
+    {
+      name: "generate-voice",
+      run: "voice",
+      inputs: {
+        text: "$inputs.text",
+        voice: "$inputs.voice",
+        output: "output/voiceover.mp3",
+      },
+    },
+    {
+      name: "animate-character",
+      run: "sync",
+      inputs: {
+        image: "$results.generate-character.imageUrl",
+        audio: "output/voiceover.mp3",
+        prompt: "person talking naturally, professional demeanor",
+        duration: "$inputs.duration",
+      },
+    },
+    {
+      name: "add-captions",
+      run: "captions",
+      inputs: {
+        video: "$results.animate-character.videoUrl",
+        output: "output/final.mp4",
+        style: "$inputs.style",
+      },
+    },
+  ],
+};
+
+export default definition;

package/src/definitions/skills/text-to-tiktok.ts

@@ -0,0 +1,97 @@
+/**
+ * Text to TikTok Skill
+ * Turn text into a TikTok with AI-generated looping background and voiceover
+ */
+
+import { z } from "zod";
+import {
+  captionStyleSchema,
+  simpleVoiceSchema,
+} from "../../core/schema/shared";
+import type { SkillDefinition, ZodSchema } from "../../core/schema/types";
+
+// Input schema with Zod
+const textToTiktokInputSchema = z.object({
+  text: z.string().describe("Text content to convert to video"),
+  voice: simpleVoiceSchema.default("sam").describe("Voice for narration"),
+  backgroundPrompt: z
+    .string()
+    .default(
+      "POV from inside moving car driving through rainy city at night, motion blur on streetlights, cinematic",
+    )
+    .describe("Prompt for background video"),
+  captionStyle: captionStyleSchema.default("tiktok").describe("Caption style"),
+});
+
+// Output schema with Zod
+const textToTiktokOutputSchema = z.object({
+  videoUrl: z.string(),
+  voiceoverPath: z.string().optional(),
+  captionsPath: z.string().optional(),
+  backgroundVideoUrl: z.string().optional(),
+});
+
+// Schema object for the definition
+const schema: ZodSchema<
+  typeof textToTiktokInputSchema,
+  typeof textToTiktokOutputSchema
+> = {
+  input: textToTiktokInputSchema,
+  output: textToTiktokOutputSchema,
+};
+
+export const definition: SkillDefinition<typeof schema> = {
+  type: "skill",
+  name: "text-to-tiktok",
+  description: "Turn text into a TikTok with looping background and voiceover",
+  schema,
+  steps: [
+    {
+      name: "generate-voiceover",
+      run: "voice",
+      inputs: {
+        text: "$inputs.text",
+        voice: "$inputs.voice",
+        output: "output/voiceover.mp3",
+      },
+    },
+    {
+      name: "transcribe",
+      run: "transcribe",
+      inputs: {
+        audio: "output/voiceover.mp3",
+        provider: "fireworks",
+        output: "output/captions.srt",
+      },
+    },
+    {
+      name: "generate-background-frame",
+      run: "image",
+      inputs: {
+        prompt: "$inputs.backgroundPrompt",
+        size: "portrait_16_9",
+      },
+    },
+    {
+      name: "generate-background-video",
+      run: "video",
+      inputs: {
+        prompt: "$inputs.backgroundPrompt",
+        image: "$results.generate-background-frame.imageUrl",
+        duration: 10,
+      },
+    },
+    {
+      name: "add-captions",
+      run: "captions",
+      inputs: {
+        video: "$results.generate-background-video.videoUrl",
+        output: "output/final.mp4",
+        srt: "output/captions.srt",
+        style: "$inputs.captionStyle",
+      },
+    },
+  ],
+};
+
+export default definition;

package/src/index.ts

@@ -0,0 +1,118 @@
+/**
+ * varg.ai SDK
+ * AI video generation and editing tools
+ */
+
+// Re-export external clients for convenience
+export { fal } from "@ai-sdk/fal";
+export { replicate } from "@ai-sdk/replicate";
+export { fal as falClient } from "@fal-ai/client";
+export { HiggsfieldClient } from "@higgsfield/client";
+// Core exports
+export * from "./core";
+export type {
+  ActionDefinition,
+  Definition,
+  ExecutionResult,
+  InferInput,
+  InferOutput,
+  Job,
+  JobStatus,
+  JsonSchema,
+  ModelDefinition,
+  Provider,
+  ProviderConfig,
+  RunOptions,
+  SchemaProperty,
+  SkillDefinition,
+  VargConfig,
+  ZodSchema,
+} from "./core/schema/types";
+// Definition exports
+export * from "./definitions";
+export type {
+  FireworksResponse,
+  FireworksWord,
+  ProbeResult,
+  ProviderResult,
+  StorageConfig,
+} from "./providers";
+// Provider exports (excluding transcribeAudio to avoid conflict with definitions)
+
+export {
+  addAudio,
+  // Base
+  BaseProvider,
+  BatchSize,
+  chatCompletion,
+  concatVideos,
+  convertFireworksToSRT,
+  convertFormat,
+  createSoulId,
+  downloadToFile,
+  // ElevenLabs
+  ElevenLabsProvider,
+  elevenlabsProvider,
+  ensureUrl,
+  extractAudio,
+  // Fal
+  FalProvider,
+  // FFmpeg
+  FFmpegProvider,
+  // Fireworks
+  FireworksProvider,
+  fadeVideo,
+  falProvider,
+  ffmpegProvider,
+  fireworksProvider,
+  GROQ_MODELS,
+  // Groq
+  GroqProvider,
+  generateImage,
+  generateMusicElevenlabs,
+  generatePresignedUrl,
+  generateSoul,
+  generateSoundEffect,
+  getExtension,
+  getPublicUrl,
+  getVideoDuration,
+  getVoice,
+  groqProvider,
+  // Higgsfield
+  HiggsfieldProvider,
+  higgsfieldProvider,
+  imageToImage,
+  imageToVideo,
+  listModels,
+  listSoulIds,
+  listSoulStyles,
+  listVoices,
+  MODELS,
+  ProviderRegistry,
+  probe,
+  providers,
+  // Replicate
+  ReplicateProvider,
+  replicateProvider,
+  resizeVideo,
+  runImage,
+  runModel,
+  runVideo,
+  SoulQuality,
+  SoulSize,
+  // Storage
+  StorageProvider,
+  splitAtTimestamps,
+  storageProvider,
+  textToMusic,
+  textToSpeech,
+  textToVideo,
+  transcribeWithFireworks,
+  trimVideo,
+  uploadBuffer,
+  uploadFile,
+  uploadFromUrl,
+  VOICES,
+  wan25,
+  xfadeVideos,
+} from "./providers";