@mixio-pro/kalaasetu-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kalaasetu
+
+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,127 @@
+# kalaasetu-mcp
+
+Kalaasetu MCP Server - A powerful Model Context Protocol server providing various AI tools for content generation and analysis.
+
+## Features
+
+### 🎨 Gemini Tools
+- **Text to Image**: Generate images from text prompts
+- **Image Editing**: Edit existing images with AI
+- **Image Analysis**: Analyze and describe images
+- **Text-to-Speech**: Generate natural speech from text
+- **Video Analysis**: Analyze video content
+
+### 📹 Video Tools
+- **Image-to-Video** (Vertex AI Veo): Generate videos from images using Google's Veo models
+- **Infinitalk** (FAL AI): Create talking avatar videos with lip-sync from image and audio
+
+### 🎬 YouTube Tools
+- **YouTube Analyzer**: Analyze YouTube videos and extract insights
+
+### 🔍 Perplexity Search Tools
+- **Image Search**: Search for images using Perplexity AI with domain and format filters
+- **Video Search**: Search for videos using Perplexity AI with domain filters
+
+## Installation
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+## Configuration
+
+Set up the required API keys as environment variables:
+
+```bash
+# For Gemini and Vertex AI tools
+export GOOGLE_APPLICATION_CREDENTIALS="/path/to/your/credentials.json"
+export GEMINI_API_KEY="your-gemini-api-key"
+
+# For FAL AI Infinitalk
+export FAL_KEY="your-fal-api-key"
+
+# For Perplexity Search Tools
+export PERPLEXITY_API_KEY="your-perplexity-api-key"
+```
+
+## Running the Server
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+## Tool: Infinitalk
+
+Generate talking avatar videos from images and audio using FAL AI's Infinitalk model.
+
+### Parameters
+
+- `image_url` (required): URL of the input image
+- `audio_url` (required): URL of the audio file for lip-sync
+- `prompt` (required): Text description guiding video generation
+- `num_frames` (optional): Number of frames (41-721, default: 145)
+- `resolution` (optional): Video resolution - "480p" or "720p" (default: "480p")
+- `seed` (optional): Random seed for reproducibility (default: 42)
+- `acceleration` (optional): Generation speed - "none", "regular", or "high" (default: "regular")
+- `fal_key` (optional): FAL API key (uses FAL_KEY env var if not provided)
+
+### Example Usage
+
+```json
+{
+  "image_url": "https://example.com/portrait.png",
+  "audio_url": "https://example.com/speech.mp3",
+  "prompt": "A person speaking professionally in a podcast setting",
+  "resolution": "720p",
+  "num_frames": 200
+}
+```
+
+## Tool: Perplexity Images
+
+Search for images using Perplexity AI with advanced filtering options.
+
+### Parameters
+
+- `query` (required): The search query for images
+- `image_domain_filter` (optional): Array of domains to include or exclude (prefix with '-' to exclude)
+  - Example: `["wikimedia.org", "-gettyimages.com"]`
+- `image_format_filter` (optional): Array of allowed image formats
+  - Example: `["jpg", "png", "gif"]`
+
+### Example Usage
+
+```json
+{
+  "query": "mountain landscapes",
+  "image_domain_filter": ["wikimedia.org", "-gettyimages.com"],
+  "image_format_filter": ["jpg", "png"]
+}
+```
+
+## Tool: Perplexity Videos
+
+Search for videos using Perplexity AI with domain filtering.
+
+### Parameters
+
+- `query` (required): The search query for videos
+- `search_domain_filter` (optional): Array of domains to limit search (use '-' prefix to exclude)
+  - Example: `["youtube.com"]` or `["-tiktok.com"]`
+
+### Example Usage
+
+```json
+{
+  "query": "yoga for beginners",
+  "search_domain_filter": ["youtube.com"]
+}
+```
+
+## Project Info
+
+This project was created using `bun init` in bun v1.3.1. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@mixio-pro/kalaasetu-mcp",
+  "version": "1.0.0",
+  "description": "A powerful Model Context Protocol server providing AI tools for content generation and analysis",
+  "type": "module",
+  "module": "src/index.ts",
+  "main": "src/index.ts",
+  "bin": {
+    "kalaasetu-mcp": "./src/index.ts"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "dev": "bun --watch src/index.ts"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "gemini",
+    "perplexity",
+    "video-generation",
+    "image-generation",
+    "tts",
+    "vertex-ai",
+    "fal-ai"
+  ],
+  "author": "Kalaasetu",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mixiopro/kalaasetu-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mixiopro/kalaasetu-mcp/issues"
+  },
+  "homepage": "https://github.com/mixiopro/kalaasetu-mcp#readme",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@fal-ai/client": "^1.7.2",
+    "@google/genai": "^1.28.0",
+    "@types/wav": "^1.0.4",
+    "fastmcp": "^3.22.0",
+    "google-auth-library": "^10.5.0",
+    "wav": "^1.0.2",
+    "zod": "^4.1.12"
+  }
+}

package/src/index.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env bun
+import { FastMCP } from "fastmcp";
+import { 
+  geminiTextToImage, 
+  geminiEditImage, 
+  geminiAnalyzeImages,
+  geminiSingleSpeakerTts,
+  geminiAnalyzeVideos
+} from "./tools/gemini";
+import { analyzeYoutubeVideo } from "./tools/youtube";
+import { imageToVideo } from "./tools/image-to-video";
+import { infinitalk } from "./tools/infinitalk";
+import { hunyuanAvatar } from "./tools/hunyuan-avatar";
+import { perplexityImages, perplexityVideos } from "./tools/perplexity";
+
+const server = new FastMCP({
+  name: "Kalaasetu MCP Server",
+  version: "1.0.0",
+});
+
+// Gemini Image Tools
+server.addTool(geminiTextToImage);
+server.addTool(geminiEditImage);
+server.addTool(geminiAnalyzeImages);
+
+// Gemini TTS Tool
+server.addTool(geminiSingleSpeakerTts);
+
+// Gemini Video Analysis Tool
+server.addTool(geminiAnalyzeVideos);
+
+// YouTube Analyzer Tool
+server.addTool(analyzeYoutubeVideo);
+
+// Vertex AI Image-to-Video Tool
+server.addTool(imageToVideo);
+
+// FAL AI Infinitalk Tool
+server.addTool(infinitalk);
+
+// FAL AI Hunyuan Avatar Tool
+server.addTool(hunyuanAvatar);
+
+// Perplexity Search Tools
+server.addTool(perplexityImages);
+server.addTool(perplexityVideos);
+
+server.start({
+  transportType: "stdio",
+});

