@mixio-pro/kalaasetu-mcp 1.1.1 → 1.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mixio-pro/kalaasetu-mcp",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "A powerful Model Context Protocol server providing AI tools for content generation and analysis",
   "type": "module",
   "module": "src/index.ts",

package/src/index.ts

@@ -1,21 +1,21 @@
 #!/usr/bin/env bun
 import { FastMCP } from "fastmcp";
-import {
-  geminiTextToImage,
-  geminiEditImage,
-  geminiAnalyzeImages,
-  geminiSingleSpeakerTts,
-  geminiAnalyzeVideos,
-} from "./tools/gemini";
-import { analyzeYoutubeVideo } from "./tools/youtube";
+import { geminiEditImage, geminiTextToImage } from "./tools/gemini";
 import { imageToVideo } from "./tools/image-to-video";
-import { infinitalk } from "./tools/infinitalk";
-import { hunyuanAvatar } from "./tools/hunyuan-avatar";
-import { perplexityImages, perplexityVideos } from "./tools/perplexity";
+import {
+  falListModels,
+  falSearchModels,
+  falGetSchema,
+  falGenerateContent,
+  falGetResult,
+  falGetStatus,
+  falCancelRequest,
+  falUploadFile,
+} from "./tools/fal";
 
 const server = new FastMCP({
   name: "Kalaasetu MCP Server",
-  version: "1.0.0",
+  version: "1.1.0",
 });
 
 // Gemini Image Tools
@@ -27,7 +27,7 @@ server.addTool(geminiEditImage);
 // server.addTool(geminiSingleSpeakerTts);
 
 // Gemini Video Analysis Tool
-server.addTool(geminiAnalyzeVideos);
+// server.addTool(geminiAnalyzeVideos);
 
 // YouTube Analyzer Tool
 // server.addTool(analyzeYoutubeVideo);
@@ -35,16 +35,20 @@ server.addTool(geminiAnalyzeVideos);
 // 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);
 
+// Fal AI Tools
+server.addTool(falListModels);
+server.addTool(falSearchModels);
+server.addTool(falGetSchema);
+server.addTool(falGenerateContent);
+server.addTool(falGetResult);
+server.addTool(falGetStatus);
+server.addTool(falCancelRequest);
+server.addTool(falUploadFile);
+
 server.start({
   transportType: "stdio",
 });

package/src/tools/fal/config.ts

@@ -0,0 +1,34 @@
+/**
+ * Configuration module for the fal.ai MCP server.
+ * Provides centralized configuration settings for API endpoints, timeouts, and server metadata.
+ */
+
+// API URLs
+export const FAL_BASE_URL = "https://fal.ai/api";
+export const FAL_QUEUE_URL = "https://queue.fal.run";
+export const FAL_DIRECT_URL = "https://fal.run";
+export const FAL_REST_URL = "https://rest.alpha.fal.ai";
+
+// Timeouts (in milliseconds)
+export const DEFAULT_TIMEOUT = 30000;
+export const AUTHENTICATED_TIMEOUT = 600000; // 10 minutes for long-running operations
+
+// Environment variable names
+export const API_KEY_ENV_VAR = "FAL_KEY";
+
+// Server metadata
+export const SERVER_NAME = "fal.ai MCP Server";
+export const SERVER_DESCRIPTION =
+  "Access fal.ai models and generate content through MCP";
+export const SERVER_VERSION = "1.0.0";
+
+/**
+ * Get the fal.ai API key from environment variables.
+ */
+export function getApiKey(): string {
+  const apiKey = process.env[API_KEY_ENV_VAR];
+  if (!apiKey) {
+    throw new Error(`${API_KEY_ENV_VAR} environment variable not set`);
+  }
+  return apiKey;
+}

package/src/tools/fal/generate.ts

