@mixio-pro/kalaasetu-mcp 1.1.3 → 1.1.4

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { getStorage } from "../storage";
 import { generateTimestampedFilename } from "../utils/filename";
+import { safeToolExecute } from "../utils/tool-wrapper";
 
 import { getGoogleAccessToken } from "../utils/google-auth";
 
@@ -110,6 +111,7 @@ export const imageToVideo = {
       )
       .default(false),
   }),
+  timeoutMs: 1200000, // 20 minutes
   async execute(args: {
     prompt: string;
     image_path?: string;
@@ -126,223 +128,235 @@ export const imageToVideo = {
     model_id?: string;
     generate_audio?: boolean;
   }) {
-    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";
+    return safeToolExecute(async () => {
+      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";
 
-    // Validate and parse duration_seconds - snap to nearest 4, 6, or 8
-    let durationSeconds = parseInt(args.duration_seconds || "6");
-    if (isNaN(durationSeconds)) durationSeconds = 6;
+      // Validate and parse duration_seconds - snap to nearest 4, 6, or 8
+      let durationSeconds = parseInt(args.duration_seconds || "6");
+      if (isNaN(durationSeconds)) durationSeconds = 6;
 
-    const validDurations = [4, 6, 8];
-    // Find nearest valid duration
-    durationSeconds = validDurations.reduce((prev, curr) => {
-      return Math.abs(curr - durationSeconds) < Math.abs(prev - durationSeconds)
-        ? curr
-        : prev;
-    });
+      const validDurations = [4, 6, 8];
+      // Find nearest valid duration
+      durationSeconds = validDurations.reduce((prev, curr) => {
+        return Math.abs(curr - durationSeconds) <
+          Math.abs(prev - durationSeconds)
+          ? curr
+          : prev;
+      });
 
-    // Tie-breaking: if equidistant (e.g. 5), the reduce above keeps the first one (4) because < is strict.
-    // However, user requested "nearest duration with the ceil", effectively meaning round up if equidistant.
-    // Let's explicitly handle the equidistant cases or just use a custom finder.
-    // 5 -> equidistant to 4 and 6. "With ceil" implies 6.
-    // 7 -> equidistant to 6 and 8. "With ceil" implies 8.
+      // Tie-breaking: if equidistant (e.g. 5), the reduce above keeps the first one (4) because < is strict.
+      // However, user requested "nearest duration with the ceil", effectively meaning round up if equidistant.
+      // Let's explicitly handle the equidistant cases or just use a custom finder.
+      // 5 -> equidistant to 4 and 6. "With ceil" implies 6.
+      // 7 -> equidistant to 6 and 8. "With ceil" implies 8.
 
-    // Simpler logic for these specific values:
-    if (durationSeconds === 4 && parseInt(args.duration_seconds || "6") === 5) {
-      durationSeconds = 6;
-    }
-    if (durationSeconds === 6 && parseInt(args.duration_seconds || "6") === 7) {
-      durationSeconds = 8;
-    }
+      // Simpler logic for these specific values:
+      if (
+        durationSeconds === 4 &&
+        parseInt(args.duration_seconds || "6") === 5
+      ) {
+        durationSeconds = 6;
+      }
+      if (
+        durationSeconds === 6 &&
+        parseInt(args.duration_seconds || "6") === 7
+      ) {
+        durationSeconds = 8;
+      }
 
-    const token = await getGoogleAccessToken();
+      const token = await getGoogleAccessToken();
 
-    const url = `https://${location}-aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/${modelId}:predictLongRunning`;
+      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 } = await fileToBase64(args.image_path);
-      imagePart = {
-        image: {
-          bytesBase64Encoded: data,
-          mimeType,
-        },
-      };
-    }
+      let imagePart: any = undefined;
+      if (args.image_path) {
+        const { data, mimeType } = await fileToBase64(args.image_path);
+        imagePart = {
+          image: {
+            bytesBase64Encoded: data,
+            mimeType,
+          },
+        };
+      }
 
-    let lastFramePart: any = undefined;
-    if (args.last_frame_path) {
-      const { data, mimeType } = await fileToBase64(args.last_frame_path);
-      lastFramePart = {
-        lastFrame: {
-          bytesBase64Encoded: data,
-          mimeType,
-        },
-      };
-    }
+      let lastFramePart: any = undefined;
+      if (args.last_frame_path) {
+        const { data, mimeType } = await fileToBase64(args.last_frame_path);
+        lastFramePart = {
+          lastFrame: {
+            bytesBase64Encoded: data,
+            mimeType,
+          },
+        };
+      }
 
-    let referenceImages: any[] | undefined = undefined;
-    if (args.reference_images) {
-      let refImages: string[];
-      if (typeof args.reference_images === "string") {
-        if (
-          args.reference_images.startsWith("[") &&
-          args.reference_images.endsWith("]")
-        ) {
-          try {
-            refImages = JSON.parse(args.reference_images);
-          } catch {
-            throw new Error("Invalid reference_images format");
+      let referenceImages: any[] | undefined = undefined;
+      if (args.reference_images) {
+        let refImages: string[];
+        if (typeof args.reference_images === "string") {
+          if (
+            args.reference_images.startsWith("[") &&
+            args.reference_images.endsWith("]")
+          ) {
+            try {
+              refImages = JSON.parse(args.reference_images);
+            } catch {
+              throw new Error("Invalid reference_images format");
+            }
+          } else {
+            refImages = [args.reference_images];
           }
+        } else if (Array.isArray(args.reference_images)) {
+          refImages = args.reference_images;
         } else {
-          refImages = [args.reference_images];
+          throw new Error("Invalid reference_images: must be array or string");
         }
-      } 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 = await Promise.all(
-          refImages.slice(0, 3).map(async (p) => {
-            const { data, mimeType } = await fileToBase64(p);
-            return {
-              image: {
-                bytesBase64Encoded: data,
-                mimeType,
-              },
-              referenceType: "asset",
-            };
-          })
-        );
+        if (refImages.length > 0) {
+          referenceImages = await Promise.all(
+            refImages.slice(0, 3).map(async (p) => {
+              const { data, mimeType } = await 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 || {}),
-        ...(lastFramePart || {}),
-        ...(referenceImages ? { referenceImages } : {}),
-      },
-    ];
-
-    const parameters: any = {
-      aspectRatio: args.aspect_ratio || "9:16",
-      durationSeconds: durationSeconds,
-      resolution: args.resolution || "720p",
-      negativePrompt: args.negative_prompt,
-      generateAudio: args.generate_audio || 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 personGeneration =
+        args.person_generation ||
+        (args.image_path ? "allow_adult" : "allow_all");
 
-    const op = (await res.json()) as any;
-    const name: string = op.name || op.operation || "";
-    if (!name) {
-      throw new Error(
-        "Vertex did not return an operation name for long-running request"
-      );
-    }
+      const instances: any[] = [
+        {
+          prompt: args.prompt,
+          ...(imagePart || {}),
+          ...(lastFramePart || {}),
+          ...(referenceImages ? { referenceImages } : {}),
+        },
+      ];
 
-    let current = op;
-    let done = !!op.done;
-    let tries = 0;
+      const parameters: any = {
+        aspectRatio: args.aspect_ratio || "9:16",
+        durationSeconds: durationSeconds,
+        resolution: args.resolution || "720p",
+        negativePrompt: args.negative_prompt,
+        generateAudio: args.generate_audio || false,
+        personGeneration,
+      };
 
-    // 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, {
+      const res = await fetch(url, {
         method: "POST",
         headers: {
           Authorization: `Bearer ${token}`,
           "Content-Type": "application/json",
         },
-        body: JSON.stringify({ operationName: name }),
+        body: JSON.stringify({ instances, parameters }),
       });
-      if (!poll.ok) {
-        const text = await poll.text();
-        throw new Error(`Vertex operation poll failed: ${poll.status} ${text}`);
+
+      if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Vertex request failed: ${res.status} ${text}`);
       }
-      current = (await poll.json()) as any;
-      done = !!current.done || !!current.response;
-      tries++;
-    }
 
-    const resp = current.response || current;
-    // Decode from response.videos[].bytesBase64Encoded only
-    const videos: Array<{ url: string; filename: string; mimeType: string }> =
-      [];
-    const saveVideo = async (base64: string, index: number) => {
-      if (!base64) return;
+      const op = (await res.json()) as any;
+      const name: string = op.name || op.operation || "";
+      if (!name) {
+        throw new Error(
+          "Vertex did not return an operation name for long-running request"
+        );
+      }
+
+      let current = op;
+      let done = !!op.done;
+      let tries = 0;
 
-      // Use provided output path or generate default with timestamp
-      let filePath: string;
-      if (args.output_path) {
-        // User provided path - use as-is for first video, add index for subsequent
-        filePath =
-          index === 0
-            ? args.output_path
-            : args.output_path.replace(/\.mp4$/i, `_${index}.mp4`);
-      } else {
-        // No path provided - generate timestamped default
-        const defaultName = `video_output${index > 0 ? `_${index}` : ""}.mp4`;
-        filePath = generateTimestampedFilename(defaultName);
+      // 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()) as any;
+        done = !!current.done || !!current.response;
+        tries++;
       }
 
-      const buf = Buffer.from(base64, "base64");
-      const storage = getStorage();
-      const url = await storage.writeFile(filePath, buf);
-      videos.push({
-        url,
-        filename: filePath,
-        mimeType: "video/mp4",
-      });
-    };
+      const resp = current.response || current;
+      // Decode from response.videos[].bytesBase64Encoded only
+      const videos: Array<{ url: string; filename: string; mimeType: string }> =
+        [];
+      const saveVideo = async (base64: string, index: number) => {
+        if (!base64) return;
 
-    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") {
-          await saveVideo(v.bytesBase64Encoded, i);
+        // Use provided output path or generate default with timestamp
+        let filePath: string;
+        if (args.output_path) {
+          // User provided path - use as-is for first video, add index for subsequent
+          filePath =
+            index === 0
+              ? args.output_path
+              : args.output_path.replace(/\.mp4$/i, `_${index}.mp4`);
+        } else {
+          // No path provided - generate timestamped default
+          const defaultName = `video_output${index > 0 ? `_${index}` : ""}.mp4`;
+          filePath = generateTimestampedFilename(defaultName);
+        }
+
+        const buf = Buffer.from(base64, "base64");
+        const storage = getStorage();
+        const url = await storage.writeFile(filePath, buf);
+        videos.push({
+          url,
+          filename: filePath,
+          mimeType: "video/mp4",
+        });
+      };
+
+      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") {
+            await saveVideo(v.bytesBase64Encoded, i);
+          }
         }
       }
-    }
-    if (videos.length > 0) {
-      return JSON.stringify({
-        videos,
-        message: "Video(s) generated successfully",
-      });
-    }
+      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
-    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}`;
+      // 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}`;
+    }, "imageToVideo");
   },
 };