package/src/tools/gemini.ts

@@ -0,0 +1,395 @@
+import { z } from "zod";
+import { GoogleGenAI, createPartFromUri, createUserContent } from "@google/genai";
+import * as fs from "fs";
+import * as wav from "wav";
+
+const ai = new GoogleGenAI({
+  apiKey: process.env.GEMINI_API_KEY || "",
+});
+
+function fileToGenerativePart(filePath: string) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const imageBytes = fs.readFileSync(filePath);
+  return {
+    inlineData: {
+      data: Buffer.from(imageBytes).toString("base64"),
+      mimeType: "image/jpeg",
+    },
+  };
+}
+
+// Helper function to save WAV file
+function saveWaveFile(
+  filename: string,
+  pcmData: Buffer,
+  channels = 1,
+  rate = 24000,
+  sampleWidth = 2,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const writer = new wav.FileWriter(filename, {
+      channels,
+      sampleRate: rate,
+      bitDepth: sampleWidth * 8,
+    });
+
+    writer.on('finish', resolve);
+    writer.on('error', reject);
+
+    writer.write(pcmData);
+    writer.end();
+  });
+}
+
+// Helper function to check if URL is YouTube URL
+function isYouTubeUrl(url: string): boolean {
+  return url.includes('youtube.com/watch') || url.includes('youtu.be');
+}
+
+// Helper function to get file size in bytes
+function getFileSize(filePath: string): number {
+  const stats = fs.statSync(filePath);
+  return stats.size;
+}
+
+// Helper function to upload file to Gemini API
+async function uploadFileToGemini(filePath: string): Promise<any> {
+  try {
+    const uploadedFile = await ai.files.upload({
+      file: filePath,
+    });
+    
+    // Wait for file processing to complete
+    let getFile = await ai.files.get({ name: uploadedFile.name! });
+    while (getFile.state === 'PROCESSING') {
+      await new Promise(resolve => setTimeout(resolve, 3000));
+      getFile = await ai.files.get({ name: uploadedFile.name! });
+    }
+
+    if (getFile.state === 'FAILED') {
+      throw new Error('File processing failed');
+    }
+
+    return getFile;
+  } catch (error: any) {
+    throw new Error(`File upload failed: ${error.message}`);
+  }
+}
+
+// Helper function to process video input intelligently
+async function processVideoInput(input: string, config?: { fps?: number; startOffset?: string; endOffset?: string }): Promise<any> {
+  if (isYouTubeUrl(input)) {
+    return {
+      fileData: {
+        fileUri: input,
+        mimeType: 'video/*',
+        videoMetadata: config ? {
+          fps: config.fps,
+          startOffset: config.startOffset,
+          endOffset: config.endOffset
+        } : undefined
+      }
+    };
+  } else {
+    // Local file processing - use File Upload API
+    if (!fs.existsSync(input)) {
+      throw new Error(`Video file not found: ${input}`);
+    }
+    
+    // Upload file to Gemini API
+    const uploadedFile = await uploadFileToGemini(input);
+    
+    return uploadedFile;
+  }
+}
+
+export const geminiTextToImage = {
+  name: "geminiTextToImage",
+  description: "Generate images from text prompts using Gemini 2.5 Flash Image model",
+  parameters: z.object({
+    prompt: z.string().describe("Text description of the image to generate"),
+    aspect_ratio: z.string().optional().describe("Aspect ratio: 1:1, 3:4, 4:3, 9:16, or 16:9"),
+    output_path: z.string().optional().describe("File path to save the generated image"),
+  }),
+  execute: async (args: { prompt: string; aspect_ratio?: string; output_path?: string }) => {
+    try {
+      const response = await ai.models.generateContent({
+        model: "gemini-2.5-flash-image",
+        contents: args.prompt,
+        config: {
+          imageConfig: {
+            aspectRatio: args.aspect_ratio || "1:1",
+          },
+        },
+      });
+
+      let result = "";
+      if (response.candidates && response.candidates[0]?.content?.parts) {
+        for (const part of response.candidates[0].content.parts) {
+          if (part.text) {
+            result += part.text;
+          } else if (part.inlineData?.data) {
+            const imageData = part.inlineData.data;
+            if (args.output_path) {
+              fs.writeFileSync(args.output_path, Buffer.from(imageData, "base64"));
+              result += `\nImage saved to: ${args.output_path}`;
+            } else {
+              result += `\nGenerated image (base64): ${imageData.substring(0, 100)}...`;
+            }
+          }
+        }
+      }
+      return result || "Image generation completed but no response received";
+    } catch (error: any) {
+      throw new Error(`Image generation failed: ${error.message}`);
+    }
+  },
+};
+
+export const geminiEditImage = {
+  name: "geminiEditImage",
+  description: "Edit existing images with text instructions using Gemini 2.5 Flash Image Preview",
+  parameters: z.object({
+    image_path: z.string().describe("Path to the source image file"),
+    prompt: z.string().describe("Text instructions for editing the image"),
+    output_path: z.string().optional().describe("File path to save the edited image"),
+    reference_images: z.array(z.string()).optional().describe("Additional image paths for reference"),
+  }),
+  execute: async (args: { image_path: string; prompt: string; output_path?: string; reference_images?: string[] }) => {
+    try {
+      const contents: any[] = [args.prompt, fileToGenerativePart(args.image_path)];
+      
+      if (args.reference_images) {
+        for (const refPath of args.reference_images) {
+          contents.push(fileToGenerativePart(refPath));
+        }
+      }
+
+      const response = await ai.models.generateContent({
+        model: "gemini-2.5-flash-image-preview",
+        contents: contents,
+      });
+
+      let result = "";
+      if (response.candidates && response.candidates[0]?.content?.parts) {
+        for (const part of response.candidates[0].content.parts) {
+          if (part.text) {
+            result += part.text;
+          } else if (part.inlineData?.data) {
+            const imageData = part.inlineData.data;
+            if (args.output_path) {
+              fs.writeFileSync(args.output_path, Buffer.from(imageData, "base64"));
+              result += `\nEdited image saved to: ${args.output_path}`;
+            } else {
+              result += `\nEdited image (base64): ${imageData.substring(0, 100)}...`;
+            }
+          }
+        }
+      }
+      return result || "Image editing completed but no response received";
+    } catch (error: any) {
+      throw new Error(`Image editing failed: ${error.message}`);
+    }
+  },
+};
+
+export const geminiAnalyzeImages = {
+  name: "geminiAnalyzeImages",
+  description: "Analyze and describe images using Gemini 2.5 Pro with advanced multimodal understanding",
+  parameters: z.object({
+    image_paths: z.array(z.string()).describe("Array of image file paths to analyze"),
+    prompt: z.string().describe("Text prompt or question about the images"),
+  }),
+  execute: async (args: { image_paths: string[]; prompt: string }) => {
+    try {
+      // Handle array parsing
+      if (!args.image_paths) {
+        throw new Error("Image paths not provided");
+      }
+      
+      // Convert to array if passed as string
+      let imagePaths: string[];
+      if (typeof args.image_paths === 'string') {
+        const strValue = args.image_paths as string;
+        if (strValue.startsWith('[') && strValue.endsWith(']')) {
+          try {
+            imagePaths = JSON.parse(strValue);
+          } catch {
+            throw new Error("Invalid image_paths format");
+          }
+        } else {
+          imagePaths = [strValue];
+        }
+      } else if (Array.isArray(args.image_paths)) {
+        imagePaths = args.image_paths;
+      } else {
+        throw new Error("Invalid image_paths: must be array or string");
+      }
+      
+      if (imagePaths.length === 0) {
+        throw new Error("At least one image path must be provided");
+      }
+      
+      const contents: any[] = [args.prompt];
+      
+      for (const imagePath of imagePaths) {
+        contents.push(fileToGenerativePart(imagePath));
+      }
+
+      const response = await ai.models.generateContent({
+        model: "gemini-2.5-pro",
+        contents: contents,
+      });
+
+      let result = "";
+      if (response.candidates && response.candidates[0]?.content?.parts) {
+        for (const part of response.candidates[0].content.parts) {
+          if (part.text) {
+            result += part.text;
+          }
+        }
+      }
+      return result || "Analysis completed but no text response received";
+    } catch (error: any) {
+      throw new Error(`Image analysis failed: ${error.message}`);
+    }
+  },
+};
+
+export const geminiSingleSpeakerTts = {
+  name: "geminiSingleSpeakerTts",
+  description: "Generate single speaker voice audio from text using Gemini 2.5 Pro Preview TTS model",
+  parameters: z.object({
+    text: z.string().describe("Text to convert to speech"),
+    voice_name: z.string().describe("Voice name from supported options (e.g., 'Kore', 'Zephyr', 'Puck', etc.)"),
+    output_path: z.string().optional().describe("Output WAV file path (optional, defaults to timestamp-based filename)"),
+  }),
+  execute: async (args: { text: string; voice_name: string; output_path?: string }) => {
+    try {
+      const response = await ai.models.generateContent({
+        model: "gemini-2.5-pro-preview-tts",
+        contents: [{ parts: [{ text: args.text }] }],
+        config: {
+          responseModalities: ['AUDIO'],
+          speechConfig: {
+            voiceConfig: {
+              prebuiltVoiceConfig: { 
+                voiceName: args.voice_name 
+              },
+            },
+          },
+        },
+      });
+
+      const data = response.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
+      if (!data) {
+        throw new Error("No audio data received from Gemini API");
+      }
+
+      const audioBuffer = Buffer.from(data, 'base64');
+      
+      // Generate output filename if not provided
+      const outputPath = args.output_path || `voice_output_${Date.now()}.wav`;
+      
+      await saveWaveFile(outputPath, audioBuffer);
+      
+      return `Audio generated successfully: ${outputPath}`;
+    } catch (error: any) {
+      throw new Error(`Voice generation failed: ${error.message}`);
+    }
+  },
+};
+
+export const geminiAnalyzeVideos = {
+  name: "geminiAnalyzeVideos",
+  description: "Analyze and understand video content using Gemini 2.5 Flash model. Intelligently handles YouTube URLs and local videos (files <20MB processed inline, ≥20MB uploaded via File API). Supports timestamp queries, clipping, and custom frame rates with default 5 FPS for local videos to optimize processing.",
+  parameters: z.object({
+    video_inputs: z.array(z.string()).describe("Array of video inputs - mix of local file paths and YouTube URLs (max 10 videos). Local files <20MB processed inline, larger files uploaded via File API automatically."),
+    prompt: z.string().describe("Text prompt or question about the videos. Use MM:SS format for timestamp references (e.g., 'What happens at 01:30?')."),
+    fps: z.number().optional().describe("Frame rate for video processing (default: 5 FPS for local videos to reduce file size, 1 FPS for YouTube URLs)"),
+    start_offset: z.string().optional().describe("Clip start time in seconds with 's' suffix (e.g., '40s')"),
+    end_offset: z.string().optional().describe("Clip end time in seconds with 's' suffix (e.g., '80s')"),
+    media_resolution: z.string().optional().describe("Media resolution: 'default' or 'low' (low resolution uses ~100 tokens/sec vs 300 tokens/sec)"),
+  }),
+  execute: async (args: { video_inputs: string[]; prompt: string; fps?: number; start_offset?: string; end_offset?: string; media_resolution?: string }) => {
+    try {
+      // Handle array parsing
+      if (!args.video_inputs) {
+        throw new Error("Video inputs not provided");
+      }
+      
+      // Convert to array if passed as string
+      let videoInputs: string[];
+      if (typeof args.video_inputs === 'string') {
+        const strValue = args.video_inputs as string;
+        if (strValue.startsWith('[') && strValue.endsWith(']')) {
+          try {
+            videoInputs = JSON.parse(strValue);
+          } catch {
+            throw new Error("Invalid video_inputs format");
+          }
+        } else {
+          videoInputs = [strValue];
+        }
+      } else if (Array.isArray(args.video_inputs)) {
+        videoInputs = args.video_inputs;
+      } else {
+        throw new Error("Invalid video_inputs: must be array or string");
+      }
+      
+      if (videoInputs.length === 0) {
+        throw new Error("At least one video input must be provided");
+      }
+      
+      if (videoInputs.length > 10) {
+        throw new Error("Maximum 10 videos per request allowed for Gemini 2.5+ models");
+      }
+
+      // Prepare video parts for content
+      const videoParts: any[] = [];
+      
+      // Process each video input
+      for (const videoInput of videoInputs) {
+        const videoConfig = {
+          fps: args.fps || (isYouTubeUrl(videoInput) ? 1 : 5), // Default 5 FPS for local, 1 FPS for YouTube
+          startOffset: args.start_offset,
+          endOffset: args.end_offset
+        };
+        
+        const videoPart = await processVideoInput(videoInput, videoConfig);
+        videoParts.push(videoPart);
+      }
+
+      // Build content using createUserContent and createPartFromUri for uploaded files
+      const contentParts: any[] = [args.prompt];
+      
+      for (const videoPart of videoParts) {
+        if (videoPart.uri && videoPart.mimeType) {
+          contentParts.push(createPartFromUri(videoPart.uri, videoPart.mimeType));
+        }
+      }
+      
+      const finalContents = createUserContent(contentParts);
+      
+      const response = await ai.models.generateContent({
+        model: 'gemini-2.5-pro',
+        contents: finalContents,
+      });
+
+      let result = "";
+      if (response.candidates && response.candidates[0]?.content?.parts) {
+        for (const part of response.candidates[0].content.parts) {
+          if (part.text) {
+            result += part.text;
+          }
+        }
+      }
+      
+      return result || "Video analysis completed but no text response received";
+    } catch (error: any) {
+      throw new Error(`Video analysis failed: ${error.message}`);
+    }
+  },
+};

