@mixio-pro/kalaasetu-mcp 1.0.6 → 1.0.8

package/README.md

@@ -68,7 +68,9 @@ Add to your Cursor settings (`~/.cursor/config.json` or via Settings → MCP):
       "env": {
         "GEMINI_API_KEY": "your-gemini-api-key",
         "FAL_KEY": "your-fal-api-key",
-        "PERPLEXITY_API_KEY": "your-perplexity-api-key"
+        "PERPLEXITY_API_KEY": "your-perplexity-api-key", 
+        "STORAGE_PROVIDER":"gcs",
+        "GCS_BUCKET":"your-gcs-bucket-name"
       }
     }
   }
@@ -88,7 +90,9 @@ Add to your OpenCode MCP configuration:
       "environment": {
         "GEMINI_API_KEY": "your-gemini-api-key",
         "FAL_KEY": "your-fal-api-key",
-        "PERPLEXITY_API_KEY": "your-perplexity-api-key"
+        "PERPLEXITY_API_KEY": "your-perplexity-api-key", 
+        "STORAGE_PROVIDER":"gcs",
+        "GCS_BUCKET":"your-bucket-name"
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mixio-pro/kalaasetu-mcp",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "A powerful Model Context Protocol server providing AI tools for content generation and analysis",
   "type": "module",
   "module": "src/index.ts",
@@ -49,8 +49,10 @@
   "dependencies": {
     "@fal-ai/client": "^1.7.2",
     "@google/genai": "^1.28.0",
+    "@types/node": "^24.10.1",
     "@types/wav": "^1.0.4",
     "fastmcp": "^3.22.0",
+    "form-data": "^4.0.5",
     "google-auth-library": "^10.5.0",
     "wav": "^1.0.2",
     "zod": "^4.1.12"

package/src/storage/gcs.ts

@@ -0,0 +1,116 @@
+import { GoogleAuth } from "google-auth-library";
+import type { StorageProvider } from "./interface";
+import * as path from "path";
+
+export class GCSStorageProvider implements StorageProvider {
+  private bucket: string;
+  private auth: GoogleAuth;
+
+  constructor(bucket: string) {
+    this.bucket = bucket;
+    this.auth = new GoogleAuth({
+      scopes: ["https://www.googleapis.com/auth/cloud-platform"],
+    });
+  }
+
+  async init(): Promise<void> {
+    console.log(
+      `Initializing GCS Storage Provider with bucket: ${this.bucket}`
+    );
+    // Verify we can get credentials
+    try {
+      await this.auth.getClient();
+    } catch (error) {
+      console.warn(`Warning: Could not initialize GCS client: ${error}`);
+    }
+  }
+
+  private async getAccessToken(): Promise<string> {
+    const client = await this.auth.getClient();
+    const token = await client.getAccessToken();
+    if (!token.token) {
+      throw new Error("Failed to get GCS access token");
+    }
+    return token.token;
+  }
+
+  async readFile(filePath: string): Promise<Buffer> {
+    const objectName = path.basename(filePath);
+    const url = `https://storage.googleapis.com/storage/v1/b/${
+      this.bucket
+    }/o/${encodeURIComponent(objectName)}?alt=media`;
+
+    const token = await this.getAccessToken();
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to read file from GCS: ${response.status} ${response.statusText}`
+      );
+    }
+
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  }
+
+  async writeFile(filePath: string, data: Buffer | string): Promise<string> {
+    const objectName = path.basename(filePath);
+    const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+
+    // Upload using JSON API
+    const url = `https://storage.googleapis.com/upload/storage/v1/b/${
+      this.bucket
+    }/o?uploadType=media&name=${encodeURIComponent(objectName)}`;
+
+    const token = await this.getAccessToken();
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/octet-stream",
+        "Content-Length": buffer.length.toString(),
+      },
+      body: buffer,
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Failed to upload to GCS: ${response.status} ${errorText}`
+      );
+    }
+
+    // Return public URL
+    return `https://storage.googleapis.com/${this.bucket}/${objectName}`;
+  }
+
+  async exists(filePath: string): Promise<boolean> {
+    try {
+      const objectName = path.basename(filePath);
+      const url = `https://storage.googleapis.com/storage/v1/b/${
+        this.bucket
+      }/o/${encodeURIComponent(objectName)}`;
+
+      const token = await this.getAccessToken();
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${token}`,
+        },
+      });
+
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async getPublicUrl(filePath: string): Promise<string> {
+    const objectName = path.basename(filePath);
+    return `https://storage.googleapis.com/${this.bucket}/${objectName}`;
+  }
+}

package/src/storage/index.ts

