@mixio-pro/kalaasetu-mcp 2.0.6-beta → 2.0.7-beta

package/package.json

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

@@ -1,14 +1,15 @@
 #!/usr/bin/env bun
 import { FastMCP } from "fastmcp";
 import pkg from "../package.json";
-import { geminiEditImage, geminiTextToImage } from "./tools/gemini";
-import { imageToVideo } from "./tools/image-to-video";
 import {
   falListPresets,
   falGetPresetDetails,
-  falGenerate,
   falUploadFile,
 } from "./tools/fal";
+import { createAllFalTools } from "./tools/fal/dynamic-tools";
+import { geminiEditImage, geminiTextToImage } from "./tools/gemini";
+import { imageToVideo } from "./tools/image-to-video";
+import { getGenerationStatus } from "./tools/get-status";
 
 const server = new FastMCP({
   name: "Kalaasetu MCP Server",
@@ -36,13 +37,17 @@ server.addTool(imageToVideo);
 // server.addTool(perplexityImages);
 // server.addTool(perplexityVideos);
 
-import { getGenerationStatus } from "./tools/get-status";
-
-// Fal AI Tools
+// Discovery and Utility Tools
 server.addTool(falListPresets);
-server.addTool(falGenerate);
+server.addTool(falGetPresetDetails);
 server.addTool(falUploadFile);
 
+// Dynamic FAL AI Tools - each preset becomes a separate tool (prefixed with fal_)
+const falTools = createAllFalTools();
+for (const tool of falTools) {
+  server.addTool(tool);
+}
+
 // Unified Status Tool (works with both FAL and Vertex AI)
 server.addTool(getGenerationStatus);
 

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

@@ -0,0 +1,406 @@
+/**
+ * Dynamic FAL Tools Generator
+ *
+ * Creates MCP tools dynamically from preset configurations.
+ * Each preset becomes a first-class MCP tool with its own Zod schema.
+ */
+
+import { z, type ZodTypeAny } from "zod";
+import { safeToolExecute } from "../../utils/tool-wrapper";
+import { resolveEnhancer } from "../../utils/prompt-enhancer-presets";
+import { sanitizeResponse } from "../../utils/sanitize";
+import {
+  FAL_QUEUE_URL,
+  AUTHENTICATED_TIMEOUT,
+  getApiKey,
+  loadFalConfig,
+  type FalPresetConfig,
+} from "./config";
+
+/**
+ * Helper to wait for a specified duration.
+ */
+async function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Make an authenticated request to fal.ai API.
+ */
+async function authenticatedRequest(
+  url: string,
+  method: "GET" | "POST" | "PUT" = "GET",
+  jsonData?: Record<string, any>
+): Promise<any> {
+  const headers: Record<string, string> = {
+    Authorization: `Key ${getApiKey()}`,
+    "Content-Type": "application/json",
+  };
+
+  const options: RequestInit = {
+    method,
+    headers,
+    signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+  };
+
+  if (jsonData && (method === "POST" || method === "PUT")) {
+    options.body = JSON.stringify(jsonData);
+  }
+
+  const response = await fetch(url, options);
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    if (response.status === 404) {
+      return {
+        status: "IN_PROGRESS_WAITING",
+        detail: "Request not yet available in queue.",
+      };
+    }
+    throw new Error(`[${response.status}] API error: ${errorText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Sanitize parameters by removing null/undefined values.
+ */
+function sanitizeParameters(
+  parameters: Record<string, any>
+): Record<string, any> {
+  return Object.fromEntries(
+    Object.entries(parameters).filter(([_, v]) => v != null)
+  );
+}
+
+/**
+ * Progress reporter interface for MCP context compatibility.
+ */
+interface ProgressContext {
+  reportProgress?: (progress: {
+    progress: number;
+    total: number;
+  }) => Promise<void>;
+  streamContent?: (
+    content: { type: "text"; text: string } | { type: "text"; text: string }[]
+  ) => Promise<void>;
+  log?: {
+    info: (message: string, data?: any) => void;
+    debug: (message: string, data?: any) => void;
+  };
+}
+
+
+/**
+ * Build a Zod object schema from preset input_schema using built-in z.fromJSONSchema.
+ */
+function buildZodSchema(
+  inputSchema: Record<string, any> | undefined,
+  defaultParams?: Record<string, any>
+): z.ZodObject<any> {
+  // Construct a properties object for JSON schema
+  const properties: Record<string, any> = {};
+
+  if (inputSchema) {
+    for (const [key, schema] of Object.entries(inputSchema)) {
+      properties[key] = { ...schema };
+      // Override default if specified in defaultParams
+      if (defaultParams && defaultParams[key] !== undefined) {
+        properties[key].default = defaultParams[key];
+      }
+    }
+  }
+
+  // Create full JSON schema object
+  const jsonSchema = {
+    type: "object",
+    properties,
+  };
+
+  // Convert to Zod using Zod 4's fromJSONSchema (experimental)
+  let zodSchema = (z as any).fromJSONSchema(jsonSchema) as z.ZodObject<any>;
+
+  // Always add resume_endpoint for resumable operations
+  zodSchema = zodSchema.extend({
+    resume_endpoint: z
+      .string()
+      .optional()
+      .describe(
+        "If provided, resume polling for an existing request instead of starting a new one. " +
+          "Use the 'resume_endpoint' returned in an 'IN_PROGRESS' response."
+      ),
+    auto_enhance: z
+      .boolean()
+      .default(true) // Our custom default
+      .describe(
+        "Whether to automatically enhance the prompt. Set to false to disable."
+      ),
+  });
+
+  return zodSchema;
+}
+
+/**
+ * Create an MCP tool from a preset configuration.
+ */
+export function createToolFromPreset(preset: FalPresetConfig) {
+  const zodSchema = buildZodSchema(
+    preset.input_schema as Record<string, any>,
+    preset.defaultParams
+  );
+
+  const toolName = preset.presetName.startsWith("fal_")
+    ? preset.presetName
+    : `fal_${preset.presetName}`;
+
+  return {
+    name: toolName,
+    description:
+      preset.intent +
+      (preset.description ? ` ${preset.description}` : "") +
+      ` [Model: ${preset.modelId}]`,
+    parameters: zodSchema,
+    timeoutMs: 90000, // 90 seconds MCP timeout
+
+    execute: async (
+      args: Record<string, any>,
+      context?: ProgressContext
+    ) => {
+      return safeToolExecute(async () => {
+        let statusUrl: string;
+        let responseUrl: string;
+        let requestId: string;
+
+        // 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 lastPart = urlParts[urlParts.length - 1] || "";
+            requestId =
+              lastPart.replace("/status", "") ||
+              urlParts[urlParts.length - 2] ||
+              "unknown";
+            context?.log?.info(`Resuming with FAL URL: ${args.resume_endpoint}`);
+          } else {
+            // Legacy UUID format - reconstruct URL
+            requestId = args.resume_endpoint;
+            statusUrl = `${FAL_QUEUE_URL}/${preset.modelId}/requests/${requestId}/status`;
+            responseUrl = `${FAL_QUEUE_URL}/${preset.modelId}/requests/${requestId}`;
+            context?.log?.info(
+              `Resuming polling for ${preset.modelId} request: ${requestId}`
+            );
+          }
+        } else {
+          // New request - start generation
+          try {
+            const apiKey = getApiKey();
+            if (context?.streamContent) {
+              await context.streamContent({
+                type: "text" as const,
+                text: `[FAL] ✓ API key found (${apiKey.slice(0, 8)}...). Using model: ${preset.modelId}`,
+              });
+            }
+          } catch (keyError: any) {
+            throw keyError;
+          }
+
+          // Build parameters: input_schema defaults → defaultParams → user args
+          // Extract only the model parameters (exclude our internal fields)
+          const { resume_endpoint, auto_enhance, ...userParams } = args;
+
+          // Start with defaults from input_schema
+          const schemaDefaults: Record<string, any> = {};
+          if (preset.input_schema) {
+            for (const [key, paramSchema] of Object.entries(preset.input_schema)) {
+              if ((paramSchema as any).default !== undefined) {
+                schemaDefaults[key] = (paramSchema as any).default;
+              }
+            }
+          }
+
+          // Merge: schema defaults → preset defaultParams → user params
+          const mergedParams = {
+            ...schemaDefaults,
+            ...(preset.defaultParams || {}),
+            ...userParams,
+          };
+
+          // Apply prompt enhancement if enabled
+          const shouldEnhance = auto_enhance !== false;
+          if (shouldEnhance && preset.promptEnhancer && mergedParams.prompt) {
+            const enhancerName =
+              typeof preset.promptEnhancer === "string"
+                ? preset.promptEnhancer
+                : null;
+
+            if (enhancerName === "ltx2") {
+              const { enhancePromptWithLLM, isLLMEnhancerAvailable } =
+                await import("../../utils/llm-prompt-enhancer");
+              if (isLLMEnhancerAvailable()) {
+                try {
+                  const originalPrompt = mergedParams.prompt;
+                  mergedParams.prompt = await enhancePromptWithLLM(
+                    mergedParams.prompt,
+                    "ltx2"
+                  );
+                  context?.log?.info(
+                    `LLM-enhanced prompt: "${originalPrompt}" → "${mergedParams.prompt}"`
+                  );
+                } catch (err) {
+                  context?.log?.info(
+                    `LLM enhancement failed, using original prompt`
+                  );
+                }
+              }
+            } else if (preset.promptEnhancer) {
+              const enhancer = resolveEnhancer(preset.promptEnhancer);
+              if (enhancer.hasTransformations()) {
+                mergedParams.prompt = enhancer.enhance(mergedParams.prompt);
+                const negatives = enhancer.getNegativeElements();
+                if (negatives && !mergedParams.negative_prompt) {
+                  mergedParams.negative_prompt = negatives;
+                }
+              }
+            }
+          }
+
+          const sanitizedParams = sanitizeParameters(mergedParams);
+          const url = `${FAL_QUEUE_URL}/${preset.modelId}`;
+
+          if (context?.streamContent) {
+            await context.streamContent({
+              type: "text" as const,
+              text: `[FAL] Submitting generation request to ${preset.modelId}...`,
+            });
+          }
+
+          const queueRes = await authenticatedRequest(
+            url,
+            "POST",
+            sanitizedParams
+          );
+
+          if (!queueRes.request_id && !queueRes.status_url) {
+            return JSON.stringify(sanitizeResponse(queueRes));
+          }
+
+          requestId =
+            queueRes.request_id || queueRes.status_url?.split("/").pop() || "";
+
+          if (!requestId) {
+            throw new Error("Could not extract request ID from response");
+          }
+
+          statusUrl =
+            queueRes.status_url ||
+            `${FAL_QUEUE_URL}/${preset.modelId}/requests/${requestId}/status`;
+          responseUrl =
+            queueRes.response_url ||
+            `${FAL_QUEUE_URL}/${preset.modelId}/requests/${requestId}`;
+
+          if (context?.streamContent) {
+            await context.streamContent({
+              type: "text" as const,
+              text: `[FAL] Generation started. resume_endpoint: ${statusUrl}`,
+            });
+          }
+        }
+
+        // Stream message for resume calls
+        if (args.resume_endpoint && context?.streamContent) {
+          await context.streamContent({
+            type: "text" as const,
+            text: `[FAL] Resuming status check for job: ${requestId}`,
+          });
+        }
+
+        // Poll for completion
+        const startTime = Date.now();
+        const MAX_POLL_TIME = 60000; // 60 seconds internal timeout
+        let pollCount = 0;
+        const POLL_INTERVAL = 3000;
+
+        while (Date.now() - startTime < MAX_POLL_TIME) {
+          pollCount++;
+          let res;
+          try {
+            res = await authenticatedRequest(statusUrl, "GET");
+          } catch (e: any) {
+            if (`${e}`.includes("405")) {
+              context?.log?.info(
+                `Status check 405 on ${statusUrl}, trying fallback...`
+              );
+              res = await authenticatedRequest(responseUrl, "GET");
+              statusUrl = responseUrl;
+            } else {
+              throw e;
+            }
+          }
+
+          if (res.status_url) statusUrl = res.status_url;
+          if (res.response_url) responseUrl = res.response_url;
+
+          if (context?.reportProgress) {
+            const elapsed = Date.now() - startTime;
+            const progressPercent = Math.min(
+              Math.round((elapsed / MAX_POLL_TIME) * 100),
+              99
+            );
+            await context.reportProgress({
+              progress: progressPercent,
+              total: 100,
+            });
+          }
+
+          if (context?.streamContent && pollCount % 5 === 0) {
+            await context.streamContent({
+              type: "text" as const,
+              text: `[FAL] Still processing... (${Math.round(
+                (Date.now() - startTime) / 1000
+              )}s elapsed, status: ${res.status})`,
+            });
+          }
+
+          if (res.status === "COMPLETED") {
+            if (context?.reportProgress) {
+              await context.reportProgress({ progress: 100, total: 100 });
+            }
+            const finalResult = await authenticatedRequest(responseUrl, "GET");
+            return JSON.stringify(sanitizeResponse(finalResult));
+          }
+
+          if (res.status === "FAILED") {
+            throw new Error(
+              `Generation failed: ${JSON.stringify(res.error || res)}`
+            );
+          }
+
+          await wait(POLL_INTERVAL);
+        }
+
+        // Timeout - return resume_endpoint
+        return JSON.stringify({
+          status: "IN_PROGRESS",
+          request_id: requestId,
+          resume_endpoint: statusUrl,
+          status_url: statusUrl,
+          response_url: responseUrl,
+          message:
+            "The generation is still in progress. Call this tool again with resume_endpoint to continue polling.",
+        });
+      }, preset.presetName);
+    },
+  };
+}
+
+/**
+ * Create all FAL tools from the configuration.
+ * Each preset becomes a separate MCP tool.
+ */
+export function createAllFalTools(): ReturnType<typeof createToolFromPreset>[] {
+  const config = loadFalConfig();
+  return config.presets.map((preset) => createToolFromPreset(preset));
+}

package/src/tools/fal/generate.ts

@@ -12,7 +12,6 @@ import {
   getApiKey,
   loadFalConfig,
 } from "./config";
-import { checkFalStatus, fetchFalResult } from "../get-status";
 
 /**
  * Helper to wait for a specified duration.
@@ -106,7 +105,6 @@ export const falGenerate = {
       ),
     parameters: z
       .record(z.string(), z.any())
-      .optional()
       .describe(
         "A dictionary of model-specific parameters (e.g., { 'prompt': '...', 'image_url': '...' }). " +
           "These override the default values defined in the preset. " +
@@ -371,14 +369,14 @@ export const falGenerate = {
         pollCount++;
         let res;
         try {
-          res = await checkFalStatus(statusUrl);
+          res = await authenticatedRequest(statusUrl, "GET");
         } catch (e: any) {
           if (`${e}`.includes("405")) {
             context?.log?.info(
               `Status check 405 on ${statusUrl}, trying fallback to responseUrl...`
             );
             // Try checking the request root URL instead of /status
-            res = await fetchFalResult(responseUrl);
+            res = await authenticatedRequest(responseUrl, "GET");
             // If successful, update statusUrl to match for future polls
             statusUrl = responseUrl;
           } else {
@@ -421,7 +419,7 @@ export const falGenerate = {
             await context.reportProgress({ progress: 100, total: 100 });
           }
           // responseUrl is now guaranteed to be correct/fresh from polling
-          const finalResult = await fetchFalResult(responseUrl);
+          const finalResult = await authenticatedRequest(responseUrl, "GET");
           return JSON.stringify(finalResult);
         }
 

package/src/tools/fal/models.ts

@@ -72,7 +72,9 @@ export const falListPresets = {
 
       // Fetch schemas for presets that don't have them (or if refresh requested)
       for (const preset of config.presets) {
-        const shouldFetch = !preset.input_schema || args.refresh_schemas;
+        const hasSchema =
+          preset.input_schema && Object.keys(preset.input_schema).length > 0;
+        const shouldFetch = !hasSchema || args.refresh_schemas;
         console.log(
           `[fal_list_presets] ${
             preset.presetName

package/src/tools/get-status.ts

@@ -6,6 +6,7 @@
 import { z } from "zod";
 import { safeToolExecute } from "../utils/tool-wrapper";
 import { getGoogleAccessToken } from "../utils/google-auth";
+import { sanitizeResponse } from "../utils/sanitize";
 
 const FAL_KEY = process.env.FAL_KEY;
 
@@ -67,9 +68,7 @@ export async function fetchFalResult(responseUrl: string): Promise<any> {
   return await response.json();
 }
 
-export async function checkVertexStatus(
-  resumeEndpoint: string
-): Promise<any> {
+export async function checkVertexStatus(resumeEndpoint: string): Promise<any> {
   const accessToken = await getGoogleAccessToken();
 
   // resumeEndpoint is composite format: fetchUrl||operationName||outputPath
@@ -80,7 +79,7 @@ export async function checkVertexStatus(
 
   if (!fetchUrl || !operationName) {
     throw new Error(
-      "Invalid Vertex resume_endpoint format. Expected 'fetchUrl||operationName[||outputPath]'."
+      "Invalid Vertex resume_endpoint format. Expected 'fetchUrl||operationName[||outputPath]'.",
     );
   }
 
@@ -117,9 +116,7 @@ export async function checkVertexStatus(
           if (outputPath) {
             // Use custom path, add index for subsequent videos
             filePath =
-              i === 0
-                ? outputPath
-                : outputPath.replace(/\.mp4$/i, `_${i}.mp4`);
+              i === 0 ? outputPath : outputPath.replace(/\.mp4$/i, `_${i}.mp4`);
           } else {
             // Default timestamped filename
             filePath = generateTimestampedFilename(`video_output_${i}.mp4`);
@@ -131,6 +128,8 @@ export async function checkVertexStatus(
             filename: filePath,
             mimeType: "video/mp4",
           });
+          // CRITICAL: Remove base64 data to prevent context window poisoning
+          delete v.bytesBase64Encoded;
         }
       }
 
@@ -157,14 +156,14 @@ export const getGenerationStatus = {
       .describe(
         "The resume_endpoint returned by the original generation tool. " +
           "For FAL: This is a full URL (starts with 'https://queue.fal.run/...'). " +
-          "For Vertex AI: This is an operation name or full path."
+          "For Vertex AI: This is an operation name or full path.",
       ),
     source: z
       .enum(["fal", "vertex", "auto"])
       .optional()
       .default("auto")
       .describe(
-        "Source of the operation: 'fal' for FAL AI, 'vertex' for Google Vertex AI, or 'auto' to auto-detect based on resume_endpoint format."
+        "Source of the operation: 'fal' for FAL AI, 'vertex' for Google Vertex AI, or 'auto' to auto-detect based on resume_endpoint format.",
       ),
   }),
   timeoutMs: 30000, // 30 seconds for status check
@@ -173,10 +172,7 @@ export const getGenerationStatus = {
     source?: "fal" | "vertex" | "auto";
   }) => {
     return safeToolExecute(async () => {
-      const {
-        resume_endpoint,
-        source = "auto",
-      } = args;
+      const { resume_endpoint, source = "auto" } = args;
       const project_id = "mixio-pro";
       const location_id = "us-central1";
 
@@ -203,25 +199,27 @@ export const getGenerationStatus = {
 
       // Normalize the response
       const status =
-        (result as any).status || ((result as any).done ? "COMPLETED" : "IN_PROGRESS");
+        (result as any).status ||
+        ((result as any).done ? "COMPLETED" : "IN_PROGRESS");
+
+      const safeResult = sanitizeResponse(result);
 
       return JSON.stringify(
         {
           source: detectedSource,
           status,
           resume_endpoint,
-          result,
+          result: safeResult,
           message:
             status === "COMPLETED"
-              ? "Generation completed! The result is included in the 'result' field."
+              ? "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.",
+                ? "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.",
         },
         null,
-        2
+        2,
       );
     }, "get_generation_status");
   },
 };
-

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

@@ -17,7 +17,7 @@ async function wait(ms: number): Promise<void> {
 import { ensureLocalFile } from "../utils/url-file";
 
 async function fileToBase64(
-  filePath: string
+  filePath: string,
 ): Promise<{ data: string; mimeType: string }> {
   const fileResult = await ensureLocalFile(filePath);
 
@@ -56,7 +56,7 @@ export const imageToVideo = {
       .string()
       .optional()
       .describe(
-        "Required for new requests. Descriptive text for the video action and style (e.g., 'A robot walking through a neon city at night')."
+        "Required for new requests. Descriptive text for the video action and style (e.g., 'A robot walking through a neon city at night').",
       ),
     image_path: z
       .string()
@@ -66,21 +66,21 @@ export const imageToVideo = {
       .string()
       .optional()
       .describe(
-        "Optional: Absolute local path or URL to the ENDING image frame to guide the video's conclusion."
+        "Optional: Absolute local path or URL to the ENDING image frame to guide the video's conclusion.",
       ),
     aspect_ratio: z
       .string()
       .optional()
       .default("16:9")
       .describe(
-        "Target aspect ratio: '16:9' (landscape) or '9:16' (vertical)."
+        "Target aspect ratio: '16:9' (landscape) or '9:16' (vertical).",
       ),
     duration_seconds: z
       .string()
       .optional()
       .default("6")
       .describe(
-        "Target duration. Vertex AI ONLY supports exactly '4', '6', or '8' seconds. Other values will be rounded to the nearest supported step."
+        "Target duration. Vertex AI ONLY supports exactly '4', '6', or '8' seconds. Other values will be rounded to the nearest supported step.",
       ),
     resolution: z
       .string()
@@ -90,38 +90,38 @@ export const imageToVideo = {
       .string()
       .optional()
       .describe(
-        "Visual elements or styles to EXCLUDE from the generated video."
+        "Visual elements or styles to EXCLUDE from the generated video.",
       ),
     person_generation: z
       .string()
       .optional()
       .describe(
-        "Policy for generating people: 'allow_adult' (standard) or 'allow_all'. Note: Gemini 1.5+ safety filters apply."
+        "Policy for generating people: 'allow_adult' (standard) or 'allow_all'. Note: Gemini 1.5+ safety filters apply.",
       ),
     reference_images: z
       .array(z.string())
       .optional()
       .describe(
-        "Optional: Additional images (up to 3) to guide style or character consistency."
+        "Optional: Additional images (up to 3) to guide style or character consistency.",
       ),
     output_path: z
       .string()
       .optional()
       .describe(
-        "Optional: Local path to save the resulting .mp4 file. Defaults to timestamped filename."
+        "Optional: Local path to save the resulting .mp4 file. Defaults to timestamped filename.",
       ),
     model_id: z
       .string()
       .optional()
       .default("veo-3.1-fast-generate-001")
       .describe(
-        "Specific Vertex Veo model ID to use. Default Value is veo-3.1-fast-generate-001"
+        "Specific Vertex Veo model ID to use. Default Value is veo-3.1-fast-generate-001",
       ),
     generate_audio: z
       .boolean()
       .optional()
       .describe(
-        "If true, Vertex will attempt to synthesize synchronized audio for the video."
+        "If true, Vertex will attempt to synthesize synchronized audio for the video.",
       )
       .default(false),
     resume_endpoint: z
@@ -129,20 +129,20 @@ export const imageToVideo = {
       .optional()
       .describe(
         "If provided, the tool will check the status of an existing Vertex operation instead of starting a new one. " +
-          "Use the 'resume_endpoint' returned in an 'IN_PROGRESS' response."
+          "Use the 'resume_endpoint' returned in an 'IN_PROGRESS' response.",
       ),
     auto_enhance: z
       .boolean()
       .optional()
       .describe(
-        "Whether to automatically enhance the prompt using Veo/LTX guidelines (default: true if enabled via preset or config). Set to false to disable enhancement."
+        "Whether to automatically enhance the prompt using Veo/LTX guidelines (default: true if enabled via preset or config). Set to false to disable enhancement.",
       ),
     enhancer_preset: z
       .string()
       .optional()
       .describe(
         "Optional: Name of a video prompt enhancer preset (e.g., 'veo', 'ltx2', 'cinematic_video'). " +
-          "When using Veo, setting this to 'veo' (or setting auto_enhance=true) will trigger the LLM-based enhancer."
+          "When using Veo, setting this to 'veo' (or setting auto_enhance=true) will trigger the LLM-based enhancer.",
       ),
   }),
   timeoutMs: 90000, // 90 seconds MCP timeout (internal timeout is 60s)
@@ -177,7 +177,7 @@ export const imageToVideo = {
         info: (msg: string, data?: any) => void;
         debug: (msg: string, data?: any) => void;
       };
-    }
+    },
   ) {
     return safeToolExecute(async () => {
       const projectId = "mixio-pro";
@@ -314,7 +314,7 @@ export const imageToVideo = {
             refImages = args.reference_images;
           } else {
             throw new Error(
-              "Invalid reference_images: must be array or string"
+              "Invalid reference_images: must be array or string",
             );
           }
 
@@ -329,7 +329,7 @@ export const imageToVideo = {
                   },
                   referenceType: "asset",
                 };
-              })
+              }),
             );
           }
         }
@@ -372,7 +372,7 @@ export const imageToVideo = {
               try {
                 enhancedPrompt = await enhancePromptWithLLM(args.prompt, "veo");
                 context?.log?.info(
-                  `LLM-enhanced prompt for Veo: "${args.prompt}" → "${enhancedPrompt}"`
+                  `LLM-enhanced prompt for Veo: "${args.prompt}" → "${enhancedPrompt}"`,
                 );
 
                 if (context?.streamContent) {
@@ -383,12 +383,12 @@ export const imageToVideo = {
                 }
               } catch (err: any) {
                 context?.log?.info(
-                  `LLM enhancement failed, using original: ${err.message}`
+                  `LLM enhancement failed, using original: ${err.message}`,
                 );
               }
             } else {
               context?.log?.info(
-                "GEMINI_API_KEY not set, skipping Veo LLM enhancement"
+                "GEMINI_API_KEY not set, skipping Veo LLM enhancement",
               );
             }
           } else {
@@ -444,7 +444,7 @@ export const imageToVideo = {
 
       if (!operationName) {
         throw new Error(
-          "Vertex did not return an operation name for long-running request"
+          "Vertex did not return an operation name for long-running request",
         );
       }
 
@@ -481,7 +481,7 @@ export const imageToVideo = {
           const elapsed = Date.now() - startTime;
           const progressPercent = Math.min(
             Math.round((elapsed / MAX_POLL_TIME) * 100),
-            99
+            99,
           );
           await context.reportProgress({
             progress: progressPercent,
@@ -493,7 +493,7 @@ export const imageToVideo = {
           await context.streamContent({
             type: "text" as const,
             text: `[Vertex] Still processing... (${Math.round(
-              (Date.now() - startTime) / 1000
+              (Date.now() - startTime) / 1000,
             )}s elapsed)`,
           });
         }
@@ -510,61 +510,26 @@ export const imageToVideo = {
       }
 
       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;
-
-        // 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) {
+      
+      // checkVertexStatus already handles saving videos and sanitizing base64
+      if (Array.isArray(resp.saved_videos) && resp.saved_videos.length > 0) {
         return JSON.stringify({
-          videos,
+          videos: resp.saved_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=${operationName}. json_head150=${head150} json_tail50=${tail50}`;
+      // If nothing saved, return a clean error without any raw JSON that could contain base64
+      // CRITICAL: Never return raw response data to prevent context window poisoning
+      const respKeys = resp ? Object.keys(resp) : [];
+      return JSON.stringify({
+        status: "ERROR",
+        message:
+          "Vertex operation completed but no videos were found in the response.",
+        operationName,
+        responseKeys: respKeys,
+        hint: "The response structure may have changed. Check the Vertex AI documentation or search for the expected response format.",
+      });
     }, "imageToVideo");
   },
 };

package/src/utils/sanitize.ts

@@ -0,0 +1,35 @@
+/**
+ * Utility to sanitize API responses by removing or masking large data fields
+ * like base64-encoded bytes to prevent context window poisoning.
+ */
+
+/**
+ * Recursively sanitizes an object by replacing large data fields.
+ * @param obj The object or array to sanitize
+ * @returns A new object with sensitive/large fields masked
+ */
+export function sanitizeResponse(obj: any): any {
+  if (obj === null || obj === undefined) return obj;
+  if (typeof obj !== "object") return obj;
+
+  if (Array.isArray(obj)) {
+    return obj.map(sanitizeResponse);
+  }
+
+  const sanitized: any = {};
+  for (const key of Object.keys(obj)) {
+    // List of keys known to contain large binary data or base64
+    const isLargeDataKey =
+      key === "bytesBase64Encoded" ||
+      key === "base64" ||
+      key === "data" ||
+      key === "content" && typeof obj[key] === "string" && obj[key].length > 10000;
+
+    if (isLargeDataKey) {
+      sanitized[key] = "[LARGE_DATA_HIDDEN]";
+    } else {
+      sanitized[key] = sanitizeResponse(obj[key]);
+    }
+  }
+  return sanitized;
+}