package/src/tools/hunyuan-avatar.ts

@@ -0,0 +1,102 @@
+import { z } from "zod";
+import { callFalModel } from "../utils/fal.utils";
+
+/**
+ * Calculate number of frames based on audio duration at 25 FPS
+ * Adds 1 second buffer to ensure complete audio coverage
+ */
+function calculateFramesFromAudioDuration(audioDurationSeconds: number): number {
+  const totalDuration = audioDurationSeconds + 1; // Add 1 second buffer
+  const frames = Math.round(totalDuration * 25); // 25 FPS
+  
+  // Clamp to valid range (129-401 frames)
+  return Math.max(129, Math.min(401, frames));
+}
+
+/**
+ * FAL AI Hunyuan Avatar - High-Fidelity Audio-Driven Human Animation
+ */
+export const hunyuanAvatar = {
+  name: "hunyuan_avatar",
+  description: "Generate high-fidelity audio-driven human animation videos using FAL AI Hunyuan Avatar. Creates realistic talking avatar animations from an image and audio file.",
+  parameters: z.object({
+    image_url: z.string().describe("Public URL of the reference image for the avatar."),
+    audio_url: z.string().describe("Public URL of the audio file to drive the animation."),
+    audio_duration_seconds: z.number().optional().describe("Duration of the audio in seconds. If provided, will automatically calculate optimal frames (audio duration + 1 second buffer at 25 FPS)."),
+    text: z.string().optional().describe("Text prompt describing the scene. Default: 'A cat is singing.'"),
+    num_frames: z.number().optional().describe("Number of video frames to generate at 25 FPS. Range: 129 to 401. If not provided and audio_duration_seconds is given, will be calculated automatically. Default: 129"),
+    num_inference_steps: z.number().optional().describe("Number of inference steps for sampling. Higher values give better quality but take longer. Range: 30 to 50. Default: 30"),
+    turbo_mode: z.boolean().optional().describe("If true, the video will be generated faster with no noticeable degradation in visual quality. Default: true"),
+    seed: z.number().optional().describe("Random seed for generation."),
+    fal_key: z.string().optional().describe("FAL API key. If not provided, will use FAL_KEY environment variable."),
+  }),
+  execute: async (args: {
+    image_url: string;
+    audio_url: string;
+    audio_duration_seconds?: number;
+    text?: string;
+    num_frames?: number;
+    num_inference_steps?: number;
+    turbo_mode?: boolean;
+    seed?: number;
+    fal_key?: string;
+  }) => {
+    // Calculate frames from audio duration if provided and num_frames not specified
+    let calculatedFrames = args.num_frames;
+    if (args.audio_duration_seconds !== undefined && args.num_frames === undefined) {
+      calculatedFrames = calculateFramesFromAudioDuration(args.audio_duration_seconds);
+    }
+
+    // Validate num_frames range if provided
+    if (calculatedFrames !== undefined && (calculatedFrames < 129 || calculatedFrames > 401)) {
+      throw new Error("num_frames must be between 129 and 401");
+    }
+
+    // Validate num_inference_steps range if provided
+    if (args.num_inference_steps !== undefined && (args.num_inference_steps < 30 || args.num_inference_steps > 50)) {
+      throw new Error("num_inference_steps must be between 30 and 50");
+    }
+
+    // Build input payload
+    const input: any = {
+      image_url: args.image_url,
+      audio_url: args.audio_url,
+    };
+
+    // Add optional parameters if provided
+    if (args.text !== undefined) {
+      input.text = args.text;
+    }
+    if (calculatedFrames !== undefined) {
+      input.num_frames = calculatedFrames;
+    }
+    if (args.num_inference_steps !== undefined) {
+      input.num_inference_steps = args.num_inference_steps;
+    }
+    if (args.turbo_mode !== undefined) {
+      input.turbo_mode = args.turbo_mode;
+    }
+    if (args.seed !== undefined) {
+      input.seed = args.seed;
+    }
+
+    const result = await callFalModel("fal-ai/hunyuan-avatar", input, { falKey: args.fal_key });
+
+    // Extract video data from the response
+    const videoData = result.data?.video;
+
+    if (!videoData || !videoData.url) {
+      throw new Error(`No video data in completed response: ${JSON.stringify(result.data)}`);
+    }
+
+    const videoUrl = videoData.url;
+    const fileDetails = videoData.file_name && videoData.file_size !== undefined
+      ? `\nFile: ${videoData.file_name} (${(videoData.file_size / 1024 / 1024).toFixed(2)} MB)`
+      : "";
+    const requestIdInfo = result.requestId ? `\nRequest ID: ${result.requestId}` : "";
+
+
+    return videoUrl
+    // return `✅ Hunyuan Avatar video generated successfully!\n\nVideo URL: ${videoUrl}${fileDetails}${requestIdInfo}`;
+  },
+};