@@ -0,0 +1,141 @@
+/**
+ * Generate module for fal.ai MCP server.
+ * Provides tools for generating content and managing queue operations with fal.ai models.
+ */
+
+import { z } from "zod";
+import {
+  FAL_QUEUE_URL,
+  FAL_DIRECT_URL,
+  AUTHENTICATED_TIMEOUT,
+  getApiKey,
+} from "./config";
+
+/**
+ * Make an authenticated request to fal.ai API.
+ */
+async function authenticatedRequest(
+  url: string,
+  method: "GET" | "POST" | "PUT" = "GET",
+  jsonData?: Record<string, any>
+): Promise<any> {
+  const headers: Record<string, string> = {
+    Authorization: `Key ${getApiKey()}`,
+    "Content-Type": "application/json",
+  };
+
+  const options: RequestInit = {
+    method,
+    headers,
+    signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+  };
+
+  if (jsonData && (method === "POST" || method === "PUT")) {
+    options.body = JSON.stringify(jsonData);
+  }
+
+  const response = await fetch(url, options);
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`[${response.status}] API error: ${errorText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Sanitize parameters by removing null/undefined values.
+ */
+function sanitizeParameters(
+  parameters: Record<string, any>
+): Record<string, any> {
+  return Object.fromEntries(
+    Object.entries(parameters).filter(([_, v]) => v != null)
+  );
+}
+
+/**
+ * Generate content using a fal.ai model.
+ */
+export const falGenerateContent = {
+  name: "fal_generate_content",
+  description:
+    "Generate content using any fal.ai model. Supports both direct execution and queued execution for long-running tasks.",
+  parameters: z.object({
+    model: z.string().describe('The model ID to use (e.g., "fal-ai/flux/dev")'),
+    parameters: z
+      .record(z.string(), z.any())
+      .describe("Model-specific parameters as a dictionary"),
+    queue: z
+      .boolean()
+      .optional()
+      .default(false)
+      .describe(
+        "Whether to use the queuing system for long-running tasks. Default: false"
+      ),
+  }),
+  execute: async (args: {
+    model: string;
+    parameters: Record<string, any>;
+    queue?: boolean;
+  }) => {
+    const sanitizedParams = sanitizeParameters(args.parameters);
+
+    const baseUrl = args.queue ? FAL_QUEUE_URL : FAL_DIRECT_URL;
+    const url = `${baseUrl}/${args.model}`;
+
+    console.error(`[fal_generate] Submitting request to ${url}...`);
+
+    const result = await authenticatedRequest(url, "POST", sanitizedParams);
+
+    console.error(`[fal_generate] Request completed successfully`);
+
+    return JSON.stringify(result);
+  },
+};
+
+/**
+ * Get the result of a queued request.
+ */
+export const falGetResult = {
+  name: "fal_get_result",
+  description: "Get the result of a queued fal.ai request.",
+  parameters: z.object({
+    url: z.string().describe("The response_url from a queued request"),
+  }),
+  execute: async (args: { url: string }) => {
+    const result = await authenticatedRequest(args.url, "GET");
+    return JSON.stringify(result);
+  },
+};
+
+/**
+ * Check the status of a queued request.
+ */
+export const falGetStatus = {
+  name: "fal_get_status",
+  description: "Check the status of a queued fal.ai request.",
+  parameters: z.object({
+    url: z.string().describe("The status_url from a queued request"),
+  }),
+  execute: async (args: { url: string }) => {
+    const result = await authenticatedRequest(args.url, "GET");
+    return JSON.stringify(result);
+  },
+};
+
+/**
+ * Cancel a queued request.
+ */
+export const falCancelRequest = {
+  name: "fal_cancel_request",
+  description: "Cancel a queued fal.ai request.",
+  parameters: z.object({
+    url: z.string().describe("The cancel_url from a queued request"),
+  }),
+  execute: async (args: { url: string }) => {
+    const result = await authenticatedRequest(args.url, "PUT");
+    return JSON.stringify(result);
+  },
+};

package/src/tools/fal/index.ts

@@ -0,0 +1,14 @@
+/**
+ * fal.ai MCP Tools
+ * Export all fal.ai tools for registration with the MCP server.
+ */
+
+export { falListModels, falSearchModels, falGetSchema } from "./models";
+export {
+  falGenerateContent,
+  falGetResult,
+  falGetStatus,
+  falCancelRequest,
+} from "./generate";
+export { falUploadFile } from "./storage";
+export { SERVER_NAME, SERVER_DESCRIPTION, SERVER_VERSION } from "./config";

package/src/tools/fal/models.ts

@@ -0,0 +1,95 @@
+/**
+ * Models module for fal.ai MCP server.
+ * Provides tools for listing, searching, and retrieving schemas for fal.ai models.
+ */
+
+import { z } from "zod";
+import { FAL_BASE_URL, DEFAULT_TIMEOUT } from "./config";
+
+/**
+ * Make a non-authenticated request to fal.ai API.
+ */
+async function publicRequest(url: string): Promise<any> {
+  const response = await fetch(url, {
+    method: "GET",
+    signal: AbortSignal.timeout(DEFAULT_TIMEOUT),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`[${response.status}] API error: ${errorText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * List available models on fal.ai with optional pagination.
+ */
+export const falListModels = {
+  name: "fal_list_models",
+  description:
+    "List available models on fal.ai. Use the page and total arguments for pagination. Avoid listing all models at once.",
+  parameters: z.object({
+    page: z
+      .number()
+      .optional()
+      .describe("The page number of models to retrieve (pagination)"),
+    total: z
+      .number()
+      .optional()
+      .describe("The total number of models to retrieve per page"),
+  }),
+  execute: async (args: { page?: number; total?: number }) => {
+    let url = `${FAL_BASE_URL}/models`;
+
+    const params: string[] = [];
+    if (args.page !== undefined) params.push(`page=${args.page}`);
+    if (args.total !== undefined) params.push(`total=${args.total}`);
+
+    if (params.length > 0) {
+      url += "?" + params.join("&");
+    }
+
+    const result = await publicRequest(url);
+    return JSON.stringify(result);
+  },
+};
+
+/**
+ * Search for models on fal.ai based on keywords.
+ */
+export const falSearchModels = {
+  name: "fal_search_models",
+  description: "Search for models on fal.ai based on keywords.",
+  parameters: z.object({
+    keywords: z.string().describe("The search terms to find models"),
+  }),
+  execute: async (args: { keywords: string }) => {
+    const url = `${FAL_BASE_URL}/models?keywords=${encodeURIComponent(
+      args.keywords
+    )}`;
+    const result = await publicRequest(url);
+    return JSON.stringify(result);
+  },
+};
+
+/**
+ * Get the OpenAPI schema for a specific model.
+ */
+export const falGetSchema = {
+  name: "fal_get_schema",
+  description: "Get the OpenAPI schema for a specific fal.ai model.",
+  parameters: z.object({
+    model_id: z
+      .string()
+      .describe('The ID of the model (e.g., "fal-ai/flux/dev")'),
+  }),
+  execute: async (args: { model_id: string }) => {
+    const url = `${FAL_BASE_URL}/openapi/queue/openapi.json?endpoint_id=${encodeURIComponent(
+      args.model_id
+    )}`;
+    const result = await publicRequest(url);
+    return JSON.stringify(result);
+  },
+};

package/src/tools/fal/storage.ts

@@ -0,0 +1,116 @@
+/**
+ * Storage module for fal.ai MCP server.
+ * Provides tools for uploading files to fal.ai storage.
+ */
+
+import { z } from "zod";
+import * as fs from "fs";
+import * as path from "path";
+import { FAL_REST_URL, AUTHENTICATED_TIMEOUT, getApiKey } from "./config";
+
+/**
+ * Get MIME type from file extension.
+ */
+function getMimeType(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeTypes: Record<string, string> = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mov": "video/quicktime",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".pdf": "application/pdf",
+    ".json": "application/json",
+    ".txt": "text/plain",
+  };
+  return mimeTypes[ext] || "application/octet-stream";
+}
+
+/**
+ * Upload a file to fal.ai storage.
+ */
+export const falUploadFile = {
+  name: "fal_upload_file",
+  description: "Upload a file to fal.ai CDN storage.",
+  parameters: z.object({
+    path: z.string().describe("The absolute path to the file to upload"),
+  }),
+  execute: async (args: { path: string }) => {
+    // Validate file exists
+    if (!fs.existsSync(args.path)) {
+      throw new Error(`File not found: ${args.path}`);
+    }
+
+    const filename = path.basename(args.path);
+    const fileSize = fs.statSync(args.path).size;
+    const contentType = getMimeType(args.path);
+
+    // Step 1: Initiate upload
+    const initiateUrl = `${FAL_REST_URL}/storage/upload/initiate?storage_type=fal-cdn-v3`;
+    const initiatePayload = {
+      content_type: contentType,
+      file_name: filename,
+    };
+
+    console.error(`[fal_upload] Initiating upload for ${filename}...`);
+
+    const initiateResponse = await fetch(initiateUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Key ${getApiKey()}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(initiatePayload),
+      signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+    });
+
+    if (!initiateResponse.ok) {
+      const errorText = await initiateResponse.text();
+      throw new Error(
+        `[${initiateResponse.status}] Failed to initiate upload: ${errorText}`
+      );
+    }
+
+    const initiateData = (await initiateResponse.json()) as {
+      file_url: string;
+      upload_url: string;
+    };
+    const { file_url, upload_url } = initiateData;
+
+    // Step 2: Upload file content
+    console.error(`[fal_upload] Uploading file content...`);
+
+    const fileContent = fs.readFileSync(args.path);
+
+    const uploadResponse = await fetch(upload_url, {
+      method: "PUT",
+      headers: {
+        "Content-Type": contentType,
+      },
+      body: fileContent,
+      signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+    });
+
+    if (!uploadResponse.ok) {
+      const errorText = await uploadResponse.text();
+      throw new Error(
+        `[${uploadResponse.status}] Failed to upload file: ${errorText}`
+      );
+    }
+
+    console.error(`[fal_upload] Upload completed successfully`);
+
+    return JSON.stringify({
+      file_url,
+      file_name: filename,
+      file_size: fileSize,
+      content_type: contentType,
+    });
+  },
+};

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