@@ -1,24 +1,27 @@
 import type { StorageProvider } from "./interface";
 import { LocalStorageProvider } from "./local";
-import { PayloadStorageProvider } from "./payload";
+import { GCSStorageProvider } from "./gcs";
 
 let storageInstance: StorageProvider | null = null;
 
 export function getStorage(): StorageProvider {
   if (!storageInstance) {
     const type = process.env.STORAGE_PROVIDER || "local";
-    console.error(`Initializing storage provider: ${type}`); // Log to stderr for debug
+    console.error(`Initializing storage provider: ${type}`);
 
-    if (type === "payload") {
-      storageInstance = new PayloadStorageProvider(
-        process.env.PAYLOAD_API_URL || "http://localhost:3000",
-        process.env.PAYLOAD_API_KEY || ""
-      );
+    if (type === "gcs") {
+      const bucket = process.env.GCS_BUCKET;
+
+      if (!bucket) {
+        throw new Error("GCS_BUCKET is required when using gcs storage");
+      }
+
+      storageInstance = new GCSStorageProvider(bucket);
     } else {
       storageInstance = new LocalStorageProvider(process.cwd());
     }
 
-    // Initialize async (fire and forget or handle properly in app startup)
+    // Initialize async
     storageInstance
       .init()
       .catch((err) => console.error("Failed to init storage:", err));

package/src/storage/interface.ts

@@ -1,7 +1,7 @@
 export interface StorageProvider {
   init(): Promise<void>;
   readFile(path: string): Promise<Buffer>;
-  writeFile(path: string, data: Buffer | string): Promise<string>; // Returns path or URL
+  writeFile(path: string, data: Buffer | string): Promise<string>; // Returns public URL
   exists(path: string): Promise<boolean>;
   getPublicUrl(path: string): Promise<string>;
 }

package/src/storage/local.ts

@@ -14,7 +14,6 @@ export class LocalStorageProvider implements StorageProvider {
   }
 
   async readFile(filePath: string): Promise<Buffer> {
-    // Handle absolute paths by checking if it starts with basePath or just use it if it exists
     let fullPath = filePath;
     if (!path.isAbsolute(filePath)) {
       fullPath = path.resolve(this.basePath, filePath);
@@ -45,7 +44,6 @@ export class LocalStorageProvider implements StorageProvider {
   }
 
   async getPublicUrl(filePath: string): Promise<string> {
-    // For local, we just return the absolute path
     let fullPath = filePath;
     if (!path.isAbsolute(filePath)) {
       fullPath = path.resolve(this.basePath, filePath);

package/src/tools/gemini.ts

@@ -164,7 +164,7 @@ async function processVideoInput(
 }
 
 export const geminiTextToImage = {
-  name: "geminiTextToImage",
+  name: "generateImage",
   description:
     "Generate images from text prompts using Gemini 2.5 Flash Image model",
   parameters: z.object({
@@ -194,30 +194,41 @@ export const geminiTextToImage = {
         },
       });
 
-      let result = "";
+      const images = [];
+      let textResponse = "";
+
       if (response.candidates && response.candidates[0]?.content?.parts) {
         for (const part of response.candidates[0].content.parts) {
           if (part.text) {
-            result += part.text;
+            textResponse += part.text;
           } else if (part.inlineData?.data) {
             const imageData = part.inlineData.data;
             if (args.output_path) {
               const storage = getStorage();
-              await storage.writeFile(
+              const url = await storage.writeFile(
                 args.output_path,
                 Buffer.from(imageData, "base64")
               );
-              result += `\nImage saved to: ${args.output_path}`;
-            } else {
-              result += `\nGenerated image (base64): ${imageData.substring(
-                0,
-                100
-              )}...`;
+              images.push({
+                url,
+                filename: args.output_path,
+                mimeType: "image/png",
+              });
             }
           }
         }
       }
-      return result || "Image generation completed but no response received";
+
+      if (images.length > 0) {
+        return JSON.stringify({
+          images,
+          message: textResponse || "Image generated successfully",
+        });
+      }
+
+      return (
+        textResponse || "Image generation completed but no response received"
+      );
     } catch (error: any) {
       throw new Error(`Image generation failed: ${error.message}`);
     }
@@ -225,7 +236,7 @@ export const geminiTextToImage = {
 };
 
 export const geminiEditImage = {
-  name: "geminiEditImage",
+  name: "editImage",
   description:
     "Edit existing images with text instructions using Gemini 2.5 Flash Image Preview",
   parameters: z.object({
@@ -261,30 +272,39 @@ export const geminiEditImage = {
         contents: contents,
       });
 
-      let result = "";
+      const images = [];
+      let textResponse = "";
+
       if (response.candidates && response.candidates[0]?.content?.parts) {
         for (const part of response.candidates[0].content.parts) {
           if (part.text) {
-            result += part.text;
+            textResponse += part.text;
           } else if (part.inlineData?.data) {
             const imageData = part.inlineData.data;
             if (args.output_path) {
               const storage = getStorage();
-              await storage.writeFile(
+              const url = await storage.writeFile(
                 args.output_path,
                 Buffer.from(imageData, "base64")
               );
-              result += `\nEdited image saved to: ${args.output_path}`;
-            } else {
-              result += `\nEdited image (base64): ${imageData.substring(
-                0,
-                100
-              )}...`;
+              images.push({
+                url,
+                filename: args.output_path,
+                mimeType: "image/png",
+              });
             }
           }
         }
       }
-      return result || "Image editing completed but no response received";
+
+      if (images.length > 0) {
+        return JSON.stringify({
+          images,
+          message: textResponse || "Image edited successfully",
+        });
+      }
+
+      return textResponse || "Image editing completed but no response received";
     } catch (error: any) {
       throw new Error(`Image editing failed: ${error.message}`);
     }
@@ -292,7 +312,7 @@ export const geminiEditImage = {
 };
 
 export const geminiAnalyzeImages = {
-  name: "geminiAnalyzeImages",
+  name: "analyzeImages",
   description:
     "Analyze and describe images using Gemini 2.5 Pro with advanced multimodal understanding",
   parameters: z.object({
@@ -358,7 +378,7 @@ export const geminiAnalyzeImages = {
 };
 
 export const geminiSingleSpeakerTts = {
-  name: "geminiSingleSpeakerTts",
+  name: "generateSpeech",
   description:
     "Generate single speaker voice audio from text using Gemini 2.5 Pro Preview TTS model",
   parameters: z.object({
@@ -407,9 +427,17 @@ export const geminiSingleSpeakerTts = {
       // Generate output filename if not provided
       const outputPath = args.output_path || `voice_output_${Date.now()}.wav`;
 
-      await saveWaveFile(outputPath, audioBuffer);
+      const storage = getStorage();
+      const url = await storage.writeFile(outputPath, audioBuffer);
 
-      return `Audio generated successfully: ${outputPath}`;
+      return JSON.stringify({
+        audio: {
+          url,
+          filename: outputPath,
+          mimeType: "audio/wav",
+        },
+        message: "Audio generated successfully",
+      });
     } catch (error: any) {
       throw new Error(`Voice generation failed: ${error.message}`);
     }
@@ -417,7 +445,7 @@ export const geminiSingleSpeakerTts = {
 };
 
 export const geminiAnalyzeVideos = {
-  name: "geminiAnalyzeVideos",
+  name: "analyzeVideos",
   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({

package/src/tools/hunyuan-avatar.ts

@@ -5,10 +5,12 @@ 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 {
+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));
 }
@@ -18,17 +20,52 @@ function calculateFramesFromAudioDuration(audioDurationSeconds: number): number
  */
 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.",
+  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"),
+    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."),
+    fal_key: z
+      .string()
+      .optional()
+      .describe(
+        "FAL API key. If not provided, will use FAL_KEY environment variable."
+      ),
   }),
   execute: async (args: {
     image_url: string;
@@ -43,17 +80,28 @@ export const hunyuanAvatar = {
   }) => {
     // 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);
+    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)) {
+    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)) {
+    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");
     }
 
@@ -80,23 +128,33 @@ export const hunyuanAvatar = {
       input.seed = args.seed;
     }
 
-    const result = await callFalModel("fal-ai/hunyuan-avatar", input, { falKey: args.fal_key });
+    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)}`);
+      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}` : "";
-
+    const fileName = videoData.file_name || "hunyuan_avatar.mp4";
 
-    return videoUrl
-    // return `✅ Hunyuan Avatar video generated successfully!\n\nVideo URL: ${videoUrl}${fileDetails}${requestIdInfo}`;
+    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/image-to-video.ts

@@ -64,7 +64,7 @@ async function fileToBase64(
 }
 
 export const imageToVideo = {
-  name: "image_to_video",
+  name: "generateVideoi2v",
   description:
     "Generate videos from an image as starting first frame using Vertex Veo models (predictLongRunning + fetchPredictOperation).",
   parameters: z.object({
@@ -283,7 +283,8 @@ export const imageToVideo = {
 
     const resp = current.response || current;
     // Decode from response.videos[].bytesBase64Encoded only
-    const outputs: string[] = [];
+    const videos: Array<{ url: string; filename: string; mimeType: string }> =
+      [];
     const saveVideo = async (base64: string, index: number) => {
       if (!base64) return;
       const filePath = args.output_path
@@ -291,14 +292,15 @@ export const imageToVideo = {
           ? args.output_path
           : args.output_path.replace(/\.mp4$/i, `_${index}.mp4`)
         : `video_output_${Date.now()}${index === 0 ? "" : "_" + index}.mp4`;
-      // For storage provider, we use the path as is (relative or absolute)
-      // If using LocalStorage, it handles resolving.
-      // If using Payload, it handles the key.
 
       const buf = Buffer.from(base64, "base64");
       const storage = getStorage();
-      await storage.writeFile(filePath, buf);
-      outputs.push(filePath);
+      const url = await storage.writeFile(filePath, buf);
+      videos.push({
+        url,
+        filename: filePath,
+        mimeType: "video/mp4",
+      });
     };
 
     if (Array.isArray(resp?.videos) && resp.videos.length > 0) {
@@ -309,8 +311,11 @@ export const imageToVideo = {
         }
       }
     }
-    if (outputs.length > 0) {
-      return `Video(s) saved: ${outputs.join(", ")}`;
+    if (videos.length > 0) {
+      return JSON.stringify({
+        videos,
+        message: "Video(s) generated successfully",
+      });
     }
 
     // If nothing saved, return a concise summary plus head/tail snippets of JSON

package/src/tools/infinitalk.ts

@@ -5,10 +5,12 @@ 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 {
+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));
 }
@@ -18,17 +20,56 @@ function calculateFramesFromAudioDuration(audioDurationSeconds: number): number
  */
 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.",
+  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."),
+    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;
@@ -43,12 +84,20 @@ export const infinitalk = {
   }) => {
     // 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);
+    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)) {
+    if (
+      calculatedFrames !== undefined &&
+      (calculatedFrames < 41 || calculatedFrames > 721)
+    ) {
       throw new Error("num_frames must be between 41 and 721");
     }
 
@@ -63,9 +112,9 @@ export const infinitalk = {
     if (calculatedFrames !== undefined) {
       input.num_frames = calculatedFrames;
     }
-    
-    input.resolution = args.resolution || '480p';
-    
+
+    input.resolution = args.resolution || "480p";
+
     if (args.seed !== undefined) {
       input.seed = args.seed;
     }
@@ -73,24 +122,35 @@ export const infinitalk = {
       input.acceleration = args.acceleration;
     }
 
-    const result = await callFalModel("fal-ai/infinitalk", input, { falKey: args.fal_key });
+    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)}`);
+      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}` : "";
+    const fileName = videoData.file_name || "infinitalk.mp4";
 
-    return videoUrl
-    // return `✅ Infinitalk video generated successfully!\n\nVideo URL: ${videoUrl}${fileDetails}${seedInfo}${requestIdInfo}`;
+    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/storage/payload.ts

@@ -1,46 +0,0 @@
-import type { StorageProvider } from "./interface";
-
-export class PayloadStorageProvider implements StorageProvider {
-  private apiUrl: string;
-  private apiKey: string;
-  private collection: string;
-
-  constructor(apiUrl: string, apiKey: string, collection: string = "media") {
-    this.apiUrl = apiUrl;
-    this.apiKey = apiKey;
-    this.collection = collection;
-  }
-
-  async init(): Promise<void> {
-    console.log("Initializing Payload Storage Provider...");
-    // TODO: Verify connection to Payload CMS
-  }
-
-  async readFile(filePath: string): Promise<Buffer> {
-    // TODO: Implement fetching file from Payload CMS
-    // 1. Search for file by filename or ID
-    // 2. Download the file buffer
-    console.log(`[Payload] Reading file: ${filePath}`);
-    throw new Error("PayloadStorageProvider.readFile not implemented yet.");
-  }
-
-  async writeFile(filePath: string, data: Buffer | string): Promise<string> {
-    // TODO: Implement uploading file to Payload CMS
-    // 1. Create FormData
-    // 2. POST to /api/{collection}
-    console.log(`[Payload] Writing file: ${filePath}`);
-    throw new Error("PayloadStorageProvider.writeFile not implemented yet.");
-  }
-
-  async exists(filePath: string): Promise<boolean> {
-    // TODO: Check if file exists in Payload
-    console.log(`[Payload] Checking existence: ${filePath}`);
-    return false;
-  }
-
-  async getPublicUrl(filePath: string): Promise<string> {
-    // TODO: Return the public URL of the file in Payload
-    console.log(`[Payload] Getting public URL: ${filePath}`);
-    return `${this.apiUrl}/${this.collection}/${filePath}`;
-  }
-}