package/src/tools/image-to-video.ts

@@ -0,0 +1,231 @@
+import { z } from "zod";
+import * as fs from "fs";
+import { GoogleAuth } from "google-auth-library";
+import { exec } from "child_process";
+import * as path from "path";
+
+async function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function fetchAccessToken(): Promise<string> {
+  try {
+    const auth = new GoogleAuth({ scopes: ["https://www.googleapis.com/auth/cloud-platform"] });
+    const client = await auth.getClient();
+    const token = await client.getAccessToken();
+    if (!token || !token.token || typeof token.token !== "string") {
+      throw new Error("No token from GoogleAuth");
+    }
+    return token.token;
+  } catch (e: any) {
+    // Fallback to gcloud
+    return await new Promise((resolve, reject) => {
+      exec("gcloud auth print-access-token", (err, stdout, stderr) => {
+        if (err) {
+          reject(new Error(`Failed to fetch an access token (ADC and gcloud): ${stderr || err.message}`));
+          return;
+        }
+        const t = (stdout || "").trim();
+        if (!t) {
+          reject(new Error("Failed to fetch an access token: empty token from gcloud"));
+          return;
+        }
+        resolve(t);
+      });
+    });
+  }
+}
+
+function fileToBase64(filePath: string): { data: string; mimeType: string } {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const buf = fs.readFileSync(filePath);
+  const data = Buffer.from(buf).toString("base64");
+  // Default to PNG if not sure, similar to existing code
+  const mimeType = "image/png";
+  return { data, mimeType };
+}
+
+export const imageToVideo = {
+  name: "imageToVideo",
+  description: "Generate videos from an image as starting first frame using Vertex Veo models (predictLongRunning + fetchPredictOperation).",
+  parameters: z.object({
+    prompt: z.string().describe("Text description for the video"),
+    image_path: z.string().optional().describe("Path to source image for image-to-video generation"),
+    aspect_ratio: z.string().optional().describe("Video aspect ratio: '16:9' or '9:16' (default: '9:16')"),
+    duration_seconds: z.string().optional().describe("Video duration in seconds: '4', '6', or '8' (default: '6')"),
+    resolution: z.string().optional().describe("Video resolution: '720p' or '1080p' (default: '720p')"),
+    negative_prompt: z.string().optional().describe("Text describing what not to include in the video"),
+    person_generation: z.string().optional().describe("Controls generation of people: 'allow_adult' (default for image-to-video) or 'allow_all'"),
+    reference_images: z.array(z.string()).optional().describe("Additional image paths for reference (max 3)"),
+    output_path: z.string().optional().describe("Output MP4 file path (if multiple predictions, index suffix is added)"),
+    project_id: z.string().optional().describe("GCP Project ID (default: mixio-pro)"),
+    location_id: z.string().optional().describe("Vertex region (default: us-central1)"),
+    model_id: z.string().optional().describe("Model ID (default: veo-3.1-fast-generate-preview)"),
+  }),
+  execute: async (args: {
+    prompt: string;
+    image_path?: string;
+    aspect_ratio?: string;
+    duration_seconds?: string;
+    resolution?: string;
+    negative_prompt?: string;
+    person_generation?: string;
+    reference_images?: string[];
+    output_path?: string;
+    project_id?: string;
+    location_id?: string;
+    model_id?: string;
+  }) => {
+    const projectId = args.project_id || "mixio-pro";
+    const location = args.location_id || "us-central1";
+    const modelId = args.model_id || "veo-3.1-fast-generate-preview";
+
+    const token = await fetchAccessToken();
+
+    const url = `https://${location}-aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/${modelId}:predictLongRunning`;
+
+    let imagePart: any = undefined;
+    if (args.image_path) {
+      const { data, mimeType } = fileToBase64(args.image_path);
+      imagePart = {
+        image: {
+          bytesBase64Encoded: data,
+          mimeType,
+        },
+      };
+    }
+
+    let referenceImages: any[] | undefined = undefined;
+    if (args.reference_images) {
+      let refImages: string[];
+      if (typeof args.reference_images === 'string') {
+        const strValue = args.reference_images as string;
+        if (strValue.startsWith("[") && strValue.endsWith("]")) {
+          try {
+            refImages = JSON.parse(strValue);
+          } catch {
+            throw new Error("Invalid reference_images format");
+          }
+        } else {
+          refImages = [strValue];
+        }
+      } else if (Array.isArray(args.reference_images)) {
+        refImages = args.reference_images;
+      } else {
+        throw new Error("Invalid reference_images: must be array or string");
+      }
+
+      if (refImages.length > 0) {
+        referenceImages = refImages.slice(0, 3).map((p) => {
+          const { data, mimeType } = fileToBase64(p);
+          return {
+            image: {
+              bytesBase64Encoded: data,
+              mimeType,
+            },
+            referenceType: "asset",
+          };
+        });
+      }
+    }
+
+    const personGeneration = args.person_generation || (args.image_path ? "allow_adult" : "allow_all");
+
+    const instances: any[] = [
+      {
+        prompt: args.prompt,
+        ...(imagePart || {}),
+        ...(referenceImages ? { referenceImages } : {}),
+      },
+    ];
+
+    const parameters: any = {
+      aspectRatio: args.aspect_ratio || "9:16",
+      durationSeconds: parseInt(args.duration_seconds || "6"),
+      resolution: args.resolution || "720p",
+      negativePrompt: args.negative_prompt,
+      generateAudio: false,
+      personGeneration,
+    };
+
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ instances, parameters }),
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Vertex request failed: ${res.status} ${text}`);
+    }
+
+    const op: any = await res.json();
+    const name: string = (op as any).name || (op as any).operation || "";
+    if (!name) {
+      throw new Error("Vertex did not return an operation name for long-running request");
+    }
+
+    let current: any = op;
+    let done = !!(op as any).done;
+    let tries = 0;
+
+    // Poll using fetchPredictOperation as per Vertex recommendation
+    const fetchUrl = `https://${location}-aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/${modelId}:fetchPredictOperation`;
+    while (!done && tries < 60) {
+      await wait(10000);
+      const poll = await fetch(fetchUrl, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ operationName: name }),
+      });
+      if (!poll.ok) {
+        const text = await poll.text();
+        throw new Error(`Vertex operation poll failed: ${poll.status} ${text}`);
+      }
+      current = await poll.json();
+      done = !!(current as any).done || !!(current as any).response;
+      tries++;
+    }
+
+    const resp = (current as any).response || current;
+    // Decode from response.videos[].bytesBase64Encoded only
+    const outputs: string[] = [];
+    const saveVideo = (base64: string, index: number) => {
+      if (!base64) return;
+      const filePath = args.output_path
+        ? (index === 0 ? args.output_path : args.output_path.replace(/\.mp4$/i, `_${index}.mp4`))
+        : `video_output_${Date.now()}${index === 0 ? '' : '_' + index}.mp4`;
+      const absPath = path.resolve(filePath);
+      const buf = Buffer.from(base64, 'base64');
+      fs.writeFileSync(absPath, buf);
+      outputs.push(absPath);
+    };
+
+    if (Array.isArray(resp?.videos) && resp.videos.length > 0) {
+      for (let i = 0; i < resp.videos.length; i++) {
+        const v = resp.videos[i] || {};
+        if (typeof v.bytesBase64Encoded === 'string') {
+          saveVideo(v.bytesBase64Encoded, i);
+        }
+      }
+    }
+    if (outputs.length > 0) {
+      return `Video(s) saved: ${outputs.join(', ')}`;
+    }
+
+    // If nothing saved, return a concise summary plus head/tail snippets of JSON
+    let jsonStr = "";
+    try { jsonStr = JSON.stringify(resp); } catch {}
+    const head150 = jsonStr ? jsonStr.slice(0, 150) : "";
+    const tail50 = jsonStr ? jsonStr.slice(Math.max(0, jsonStr.length - 50)) : "";
+    return `Vertex operation done but no videos array present. operationName=${name}. json_head150=${head150} json_tail50=${tail50}`;
+  },
+};

