@mixio-pro/kalaasetu-mcp 2.1.2-beta → 2.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mixio-pro/kalaasetu-mcp",
-  "version": "2.1.2-beta",
+  "version": "2.1.2",
   "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

@@ -8,6 +8,7 @@ import {
 } from "./tools/fal";
 import { createAllFalTools } from "./tools/fal/dynamic-tools";
 import { geminiEditImage, geminiTextToImage } from "./tools/gemini";
+import { generateImage } from "./tools/generate-image";
 import { imageToVideo } from "./tools/image-to-video";
 import { getGenerationStatus } from "./tools/get-status";
 
@@ -30,6 +31,7 @@ async function main() {
   // server.addTool(geminiTextToImage);
   // server.addTool(geminiEditImage);
   server.addTool(imageToVideo);
+  server.addTool(generateImage);
 
   // 3. Add Discovery Tools
   server.addTool(falListPresets);

package/src/tools/generate-image.ts

@@ -0,0 +1,219 @@
+import { z } from "zod";
+import { GoogleGenAI } from "@google/genai";
+import * as fs from "fs";
+import { getStorage } from "../storage";
+import { generateTimestampedFilename } from "../utils/filename";
+import { safeToolExecute } from "../utils/tool-wrapper";
+import { ensureLocalFile } from "../utils/url-file";
+import { resolveEnhancer } from "../utils/prompt-enhancer-presets";
+
+const ai = new GoogleGenAI({
+  apiKey: process.env.GEMINI_API_KEY || "",
+});
+
+async function fileToGenerativePart(filePath: string) {
+  const fileResult = await ensureLocalFile(filePath);
+
+  try {
+    let imageBytes: Buffer;
+    if (fileResult.isTemp) {
+      imageBytes = fs.readFileSync(fileResult.path);
+    } else {
+      const storage = getStorage();
+      imageBytes = await storage.readFile(fileResult.path);
+    }
+
+    return {
+      inlineData: {
+        data: Buffer.from(imageBytes).toString("base64"),
+        mimeType: "image/jpeg",
+      },
+    };
+  } finally {
+    fileResult.cleanup();
+  }
+}
+
+export const generateImage = {
+  name: "generateImage",
+  description:
+    "Generate high-quality images from text prompts using Google's Imagen 3 model via Gemini. " +
+    "This tool supports conversational history with reference images and their descriptions. " +
+    "Use this tool when you need to provide specific reference images with context/descriptions to guide the generation.",
+  parameters: z.object({
+    prompt: z
+      .string()
+      .describe("Detailed text description of the image to generate."),
+    aspect_ratio: z
+      .string()
+      .optional()
+      .describe(
+        "Supported ratios: 1:1, 3:4, 4:3, 9:16, or 16:9. Default is 9:16.",
+      ),
+    output_path: z
+      .string()
+      .optional()
+      .describe(
+        "Optional: specific local path or filename to save the image. " +
+          "If omitted, a timestamped filename is generated automatically.",
+      ),
+    reference_images: z
+      .array(
+        z.object({
+          path: z
+            .string()
+            .describe("Local path or URL to the reference image."),
+          description: z
+            .string()
+            .optional()
+            .describe("Optional description of the reference image."),
+        }),
+      )
+      .optional()
+      .describe(
+        "Optional: List of reference images with optional descriptions to guide the style or content.",
+      ),
+    enhancer_preset: z
+      .string()
+      .optional()
+      .describe(
+        "Optional: Name of a prompt enhancer preset to apply (e.g., 'cinematic', 'photorealistic', 'anime'). " +
+          "Automatically enhances the prompt with professional style modifiers.",
+      ),
+  }),
+  timeoutMs: 300000,
+  execute: async (args: {
+    prompt: string;
+    aspect_ratio?: string;
+    output_path?: string;
+    reference_images?: { path: string; description?: string }[];
+    enhancer_preset?: string;
+  }) => {
+    return safeToolExecute(
+      async () => {
+        try {
+          // Apply prompt enhancement if preset specified
+          let enhancedPrompt = args.prompt;
+          if (args.enhancer_preset) {
+            const enhancer = resolveEnhancer(args.enhancer_preset);
+            if (enhancer.hasTransformations()) {
+              enhancedPrompt = enhancer.enhance(args.prompt);
+            }
+          }
+
+          const contents: any[] = [];
+
+          // Add reference images with descriptions (conversational history style)
+          if (args.reference_images && Array.isArray(args.reference_images)) {
+            for (const refImg of args.reference_images) {
+              if (refImg.description) {
+                contents.push({ text: refImg.description });
+              }
+              const imagePart = await fileToGenerativePart(refImg.path);
+              contents.push(imagePart);
+            }
+          }
+
+          // Add main prompt
+          contents.push({ text: enhancedPrompt });
+
+          const PRIMARY_MODEL = "gemini-3-pro-image-preview";
+          const FALLBACK_MODEL = "gemini-2.5-flash-image";
+
+          const generateWithFallback = async () => {
+            const config = {
+              contents: contents,
+              config: {
+                responseModalities: ["TEXT" as const, "IMAGE" as const],
+                imageConfig: {
+                  aspectRatio: args.aspect_ratio || "9:16",
+                },
+              },
+            };
+
+            const isUnavailableError = (err: any): boolean => {
+              if (err?.status === 503) return true;
+              if (err?.error?.code === 503) return true;
+              const msg = String(err?.message || "");
+              return (
+                msg.includes("503") ||
+                msg.includes("UNAVAILABLE") ||
+                msg.includes("high demand")
+              );
+            };
+
+            try {
+              return await ai.models.generateContent({
+                model: PRIMARY_MODEL,
+                ...config,
+              });
+            } catch (err: any) {
+              if (isUnavailableError(err)) {
+                console.warn(
+                  `⚠️ ${PRIMARY_MODEL} unavailable (503), falling back to ${FALLBACK_MODEL}`,
+                );
+                try {
+                  return await ai.models.generateContent({
+                    model: FALLBACK_MODEL,
+                    ...config,
+                  });
+                } catch (fallbackErr: any) {
+                  throw new Error(
+                    `Both models unavailable — primary (${PRIMARY_MODEL}): ${err.message}; fallback (${FALLBACK_MODEL}): ${fallbackErr.message}`,
+                  );
+                }
+              }
+              throw err;
+            }
+          };
+
+          const response = await generateWithFallback();
+
+          const images = [];
+          let textResponse = "";
+
+          if (response.candidates && response.candidates[0]?.content?.parts) {
+            for (const part of response.candidates[0].content.parts) {
+              if (part.text) {
+                textResponse += part.text;
+              } else if (part.inlineData?.data) {
+                const imageData = part.inlineData.data;
+                // Always save the image
+                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 JSON.stringify({
+              url: images?.[0]?.url,
+              images,
+              message: textResponse || "Image generated successfully",
+            });
+          }
+
+          return (
+            textResponse ||
+            "Image generation completed but no image was produced"
+          );
+        } catch (error: any) {
+          throw new Error(`Image generation failed: ${error.message}`);
+        }
+      },
+      "gemini-generateImage",
+      { toolName: "generateImage" },
+    );
+  },
+};

package/src/tools/get-status.ts

@@ -23,6 +23,7 @@ interface VertexOperation {
     [key: string]: any;
   };
   error?: any;
+  _vertexError?: string;
   [key: string]: any;
 }
 
@@ -99,6 +100,19 @@ export async function checkVertexStatus(resumeEndpoint: string): Promise<any> {
 
   const result = (await response.json()) as VertexOperation;
 
+  // If the operation completed with an error, surface it immediately
+  if (result.done && result.error) {
+    const errMsg =
+      typeof result.error === "object"
+        ? result.error.message ||
+          result.error.code ||
+          JSON.stringify(result.error)
+        : String(result.error);
+    // Attach a structured error to the result for callers to inspect
+    result._vertexError = errMsg;
+    return result;
+  }
+
   // If completed, save videos if present
   const done = !!result.done || !!result.response;
   if (done) {

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

@@ -515,6 +515,30 @@ export const imageToVideo = {
           });
         }
 
+        // Check if the operation failed with an error
+        if (current.error || current._vertexError) {
+          const errMsg =
+            current._vertexError ||
+            (typeof current.error === "object"
+              ? current.error.message ||
+                current.error.code ||
+                JSON.stringify(current.error)
+              : String(current.error));
+          return JSON.stringify({
+            status: "ERROR",
+            message: `Vertex AI video generation failed: ${errMsg}`,
+            operationName,
+            error:
+              typeof current.error === "object"
+                ? {
+                    code: current.error.code,
+                    message: current.error.message,
+                    status: current.error.status,
+                  }
+                : current.error,
+          });
+        }
+
         const resp = current.response || current;
 
         // checkVertexStatus already handles saving videos and sanitizing base64

package/src/utils/tool-credits.ts

@@ -20,13 +20,20 @@ export const TOOL_CREDITS: Record<string, ToolCreditConfig> = {
     credits: 5,
     provider: "google-gemini",
     chargeable: true,
-    modelName: "imagen-3.0-generate-002",
+    modelName: "gemini-3-pro-image-preview",
   },
   editImage: {
     credits: 5,
     provider: "google-gemini",
     chargeable: true,
-    modelName: "imagen-3.0-capability-001",
+    modelName: "gemini-3-pro-image-preview",
+  },
+
+  generateImageConversational: {
+    credits: 5,
+    provider: "google-gemini",
+    chargeable: true,
+    modelName: "gemini-3-pro-image-preview",
   },
 
   // Vertex AI Video Generation - 20 credits (premium)
@@ -34,7 +41,7 @@ export const TOOL_CREDITS: Record<string, ToolCreditConfig> = {
     credits: 20,
     provider: "google-vertex",
     chargeable: true,
-    modelName: "veo-2.0-generate-001",
+    modelName: "veo-3.1-fast-generate-001",
   },
 
   // FAL AI Video Generation - 15 credits