@mixio-pro/kalaasetu-mcp 1.0.14 → 1.0.16

package/package.json

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

package/src/storage/gcs.ts

@@ -18,9 +18,6 @@ export class GCSStorageProvider implements StorageProvider {
   }
 
   async init(): Promise<void> {
-    console.log(
-      `Initializing GCS Storage Provider with bucket: ${this.bucket}`
-    );
     // Verify we can get credentials
     try {
       await this.auth.getClient();

package/src/tools/gemini.ts

@@ -167,18 +167,20 @@ async function processVideoInput(
   } else {
     // Local file processing - use File Upload API
     const storage = getStorage();
-    
+
     // Check if file exists
     const exists = await storage.exists(input);
     if (!exists) {
       // Try to provide more helpful error information
       const isAbsolute = path.isAbsolute(input);
-      const resolvedPath = isAbsolute ? input : path.resolve(process.cwd(), input);
+      const resolvedPath = isAbsolute
+        ? input
+        : path.resolve(process.cwd(), input);
       throw new Error(
         `Video file not found: ${input}\n` +
-        `Resolved path: ${resolvedPath}\n` +
-        `Is absolute: ${isAbsolute}\n` +
-        `CWD: ${process.cwd()}`
+          `Resolved path: ${resolvedPath}\n` +
+          `Is absolute: ${isAbsolute}\n` +
+          `CWD: ${process.cwd()}`
       );
     }
 
@@ -192,7 +194,7 @@ async function processVideoInput(
 export const geminiTextToImage = {
   name: "generateImage",
   description:
-    "Generate images from text prompts using Gemini image models with optional reference images",
+    "Generate images from text prompts using Gemini image models with optional reference images. Returns the URL of the generated image.",
   parameters: z.object({
     prompt: z.string().describe("Text description of the image to generate"),
     aspect_ratio: z
@@ -202,7 +204,9 @@ export const geminiTextToImage = {
     output_path: z
       .string()
       .optional()
-      .describe("File path to save the generated image"),
+      .describe(
+        "File path to save the generated image (optional, auto-generated if not provided)"
+      ),
     reference_images: z
       .array(z.string())
       .optional()
@@ -243,31 +247,35 @@ export const geminiTextToImage = {
             textResponse += part.text;
           } else if (part.inlineData?.data) {
             const imageData = part.inlineData.data;
-            if (args.output_path) {
-              const storage = getStorage();
-              const url = await storage.writeFile(
-                args.output_path,
-                Buffer.from(imageData, "base64")
-              );
-              images.push({
-                url,
-                filename: args.output_path,
-                mimeType: "image/png",
-              });
-            }
+            // Always save the image - use provided path or generate one
+            const outputPath =
+              args.output_path ||
+              generateTimestampedFilename("generated_image.png");
+            const storage = getStorage();
+            const url = await storage.writeFile(
+              outputPath,
+              Buffer.from(imageData, "base64")
+            );
+            images.push({
+              url,
+              filename: outputPath,
+              mimeType: "image/png",
+            });
           }
         }
       }
 
       if (images.length > 0) {
+        // Return the URL directly for easy parsing
         return JSON.stringify({
+          url: images?.[0]?.url,
           images,
           message: textResponse || "Image generated successfully",
         });
       }
 
       return (
-        textResponse || "Image generation completed but no response received"
+        textResponse || "Image generation completed but no image was produced"
       );
     } catch (error: any) {
       throw new Error(`Image generation failed: ${error.message}`);
@@ -465,7 +473,8 @@ export const geminiSingleSpeakerTts = {
       const audioBuffer = Buffer.from(data, "base64");
 
       // Use provided output path or generate default with timestamp
-      const outputPath = args.output_path || generateTimestampedFilename("voice_output.wav");
+      const outputPath =
+        args.output_path || generateTimestampedFilename("voice_output.wav");
 
       const storage = getStorage();
       const url = await storage.writeFile(outputPath, audioBuffer);

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

@@ -15,27 +15,67 @@ function fileToBase64(filePath: string): { data: string; mimeType: string } {
   const data = Buffer.from(buf).toString("base64");
   // Detect mime type from extension
   const ext = path.extname(filePath).toLowerCase();
-  const mimeType = ext === '.jpg' || ext === '.jpeg' ? 'image/jpeg' : 
-                   ext === '.png' ? 'image/png' :
-                   ext === '.webp' ? 'image/webp' : 'image/png';
+  const mimeType =
+    ext === ".jpg" || ext === ".jpeg"
+      ? "image/jpeg"
+      : ext === ".png"
+      ? "image/png"
+      : ext === ".webp"
+      ? "image/webp"
+      : "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).",
+  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.number().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)"),
-    gemini_api_key: z.string().optional().describe("Gemini API key (uses GEMINI_API_KEY env var if not provided)"),
-    model_id: z.string().optional().describe("Model ID (default: veo-2.0-generate-001)"),
+    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
+      .number()
+      .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)"
+      ),
+    gemini_api_key: z
+      .string()
+      .optional()
+      .describe("Gemini API key (uses GEMINI_API_KEY env var if not provided)"),
+    model_id: z
+      .string()
+      .optional()
+      .describe("Model ID (default: veo-2.0-generate-001)"),
   }),
   execute: async (args: {
     prompt: string;
@@ -52,47 +92,49 @@ export const imageToVideo = {
   }) => {
     const apiKey = args.gemini_api_key || process.env.GEMINI_API_KEY;
     if (!apiKey) {
-      throw new Error("Gemini API key is required. Set GEMINI_API_KEY environment variable or pass gemini_api_key parameter. Get one at https://aistudio.google.com/app/apikey");
+      throw new Error(
+        "Gemini API key is required. Set GEMINI_API_KEY environment variable or pass gemini_api_key parameter. Get one at https://aistudio.google.com/app/apikey"
+      );
     }
 
     const model = args.model_id || "veo-2.0-generate-001";
-    
+
     // Initialize Google GenAI client
     const genai = new GoogleGenAI({ apiKey });
 
     // Build config for video generation
     const config: any = {};
-    
+
     if (args.duration_seconds !== undefined) {
       config.duration_seconds = args.duration_seconds;
     } else {
       config.duration_seconds = 6; // default
     }
-    
+
     if (args.aspect_ratio) {
       config.aspect_ratio = args.aspect_ratio;
     }
 
     try {
       // Start video generation operation
-      console.log(`Starting video generation with model: ${model}`);
+      console.error(`Starting video generation with model: ${model}`);
       let operation = await genai.models.generateVideos({
         model,
         prompt: args.prompt,
         config,
       });
 
-      console.log("Operation started, waiting for completion...");
-      
+      console.error("Operation started, waiting for completion...");
+
       // Poll until operation is complete (max 10 minutes)
       let tries = 0;
       const maxTries = 60; // 10 minutes with 10s intervals
-      
+
       while (!operation.done && tries < maxTries) {
         await wait(10000); // Wait 10 seconds
         tries++;
-        console.log(`Polling attempt ${tries}/${maxTries}...`);
-        
+        console.error(`Polling attempt ${tries}/${maxTries}...`);
+
         operation = await genai.operations.getVideosOperation({
           operation: operation,
         });
@@ -102,60 +144,75 @@ export const imageToVideo = {
         throw new Error("Video generation timed out after 10 minutes");
       }
 
-      console.log("Operation completed!");
-      console.log("Full Response:", JSON.stringify(operation.response, null, 2));
+      console.error("Operation completed!");
+      console.error(
+        "Full Response:",
+        JSON.stringify(operation.response, null, 2)
+      );
 
       // Extract generated videos from response
       const generatedVideos = operation.response?.generatedVideos || [];
-      
+
       if (!generatedVideos || generatedVideos.length === 0) {
         const respStr = JSON.stringify(operation.response, null, 2);
-        return `Video generation completed but no videos found in response.\n\nFull Response:\n${respStr.slice(0, 2000)}${respStr.length > 2000 ? '\n...(truncated)' : ''}`;
+        return `Video generation completed but no videos found in response.\n\nFull Response:\n${respStr.slice(
+          0,
+          2000
+        )}${respStr.length > 2000 ? "\n...(truncated)" : ""}`;
       }
 
       // Download and save videos
       const outputs: string[] = [];
-      
+
       for (let i = 0; i < generatedVideos.length; i++) {
         const generatedVideo = generatedVideos[i];
         const videoUri = generatedVideo?.video?.uri;
-        
+
         if (!videoUri) {
           console.warn(`Video ${i} has no URI`);
           continue;
         }
 
-        console.log(`Downloading video ${i + 1}/${generatedVideos.length}...`);
-        
+        console.error(
+          `Downloading video ${i + 1}/${generatedVideos.length}...`
+        );
+
         // Download video from URI
         const videoUrl = `${videoUri}&key=${apiKey}`;
         const response = await fetch(videoUrl);
-        
+
         if (!response.ok) {
-          throw new Error(`Failed to download video: ${response.status} ${response.statusText}`);
+          throw new Error(
+            `Failed to download video: ${response.status} ${response.statusText}`
+          );
         }
-        
+
         const buffer = await response.arrayBuffer();
-        
+
         // Save video to file
         const filePath = args.output_path
-          ? (i === 0 ? args.output_path : args.output_path.replace(/\.mp4$/i, `_${i}.mp4`))
-          : `video_output_${Date.now()}${i === 0 ? '' : '_' + i}.mp4`;
+          ? i === 0
+            ? args.output_path
+            : args.output_path.replace(/\.mp4$/i, `_${i}.mp4`)
+          : `video_output_${Date.now()}${i === 0 ? "" : "_" + i}.mp4`;
         const absPath = path.resolve(filePath);
-        
+
         fs.writeFileSync(absPath, Buffer.from(buffer));
         outputs.push(absPath);
-        console.log(`Saved video to: ${absPath}`);
+        console.error(`Saved video to: ${absPath}`);
       }
 
       if (outputs.length > 0) {
-        return `Video(s) saved successfully:\n${outputs.map((p, i) => `${i + 1}. ${p}`).join('\n')}`;
+        return `Video(s) saved successfully:\n${outputs
+          .map((p, i) => `${i + 1}. ${p}`)
+          .join("\n")}`;
       }
 
       return "Video generation completed but no videos were saved.";
-      
     } catch (error: any) {
-      throw new Error(`Video generation failed: ${error.message || JSON.stringify(error)}`);
+      throw new Error(
+        `Video generation failed: ${error.message || JSON.stringify(error)}`
+      );
     }
   },
 };

package/src/utils/fal.utils.ts

@@ -8,14 +8,16 @@ export async function callFalModel(
   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.");
+    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...`);
+  console.error(`[${modelName}] Submitting request to FAL AI...`);
 
   try {
     const result = await fal.subscribe(modelName, {
@@ -23,23 +25,29 @@ export async function callFalModel(
       logs,
       onQueueUpdate: (update) => {
         if (update.status === "IN_PROGRESS") {
-          console.log(`[${modelName}] Status: ${update.status}`);
+          console.error(`[${modelName}] Status: ${update.status}`);
           if (logs && "logs" in update && update.logs) {
             update.logs.forEach((log) => {
-              console.log(`[${modelName}] ${log.message}`);
+              console.error(`[${modelName}] ${log.message}`);
             });
           }
         } else if (update.status === "IN_QUEUE") {
-          console.log(`[${modelName}] Status: ${update.status} - Waiting in queue...`);
+          console.error(
+            `[${modelName}] Status: ${update.status} - Waiting in queue...`
+          );
         }
       },
     });
 
-    console.log(`[${modelName}] Generation completed successfully`);
+    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)}`);
+    throw new Error(
+      `FAL AI ${modelName} generation failed: ${
+        error.message || JSON.stringify(error)
+      }`
+    );
   }
 }