package/src/tools/infinitalk.ts

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { callFalModel } from "../utils/fal.utils";
+
+/**
+ * Calculate number of frames based on audio duration at 25 FPS
+ * Adds 1 second buffer to ensure complete audio coverage
+ */
+function calculateFramesFromAudioDuration(audioDurationSeconds: number): number {
+  const totalDuration = audioDurationSeconds + 1; // Add 1 second buffer
+  const frames = Math.round(totalDuration * 25); // 25 FPS
+  
+  // Clamp to valid range (41-721 frames)
+  return Math.max(41, Math.min(721, frames));
+}
+
+/**
+ * FAL AI Infinitalk - Generate talking avatar video from image and audio
+ */
+export const infinitalk = {
+  name: "infinitalk",
+  description: "Generate a talking avatar video from an image and audio file using FAL AI Infinitalk. The avatar lip-syncs to the provided audio with natural facial expressions.",
+  parameters: z.object({
+    image_url: z.string().describe("Public URL of the input image. If the input image does not match the chosen aspect ratio, it is resized and center cropped."),
+    audio_url: z.string().describe("The Public URL of the audio file for lip-sync generation."),
+    audio_duration_seconds: z.number().optional().describe("Duration of the audio in seconds. If provided, will automatically calculate optimal frames (audio duration + 1 second buffer at 25 FPS)."),
+    prompt: z.string().describe("The text prompt to guide video generation (e.g., 'A woman with colorful hair talking on a podcast')"),
+    num_frames: z.number().optional().describe("Number of frames to generate. Must be between 41 to 721. If not provided and audio_duration_seconds is given, will be calculated automatically. Default: 145"),
+    resolution: z.enum(["480p", "720p"]).optional().describe("Resolution of the video to generate. Default: '480p'"),
+    seed: z.number().optional().describe("Random seed for reproducibility. If not provided, a random seed is chosen. Default: 42"),
+    acceleration: z.enum(["none", "regular", "high"]).optional().describe("The acceleration level to use for generation. Default: 'regular'"),
+    fal_key: z.string().optional().describe("FAL API key. If not provided, will use FAL_KEY environment variable."),
+  }),
+  execute: async (args: {
+    image_url: string;
+    audio_url: string;
+    audio_duration_seconds?: number;
+    prompt: string;
+    num_frames?: number;
+    resolution?: "480p" | "720p";
+    seed?: number;
+    acceleration?: "none" | "regular" | "high";
+    fal_key?: string;
+  }) => {
+    // Calculate frames from audio duration if provided and num_frames not specified
+    let calculatedFrames = args.num_frames;
+    if (args.audio_duration_seconds !== undefined && args.num_frames === undefined) {
+      calculatedFrames = calculateFramesFromAudioDuration(args.audio_duration_seconds);
+    }
+
+    // Validate num_frames range if provided
+    if (calculatedFrames !== undefined && (calculatedFrames < 41 || calculatedFrames > 721)) {
+      throw new Error("num_frames must be between 41 and 721");
+    }
+
+    // Build input payload
+    const input: any = {
+      image_url: args.image_url,
+      audio_url: args.audio_url,
+      prompt: args.prompt,
+    };
+
+    // Add optional parameters if provided
+    if (calculatedFrames !== undefined) {
+      input.num_frames = calculatedFrames;
+    }
+    
+    input.resolution = args.resolution || '480p';
+    
+    if (args.seed !== undefined) {
+      input.seed = args.seed;
+    }
+    if (args.acceleration !== undefined) {
+      input.acceleration = args.acceleration;
+    }
+
+    const result = await callFalModel("fal-ai/infinitalk", input, { falKey: args.fal_key });
+
+    // Extract video data from the response
+    const videoData = result.data?.video;
+    const seed = result.data?.seed;
+
+    if (!videoData || !videoData.url) {
+      throw new Error(`No video data in completed response: ${JSON.stringify(result.data)}`);
+    }
+
+    const videoUrl = videoData.url;
+    const fileDetails = videoData.file_name && videoData.file_size !== undefined
+      ? `\nFile: ${videoData.file_name} (${(videoData.file_size / 1024 / 1024).toFixed(2)} MB)`
+      : "";
+    const seedInfo = seed !== undefined ? `\nSeed: ${seed}` : "";
+    const requestIdInfo = result.requestId ? `\nRequest ID: ${result.requestId}` : "";
+
+    return videoUrl
+    // return `✅ Infinitalk video generated successfully!\n\nVideo URL: ${videoUrl}${fileDetails}${seedInfo}${requestIdInfo}`;
+  },
+};

