@mixio-pro/kalaasetu-mcp 2.3.24 → 2.3.25

package/package.json

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

package/src/tools/fal/dynamic-tools.ts

@@ -11,6 +11,10 @@ import {
   extractPrimitiveArgs,
 } from "../../utils/tool-wrapper";
 import { sanitizeResponse } from "../../utils/sanitize";
+import {
+  encodeTrackingContext,
+  decodeTrackingContext,
+} from "../../utils/endpoint-encoder";
 import {
   FAL_QUEUE_URL,
   AUTHENTICATED_TIMEOUT,
@@ -124,6 +128,12 @@ function buildZodSchema(
 
   // Always add resume_endpoint for resumable operations
   zodSchema = zodSchema.extend({
+    output_path: z
+      .string()
+      .optional()
+      .describe(
+        "Optional local path/filename to save the final generated asset when status is checked via get_generation_status.",
+      ),
     resume_endpoint: z
       .string()
       .optional()
@@ -167,21 +177,41 @@ export function createToolFromPreset(preset: FalPresetConfig) {
 
           // Handle resume flow
           if (args.resume_endpoint) {
-            if (args.resume_endpoint.startsWith("http")) {
-              statusUrl = args.resume_endpoint;
-              responseUrl = args.resume_endpoint.replace(/\/status$/, "");
-              const urlParts = args.resume_endpoint.split("/");
+            const resumeParts = args.resume_endpoint.split("||");
+            const maybeTracking = resumeParts[resumeParts.length - 1];
+            const decodedTracking =
+              maybeTracking &&
+              !maybeTracking.startsWith("http") &&
+              !maybeTracking.includes("/")
+                ? (() => {
+                    try {
+                      return decodeTrackingContext(maybeTracking);
+                    } catch {
+                      return null;
+                    }
+                  })()
+                : null;
+
+            const resumeEndpointWithoutTracking =
+              decodedTracking?.toolName && resumeParts.length > 1
+                ? resumeParts.slice(0, -1).join("||")
+                : args.resume_endpoint;
+
+            if (resumeEndpointWithoutTracking.startsWith("http")) {
+              statusUrl = resumeEndpointWithoutTracking;
+              responseUrl = resumeEndpointWithoutTracking.replace(/\/status$/, "");
+              const urlParts = resumeEndpointWithoutTracking.split("/");
               const lastPart = urlParts[urlParts.length - 1] || "";
               requestId =
                 lastPart.replace("/status", "") ||
                 urlParts[urlParts.length - 2] ||
                 "unknown";
               context?.log?.info(
-                `Resuming with FAL URL: ${args.resume_endpoint}`,
+                `Resuming with FAL URL: ${resumeEndpointWithoutTracking}`,
               );
             } else {
               // Legacy UUID format - reconstruct URL
-              requestId = args.resume_endpoint;
+              requestId = resumeEndpointWithoutTracking;
               statusUrl = `${FAL_QUEUE_URL}/${preset.modelId}/requests/${requestId}/status`;
               responseUrl = `${FAL_QUEUE_URL}/${preset.modelId}/requests/${requestId}`;
               context?.log?.info(
@@ -204,7 +234,7 @@ export function createToolFromPreset(preset: FalPresetConfig) {
 
             // Build parameters: input_schema defaults → defaultParams → user args
             // Extract only the model parameters (exclude our internal fields)
-            const { resume_endpoint, ...userParams } = args;
+            const { resume_endpoint, output_path, ...userParams } = args;
 
             // Start with defaults from input_schema
             const schemaDefaults: Record<string, any> = {};
@@ -390,7 +420,11 @@ export function createToolFromPreset(preset: FalPresetConfig) {
           return JSON.stringify({
             status: "IN_PROGRESS",
             request_id: requestId,
-            resume_endpoint: statusUrl,
+            resume_endpoint: `${statusUrl}||${encodeTrackingContext({
+              toolName,
+              toolArgs: extractPrimitiveArgs(args),
+              requestId: (context as any)?.requestId,
+            })}`,
             status_url: statusUrl,
             response_url: responseUrl,
             message:

package/src/tools/get-status.ts

@@ -8,6 +8,8 @@ import { safeToolExecute, extractPrimitiveArgs } from "../utils/tool-wrapper";
 import { logger } from "../utils/logger";
 import { getGoogleAccessToken } from "../utils/google-auth";
 import { sanitizeResponse } from "../utils/sanitize";
+import { getStorage } from "../storage";
+import * as path from "path";
 
 function getFalKey(): string {
   const falKey = process.env.FAL_KEY;
@@ -72,6 +74,146 @@ export async function fetchFalResult(responseUrl: string): Promise<any> {
   return await response.json();
 }
 
+function getFalResultUrl(statusUrl: string): string {
+  return statusUrl.replace(/\/status$/, "");
+}
+
+function inferFileExtensionFromUrl(url: string): string {
+  const normalizedUrl = url.split("?")[0]?.toLowerCase() || "";
+  if (normalizedUrl.endsWith(".mp4")) return "mp4";
+  if (normalizedUrl.endsWith(".mov")) return "mov";
+  if (normalizedUrl.endsWith(".webm")) return "webm";
+  if (normalizedUrl.endsWith(".jpg") || normalizedUrl.endsWith(".jpeg"))
+    return "jpg";
+  if (normalizedUrl.endsWith(".webp")) return "webp";
+  if (normalizedUrl.endsWith(".png")) return "png";
+  return "bin";
+}
+
+function inferMimeTypeFromExtension(ext: string): string {
+  switch (ext) {
+    case "mp4":
+      return "video/mp4";
+    case "mov":
+      return "video/quicktime";
+    case "webm":
+      return "video/webm";
+    case "jpg":
+      return "image/jpeg";
+    case "webp":
+      return "image/webp";
+    case "png":
+      return "image/png";
+    default:
+      return "application/octet-stream";
+  }
+}
+
+function outputPathWithIndex(outputPath: string, index: number): string {
+  if (index === 0) {
+    return outputPath;
+  }
+  const extension = path.extname(outputPath);
+  if (!extension) {
+    return `${outputPath}_${index}`;
+  }
+  const base = outputPath.slice(0, -extension.length);
+  return `${base}_${index}${extension}`;
+}
+
+function extractOutputPathFromTrackingContext(
+  trackingContext: any,
+): string | undefined {
+  if (!trackingContext || typeof trackingContext !== "object") {
+    return undefined;
+  }
+
+  const topLevelOutputPath = trackingContext?.toolArgs?.output_path;
+  if (typeof topLevelOutputPath === "string" && topLevelOutputPath.length > 0) {
+    return topLevelOutputPath;
+  }
+
+  const nestedOutputPath = trackingContext?.toolArgs?.parameters?.output_path;
+  if (typeof nestedOutputPath === "string" && nestedOutputPath.length > 0) {
+    return nestedOutputPath;
+  }
+
+  return undefined;
+}
+
+async function saveFalUrls(
+  result: any,
+  outputPath?: string,
+): Promise<{
+  savedVideos: Array<{ url: string; filename: string; mimeType: string }>;
+  savedImages: Array<{ url: string; filename: string; mimeType: string }>;
+}> {
+  const storage = getStorage();
+  const { generateTimestampedFilename } = await import("../utils/filename");
+
+  const savedVideos: Array<{ url: string; filename: string; mimeType: string }> =
+    [];
+  const savedImages: Array<{ url: string; filename: string; mimeType: string }> =
+    [];
+
+  const videoCandidates = Array.isArray(result?.videos) ? result.videos : [];
+  const imageCandidates = Array.isArray(result?.images) ? result.images : [];
+
+  const extractUrl = (item: any): string | undefined => {
+    if (typeof item === "string") return item;
+    if (item && typeof item.url === "string") return item.url;
+    return undefined;
+  };
+
+  for (let i = 0; i < videoCandidates.length; i++) {
+    const sourceUrl = extractUrl(videoCandidates[i]);
+    if (!sourceUrl || !sourceUrl.startsWith("http")) continue;
+
+    const response = await fetch(sourceUrl);
+    if (!response.ok) continue;
+
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const ext = inferFileExtensionFromUrl(sourceUrl);
+    const filePath = outputPath
+      ? outputPathWithIndex(outputPath, i)
+      : generateTimestampedFilename(`fal_video_output_${i}.${ext === "bin" ? "mp4" : ext}`);
+
+    const url = await storage.writeFile(filePath, buffer);
+    savedVideos.push({
+      url,
+      filename: filePath,
+      mimeType: inferMimeTypeFromExtension(ext === "bin" ? "mp4" : ext),
+    });
+  }
+
+  for (let i = 0; i < imageCandidates.length; i++) {
+    const sourceUrl = extractUrl(imageCandidates[i]);
+    if (!sourceUrl || !sourceUrl.startsWith("http")) continue;
+
+    const response = await fetch(sourceUrl);
+    if (!response.ok) continue;
+
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const ext = inferFileExtensionFromUrl(sourceUrl);
+    const defaultOutputPath = generateTimestampedFilename(
+      `fal_image_output_${i}.${ext === "bin" ? "png" : ext}`,
+    );
+
+    const filePath = outputPath
+      ? outputPathWithIndex(outputPath, i)
+      : defaultOutputPath;
+
+    const url = await storage.writeFile(filePath, buffer);
+    savedImages.push({
+      url,
+      filename: filePath,
+      mimeType: inferMimeTypeFromExtension(ext === "bin" ? "png" : ext),
+    });
+  }
+
+  return { savedVideos, savedImages };
+}
+
 export async function checkVertexStatus(resumeEndpoint: string): Promise<any> {
   const accessToken = await getGoogleAccessToken();
 
@@ -244,7 +386,32 @@ export const getGenerationStatus = {
         let result: any;
 
         if (detectedSource === "fal") {
-          result = await checkFalStatus(originalEndpoint);
+          const falStatusResult = await checkFalStatus(originalEndpoint);
+          const falStatus = falStatusResult?.status;
+
+          if (falStatus === "COMPLETED") {
+            const falResultUrl = getFalResultUrl(originalEndpoint);
+            const falFinalResult = await fetchFalResult(falResultUrl);
+            const falOutputPath = extractOutputPathFromTrackingContext(trackingContext);
+            const { savedVideos, savedImages } = await saveFalUrls(
+              falFinalResult,
+              falOutputPath,
+            );
+
+            if (savedVideos.length > 0) {
+              falFinalResult.saved_videos = savedVideos;
+            }
+            if (savedImages.length > 0) {
+              falFinalResult.saved_images = savedImages;
+            }
+
+            result = {
+              ...falFinalResult,
+              status: "COMPLETED",
+            };
+          } else {
+            result = falStatusResult;
+          }
         } else {
           result = await checkVertexStatus(originalEndpoint);
         }
@@ -277,7 +444,9 @@ export const getGenerationStatus = {
             result: safeResult,
             message:
               status === "COMPLETED"
-                ? "Generation completed! Check 'result.response.saved_videos' for the video URLs."
+                ? detectedSource === "fal"
+                  ? "Generation completed! Check 'result.saved_videos' or 'result.saved_images' for downloaded asset URLs."
+                  : "Generation completed! Check 'result.response.saved_videos' for the video URLs."
                 : status === "FAILED"
                   ? "Generation failed. Check the 'result' field for error details."
                   : "Generation is still in progress. Call this tool again with the same resume_endpoint to check later.",