@@ -1,6 +1,3 @@
-import { GoogleAuth } from "google-auth-library";
-import { exec } from "child_process";
-import * as path from "path";
 import { z } from "zod";
 import { getStorage } from "../storage";
 import { generateTimestampedFilename } from "../utils/filename";
@@ -57,10 +54,12 @@ export const imageToVideo = {
     aspect_ratio: z
       .string()
       .optional()
-      .describe("Video aspect ratio: '16:9' or '9:16' (default: '9:16')"),
+      .default("16:9")
+      .describe("Video aspect ratio: '16:9' or '9:16'"),
     duration_seconds: z
       .string()
       .optional()
+      .default("6")
       .describe(
         "Video duration in seconds. MUST be one of: '4', '6', or '8' (default: '6'). Other values will be rejected by Vertex AI."
       ),
@@ -91,15 +90,18 @@ export const imageToVideo = {
     project_id: z
       .string()
       .optional()
+      .default("mixio-pro")
       .describe("GCP Project ID (default: mixio-pro)"),
     location_id: z
       .string()
       .optional()
+      .default("us-central1")
       .describe("Vertex region (default: us-central1)"),
     model_id: z
       .string()
       .optional()
-      .describe("Model ID (default: veo-3.1-fast-generate-preview)"),
+      .default("veo-3.1-fast-generate-001")
+      .describe("Model ID (default: veo-3.1-fast-generate-001)"),
     generate_audio: z
       .boolean()
       .optional()

package/src/utils/index.ts

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

package/src/tools/hunyuan-avatar.ts

@@ -1,160 +0,0 @@
-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 fileName = videoData.file_name || "hunyuan_avatar.mp4";
-
-    return JSON.stringify({
-      videos: [
-        {
-          url: videoUrl,
-          filename: fileName,
-          mimeType: "video/mp4",
-          filesize: videoData.file_size,
-        },
-      ],
-      message: "Hunyuan Avatar video generated successfully",
-      requestId: result.requestId,
-    });
-  },
-};