package/src/tools/perplexity.ts

@@ -0,0 +1,190 @@
+import { z } from "zod";
+
+export const perplexityImages = {
+  name: "perplexityImages",
+  description: "Searches for images using the Perplexity API. Returns a formatted text response that includes a summary and a numbered list of image URLs with citations mapped to the text.",
+  parameters: z.object({
+    query: z.string().describe("The search query for images."),
+    image_domain_filter: z.array(z.string()).optional().describe("A list of domains to include or exclude. To exclude, prefix with '-'. E.g., ['wikimedia.org', '-gettyimages.com']."),
+    image_format_filter: z.array(z.string()).optional().describe("A list of allowed image formats. E.g., ['jpg', 'png', 'gif']."),
+  }),
+  execute: async (args: { query: string; image_domain_filter?: string[]; image_format_filter?: string[] }) => {
+    const apiKey = process.env.PERPLEXITY_API_KEY;
+    if (!apiKey) {
+      throw new Error("PERPLEXITY_API_KEY environment variable is not set.");
+    }
+
+    const url = "https://api.perplexity.ai/chat/completions";
+    const headers = {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "accept": "application/json"
+    };
+
+    const payload: any = {
+      model: "sonar",
+      messages: [
+        { role: "user", content: `Show me images of ${args.query}` }
+      ],
+      return_images: true
+    };
+
+    if (args.image_domain_filter) {
+      payload.image_domain_filter = args.image_domain_filter;
+    }
+    
+    if (args.image_format_filter) {
+      payload.image_format_filter = args.image_format_filter;
+    }
+
+    const res = await fetch(url, {
+      method: "POST",
+      headers: headers,
+      body: JSON.stringify(payload),
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Perplexity API request failed: ${res.status} ${text}`);
+    }
+
+    const data: any = await res.json();
+    let content = data.choices?.[0]?.message?.content;
+    const images = data.images;
+    const citations = data.citations;
+
+    if (!images || images.length === 0) {
+      return `No direct image URLs found in the API response. The text content was: ${content}`;
+    }
+
+    // Create a map of origin_url -> new 1-based index
+    const originUrlToImageIndex: { [key: string]: number } = {};
+    images.forEach((img: any, index: number) => {
+      if (img.origin_url) {
+        originUrlToImageIndex[img.origin_url] = index + 1;
+      }
+    });
+
+    // Create a map of old citation index -> new image index
+    const oldToNewCitationMap: { [key: number]: number } = {};
+    if (citations && Array.isArray(citations)) {
+        citations.forEach((citationUrl: string, index: number) => {
+            if (originUrlToImageIndex[citationUrl]) {
+                oldToNewCitationMap[index + 1] = originUrlToImageIndex[citationUrl];
+            }
+        });
+    }
+
+    // Replace citations in the content
+    if (content && typeof content === 'string') {
+        content = content.replace(/\[(\d+)\]/g, (match: string, oldIndexStr: string) => {
+            const oldIndex = parseInt(oldIndexStr, 10);
+            const newIndex = oldToNewCitationMap[oldIndex];
+            if (newIndex) {
+                return `[${newIndex}]`;
+            }
+            return ''; // Remove citation if it doesn't correspond to an image
+        }).replace(/(\s\s+)/g, ' ').trim(); // Clean up extra spaces
+    }
+    
+    // Build the final formatted output
+    let output = content + "\n\n--- Images ---\n";
+    images.forEach((img: any, index: number) => {
+      output += `${index + 1}. ${img.image_url}\n   (Source: ${img.origin_url})\n`;
+    });
+
+    return output;
+  },
+};
+
+export const perplexityVideos = {
+  name: "perplexityVideos",
+  description: "Searches for videos using the Perplexity API. Returns a formatted text response that includes a summary and a numbered list of video URLs with citations mapped to the text.",
+  parameters: z.object({
+    query: z.string().describe("The search query for videos."),
+    search_domain_filter: z.array(z.string()).optional().describe("A list of domains to limit the search to (e.g., ['youtube.com']). Use a '-' prefix to exclude a domain."),
+  }),
+  execute: async (args: { query: string; search_domain_filter?: string[] }) => {
+    const apiKey = process.env.PERPLEXITY_API_KEY;
+    if (!apiKey) {
+      throw new Error("PERPLEXITY_API_KEY environment variable is not set.");
+    }
+
+    const url = "https://api.perplexity.ai/chat/completions";
+    const headers = {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "accept": "application/json"
+    };
+
+    const payload: any = {
+      model: "sonar-pro",
+      messages: [
+        { role: "user", content: `Show me videos of ${args.query}` }
+      ],
+      media_response: { overrides: { return_videos: true } }
+    };
+
+    if (args.search_domain_filter) {
+      payload.search_domain_filter = args.search_domain_filter;
+    }
+
+    const res = await fetch(url, {
+      method: "POST",
+      headers: headers,
+      body: JSON.stringify(payload),
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Perplexity API request failed: ${res.status} ${text}`);
+    }
+
+    const data: any = await res.json();
+    let content = data.choices?.[0]?.message?.content;
+    const videos = data.videos;
+    const citations = data.citations;
+
+    if (!videos || videos.length === 0) {
+      return `No direct video URLs found in the API response. Full API Response: ${JSON.stringify(data, null, 2)}`;
+    }
+
+    // Create a map of video url -> new 1-based index
+    const urlToVideoIndex: { [key: string]: number } = {};
+    videos.forEach((video: any, index: number) => {
+      if (video.url) {
+        urlToVideoIndex[video.url] = index + 1;
+      }
+    });
+
+    // Create a map of old citation index -> new video index
+    const oldToNewCitationMap: { [key: number]: number } = {};
+    if (citations && Array.isArray(citations)) {
+        citations.forEach((citationUrl: string, index: number) => {
+            if (urlToVideoIndex[citationUrl]) {
+                oldToNewCitationMap[index + 1] = urlToVideoIndex[citationUrl];
+            }
+        });
+    }
+
+    // Replace citations in the content
+    if (content && typeof content === 'string') {
+        content = content.replace(/\[(\d+)\]/g, (match: string, oldIndexStr: string) => {
+            const oldIndex = parseInt(oldIndexStr, 10);
+            const newIndex = oldToNewCitationMap[oldIndex];
+            if (newIndex) {
+                return `[${newIndex}]`;
+            }
+            return ''; // Remove citation if it doesn't correspond to a video
+        }).replace(/(\s\s+)/g, ' ').trim(); // Clean up extra spaces
+    }
+    
+    // Build the final formatted output
+    let output = content + "\n\n--- Videos ---\n";
+    videos.forEach((video: any, index: number) => {
+      output += `${index + 1}. ${video.url}\n`;
+    });
+
+    return output;
+  },
+};

