@mixio-pro/kalaasetu-mcp 2.3.31 → 2.3.33

package/fal-config.json

@@ -143,6 +143,40 @@
           "default": "replace_audio_and_video"
         }
       }
+    },
+    {
+      "presetName": "multi_angle",
+      "intent": "Generate a single multi-angle image edit using Qwen Image Edit with the Mixio multi-angle LoRA.",
+      "modelId": "fal-ai/qwen-image-edit-2509-lora",
+      "inputType": "image",
+      "outputType": "image",
+      "enabled": false,
+      "pricing": {
+        "baseCredits": 15,
+        "rounding": "ceil"
+      }
+    },
+    {
+      "presetName": "multi_angle_batch",
+      "intent": "Generate multiple multi-angle image edits using Qwen Image Edit with the Mixio multi-angle LoRA.",
+      "modelId": "fal-ai/qwen-image-edit-2509-lora",
+      "inputType": "image",
+      "outputType": "image",
+      "enabled": false,
+      "pricing": {
+        "baseCredits": 15,
+        "modifiers": [
+          {
+            "field": "batch_count",
+            "mode": "step",
+            "operation": "add",
+            "step": 1,
+            "offset": 1,
+            "valuePerStep": 15
+          }
+        ],
+        "rounding": "ceil"
+      }
     }
   ]
 }

package/package.json

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