package/src/tools/infinitalk.ts

@@ -1,156 +0,0 @@
-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 fileName = videoData.file_name || "infinitalk.mp4";
-
-    return JSON.stringify({
-      videos: [
-        {
-          url: videoUrl,
-          filename: fileName,
-          mimeType: "video/mp4",
-          filesize: videoData.file_size,
-        },
-      ],
-      message: "Infinitalk video generated successfully",
-      seed: seed,
-      requestId: result.requestId,
-    });
-  },
-};

package/src/utils/fal.utils.ts

@@ -1,53 +0,0 @@
-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.error(`[${modelName}] Submitting request to FAL AI...`);
-
-  try {
-    const result = await fal.subscribe(modelName, {
-      input,
-      logs,
-      onQueueUpdate: (update) => {
-        if (update.status === "IN_PROGRESS") {
-          console.error(`[${modelName}] Status: ${update.status}`);
-          if (logs && "logs" in update && update.logs) {
-            update.logs.forEach((log) => {
-              console.error(`[${modelName}] ${log.message}`);
-            });
-          }
-        } else if (update.status === "IN_QUEUE") {
-          console.error(
-            `[${modelName}] Status: ${update.status} - Waiting in queue...`
-          );
-        }
-      },
-    });
-
-    console.error(`[${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)
-      }`
-    );
-  }
-}