package/src/tools/youtube.ts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { GoogleGenAI } from "@google/genai";
+
+const ai = new GoogleGenAI({
+  apiKey: process.env.GEMINI_API_KEY || "",
+});
+
+export const analyzeYoutubeVideo = {
+  name: "analyzeYoutubeVideo",
+  description: "Analyze YouTube videos for content using the correct GenAI JS API approach with FileData fileUri. Perfect for extracting stock media content, analyzing video content, or getting descriptions of YouTube videos",
+  parameters: z.object({
+    youtube_url: z.string().describe("YouTube video URL to analyze (format: https://www.youtube.com/watch?v=VIDEO_ID)"),
+    prompt: z.string().describe("Analysis prompt or question about the YouTube video content"),
+  }),
+  execute: async (args: { youtube_url: string; prompt: string }) => {
+    try {
+      // Validate YouTube URL format
+      if (!args.youtube_url || (!args.youtube_url.includes('youtube.com/watch') && !args.youtube_url.includes('youtu.be'))) {
+        throw new Error("Invalid YouTube URL format. Expected: https://www.youtube.com/watch?v=VIDEO_ID");
+      }
+
+      // Create content using the correct FileData approach with fileUri
+      const response = await ai.models.generateContent({
+        model: 'models/gemini-2.5-flash',
+        contents: {
+          parts: [
+            {
+              fileData: {
+                fileUri: args.youtube_url
+              }
+            },
+            { text: args.prompt }
+          ]
+        }
+      });
+
+      let result = "";
+      if (response.candidates && response.candidates[0]?.content?.parts) {
+        for (const part of response.candidates[0].content.parts) {
+          if (part.text) {
+            result += part.text;
+          }
+        }
+      }
+      
+      return result || "YouTube video analysis completed but no text response received";
+      
+    } catch (error: any) {
+      throw new Error(`YouTube video analysis failed: ${error.message}`);
+    }
+  },
+};