@@ -100,6 +100,8 @@ async function main() {
     server.addTool(falGetPresetDetails);
     server.addTool(falUploadFile);
     server.addTool(falGenerate);
+    server.addTool(mixioMultiAngle);
+    server.addTool(mixioMultiAngleBatch);
     // 4. Register Dynamic FAL AI Tools
     // These are now based on potentially synced remote config
     const falTools = createAllFalTools();
@@ -109,8 +111,6 @@ async function main() {
   }
 
   // 4. Add Mixio Tools
-  // server.addTool(mixioMultiAngle);
-  // server.addTool(mixioMultiAngleBatch);
   // server.addTool(mixioNextScene);
   // server.addTool(mixioFaceSwap);
   if (process.env.GROK_ENABLED === "true") {

package/src/tools/get-status.ts

@@ -10,6 +10,7 @@ import { getGoogleAccessToken } from "../utils/google-auth";
 import { sanitizeResponse } from "../utils/sanitize";
 import { getStorage } from "../storage";
 import * as path from "path";
+import { parseVertexEndpoint, buildVertexCompositeEndpoint } from "../utils/vertex-endpoint";
 
 function getFalKey(): string {
   const falKey = process.env.FAL_KEY;
@@ -352,9 +353,12 @@ export const getGenerationStatus = {
         if (resume_endpoint.includes("||")) {
           const parts = resume_endpoint.split("||");
           
-          // For FAL jobs starting with https://
-          if (parts?.[0]?.startsWith("https://")) {
-            originalEndpoint = parts[0];
+          // Domain-specific detection
+          const isFal = parts?.[0]?.includes("fal.run");
+          const isVertex = parts?.[0]?.includes("googleapis.com") || parts?.[1]?.includes("v1/projects/");
+
+          if (isFal) {
+            originalEndpoint = parts[0]!;
             // Part 1 is tracking context (base64)
             if (parts.length >= 2 && parts[1]) {
               try {
@@ -370,27 +374,40 @@ export const getGenerationStatus = {
             if (parts.length >= 3 && parts[2] && !outputPath) {
               outputPath = parts[2];
             }
+          } else if (isVertex) {
+            // New robust Vertex parsing
+            // For get_generation_status, we don't necessarily know the modelId here, 
+            // but parseVertexEndpoint uses it mainly for constructing the default op name.
+            // Since we HAVE a composite endpoint, the modelId passed to parseVertexEndpoint won't be used for the op name.
+            const parsed = parseVertexEndpoint(resume_endpoint, "veo-3.1-lite-generate-001");
+            originalEndpoint = buildVertexCompositeEndpoint(parsed.fetchUrl, parsed.operationName);
+            outputPath = args.output_path || parsed.outputPath || outputPath;
+            
+            if (parsed.trackingContext) {
+              try {
+                const { decodeTrackingContext } = await import("../utils/endpoint-encoder");
+                trackingContext = decodeTrackingContext(parsed.trackingContext);
+              } catch (err) {}
+            }
           } else {
-            // Vertex logic (legacy/other)
+            // Legacy/Fallback Vertex logic
             const lastPart = parts[parts.length - 1];
             if (
               lastPart &&
               !lastPart.startsWith("http") &&
               !lastPart.includes("/") &&
-              !lastPart.includes("mixio-pro") // Ensure it doesn't look like an operation path or URL
+              !lastPart.includes("mixio-pro")
             ) {
               try {
                 const { decodeTrackingContext } =
                   await import("../utils/endpoint-encoder");
                 trackingContext = decodeTrackingContext(lastPart);
                 if (trackingContext?.toolName) {
-                  // Remove the tracking piece from the endpoint we pass to handlers
                   originalEndpoint = parts.slice(0, -1).join("||");
                 }
               } catch (err) {}
             }
             
-            // For Vertex, if outputPath is not explicitly provided, it might be in the 3rd part of originalEndpoint
             if (!outputPath) {
               const vertexParts = originalEndpoint.split("||");
               if (vertexParts.length >= 3) {

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

@@ -5,6 +5,7 @@ import { safeToolExecute, extractPrimitiveArgs } from "../utils/tool-wrapper";
 
 import { getGoogleAccessToken } from "../utils/google-auth";
 import { checkVertexStatus } from "./get-status";
+import { parseVertexEndpoint, buildVertexCompositeEndpoint, buildVertexFetchUrl } from "../utils/vertex-endpoint";
 
 async function wait(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -222,18 +223,17 @@ export const imageToVideo = {
           throw new Error(`Google Cloud authentication failed: ${errorMsg}`);
         }
 
-        const fetchUrl = `https://${location}-aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/${modelId}:fetchPredictOperation`;
-
-        // If resuming, reconstruct the full operation path from the UUID
+        let fetchUrl = buildVertexFetchUrl(modelId, projectId, location);
         let operationName: string | undefined;
+        let outputPath = args.output_path || "";
+        let preservedTrackingContext: string | undefined;
+
         if (args.resume_endpoint) {
-          // Support both UUID-only and full path formats
-          if (args.resume_endpoint.includes("/")) {
-            operationName = args.resume_endpoint; // Already a full path
-          } else {
-            // Reconstruct full path from UUID
-            operationName = `projects/${projectId}/locations/${location}/publishers/google/models/${modelId}/operations/${args.resume_endpoint}`;
-          }
+          const parsed = parseVertexEndpoint(args.resume_endpoint, modelId, projectId, location);
+          fetchUrl = parsed.fetchUrl;
+          operationName = parsed.operationName;
+          outputPath = parsed.outputPath || outputPath;
+          preservedTrackingContext = parsed.trackingContext;
         }
         let current: any;
 
@@ -367,8 +367,7 @@ export const imageToVideo = {
 
         // Construct the composite resume_endpoint: fetchUrl||operationName||outputPath
         // This allows get_generation_status to use the URL directly and preserve output_path
-        const outputPathPart = args.output_path || "";
-        const compositeResumeEndpoint = `${fetchUrl}||${operationName}||${outputPathPart}`;
+        const compositeResumeEndpoint = buildVertexCompositeEndpoint(fetchUrl, operationName, outputPath);
 
         // Stream the resume_endpoint to the LLM immediately (before polling starts)
         // This way the LLM has it even if MCP client times out during polling
@@ -428,7 +427,7 @@ export const imageToVideo = {
           return JSON.stringify({
             status: "IN_PROGRESS",
             request_id: operationName,
-            resume_endpoint: `${compositeResumeEndpoint}||${packedTracking}`,
+            resume_endpoint: buildVertexCompositeEndpoint(fetchUrl, operationName, outputPath, packedTracking),
             message:
               "Still in progress. Call this tool again with resume_endpoint to continue checking.",
           });

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

@@ -6,6 +6,11 @@ import { getGoogleAccessToken } from "../utils/google-auth";
 import { ensureLocalFile } from "../utils/url-file";
 import { encodeTrackingContext } from "../utils/endpoint-encoder";
 import { checkVertexStatus } from "./get-status";
+import { 
+  parseVertexEndpoint, 
+  buildVertexCompositeEndpoint, 
+  buildVertexFetchUrl 
+} from "../utils/vertex-endpoint";
 
 const DEFAULT_PROJECT_ID = "mixio-pro";
 const DEFAULT_LOCATION = "us-central1";
@@ -24,12 +29,7 @@ type ToolContext = {
   requestId?: string;
 };
 
-interface ParsedResumeEndpoint {
-  fetchUrl: string;
-  operationName?: string;
-  outputPath?: string;
-  trackingContext?: string;
-}
+
 
 async function wait(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -84,43 +84,7 @@ async function fileToBase64(
   }
 }
 
-function buildFetchUrl(modelId: string): string {
-  return `https://${DEFAULT_LOCATION}-aiplatform.googleapis.com/v1/projects/${DEFAULT_PROJECT_ID}/locations/${DEFAULT_LOCATION}/publishers/google/models/${modelId}:fetchPredictOperation`;
-}
-
-function parseResumeEndpoint(
-  resumeEndpoint: string,
-  modelId: string,
- ): ParsedResumeEndpoint {
-  const defaultFetchUrl = buildFetchUrl(modelId);
-
-  if (resumeEndpoint.includes("||")) {
-    const parts = resumeEndpoint.split("||");
-    const fetchUrl = parts[0] || "";
-    const operationName = parts[1] || "";
-
-    if (fetchUrl.startsWith("http") && operationName) {
-      return {
-        fetchUrl,
-        operationName,
-        outputPath: parts[2] || "",
-        trackingContext: parts.length > 3 ? parts.slice(3).join("||") : undefined,
-      };
-    }
-  }
-
-  if (resumeEndpoint.includes("/")) {
-    return {
-      fetchUrl: defaultFetchUrl,
-      operationName: resumeEndpoint,
-    };
-  }
 
-  return {
-    fetchUrl: defaultFetchUrl,
-    operationName: `projects/${DEFAULT_PROJECT_ID}/locations/${DEFAULT_LOCATION}/publishers/google/models/${modelId}/operations/${resumeEndpoint}`,
-  };
-}
 
 function normalizeDurationSeconds(durationSecondsRaw?: string): number {
   const requestedDuration = parseInt(durationSecondsRaw || "6");
@@ -343,14 +307,14 @@ export const ingredientsToVideo = {
           throw new Error(`Google Cloud authentication failed: ${errorMessage}`);
         }
 
-        let fetchUrl = buildFetchUrl(modelId);
+        let fetchUrl = buildVertexFetchUrl(modelId);
         let operationName: string | undefined;
         let outputPath = args.output_path || "";
         let preservedTrackingContext: string | undefined;
         let current: any;
 
         if (args.resume_endpoint) {
-          const parsedResume = parseResumeEndpoint(args.resume_endpoint, modelId);
+          const parsedResume = parseVertexEndpoint(args.resume_endpoint, modelId);
           fetchUrl = parsedResume.fetchUrl;
           operationName = parsedResume.operationName;
           outputPath = parsedResume.outputPath || outputPath;
@@ -418,7 +382,7 @@ export const ingredientsToVideo = {
           );
         }
 
-        const compositeResumeEndpoint = `${fetchUrl}||${operationName}||${outputPath}`;
+        const compositeResumeEndpoint = buildVertexCompositeEndpoint(fetchUrl, operationName, outputPath);
 
         if (context?.streamContent) {
           await context.streamContent({
@@ -471,7 +435,7 @@ export const ingredientsToVideo = {
           return JSON.stringify({
             status: "IN_PROGRESS",
             request_id: operationName,
-            resume_endpoint: `${compositeResumeEndpoint}||${packedTracking}`,
+            resume_endpoint: buildVertexCompositeEndpoint(fetchUrl, operationName, outputPath, packedTracking),
             message:
               "Still in progress. Call this tool again with resume_endpoint to continue checking.",
           });