package/src/utils/fal.utils.ts

@@ -0,0 +1,45 @@
+import { fal } from "@fal-ai/client";
+
+export async function callFalModel(
+  modelName: string,
+  input: any,
+  options: { falKey?: string; logs?: boolean } = {}
+) {
+  const { falKey, logs = true } = options;
+  const key = falKey || process.env.FAL_KEY;
+  if (!key) {
+    throw new Error("FAL_KEY is required. Provide it via fal_key parameter or FAL_KEY environment variable.");
+  }
+
+  fal.config({
+    credentials: key,
+  });
+
+  console.log(`[${modelName}] Submitting request to FAL AI...`);
+
+  try {
+    const result = await fal.subscribe(modelName, {
+      input,
+      logs,
+      onQueueUpdate: (update) => {
+        if (update.status === "IN_PROGRESS") {
+          console.log(`[${modelName}] Status: ${update.status}`);
+          if (logs && "logs" in update && update.logs) {
+            update.logs.forEach((log) => {
+              console.log(`[${modelName}] ${log.message}`);
+            });
+          }
+        } else if (update.status === "IN_QUEUE") {
+          console.log(`[${modelName}] Status: ${update.status} - Waiting in queue...`);
+        }
+      },
+    });
+
+    console.log(`[${modelName}] Generation completed successfully`);
+
+    return result;
+  } catch (error: any) {
+    console.error(`[${modelName}] Error:`, error);
+    throw new Error(`FAL AI ${modelName} generation failed: ${error.message || JSON.stringify(error)}`);
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './fal.utils'