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

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@mixio-pro/kalaasetu-mcp",
-  "version": "2.0.4-beta",
+  "version": "2.0.6-beta",
   "description": "A powerful Model Context Protocol server providing AI tools for content generation and analysis",
   "type": "module",
   "module": "src/index.ts",
   "main": "src/index.ts",
   "bin": {
-    "kalaasetu-mcp": "./bin/cli.js"
+    "kalaasetu-mcp": "bin/cli.js"
   },
   "files": [
     "src",
@@ -35,7 +35,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/mixiopro/kalaasetu-mcp.git"
+    "url": "git+https://github.com/mixiopro/kalaasetu-mcp.git"
   },
   "bugs": {
     "url": "https://github.com/mixiopro/kalaasetu-mcp/issues"
@@ -58,4 +58,4 @@
     "wav": "^1.0.2",
     "zod": "^4.1.12"
   }
-}
+}

package/src/tools/fal/generate.ts

@@ -12,6 +12,7 @@ import {
   getApiKey,
   loadFalConfig,
 } from "./config";
+import { checkFalStatus, fetchFalResult } from "../get-status";
 
 /**
  * Helper to wait for a specified duration.
@@ -92,7 +93,7 @@ export const falGenerate = {
   description:
     "The primary tool for generating AI content (images, videos, etc.) using fal.ai. " +
     "This tool handles polling internally and streams progress updates to the client. " +
-    "If the generation takes too long (timeout or error), it returns a 'resume_id' that you can use to resume polling. " +
+    "If the generation takes too long (timeout or error), it returns a 'resume_endpoint' that you can use to resume polling. " +
     "Use 'fal_list_presets' to discover available intents and names. " +
     "PREREQUISITE: If using local files as parameters, you MUST upload them first using 'fal_upload_file' and use the resulting CDN URL. " +
     "ONLY USE WHEN WORKING WITH FAL MODELS/PRESETS.",
@@ -111,12 +112,12 @@ export const falGenerate = {
           "These override the default values defined in the preset. " +
           "NOTE: For image-to-video or video-to-video tasks, use 'fal_upload_file' first and pass the resulting CDN URL here."
       ),
-    resume_id: z
+    resume_endpoint: z
       .string()
       .optional()
       .describe(
         "If provided, the tool will resume polling for an existing request instead of starting a new one. " +
-          "Use the 'request_id' returned in an 'IN_PROGRESS' response or after a timeout error."
+          "Use the 'resume_endpoint' returned in an 'IN_PROGRESS' response or after a timeout error."
       ),
   }),
   timeoutMs: 90000, // 90 seconds MCP timeout (internal timeout is 60s)
@@ -124,7 +125,7 @@ export const falGenerate = {
     args: {
       preset_name?: string;
       parameters?: Record<string, any>;
-      resume_id?: string;
+      resume_endpoint?: string;
       auto_enhance?: boolean;
     },
     context?: ProgressContext
@@ -135,21 +136,21 @@ export const falGenerate = {
       let requestId: string;
       const config = loadFalConfig();
 
-      if (args.resume_id) {
-        // Check if resume_id is a full URL (new format) or legacy ID
-        if (args.resume_id.startsWith("http")) {
-          // NEW: resume_id IS the status/response URL
-          statusUrl = args.resume_id;
+      if (args.resume_endpoint) {
+        // Check if resume_endpoint is a full URL (new format) or legacy ID
+        if (args.resume_endpoint.startsWith("http")) {
+          // NEW: resume_endpoint IS the status/response URL
+          statusUrl = args.resume_endpoint;
           // Derive responseUrl by removing /status suffix if present
-          responseUrl = args.resume_id.replace(/\/status$/, "");
+          responseUrl = args.resume_endpoint.replace(/\/status$/, "");
           // Extract requestId from URL for logging
-          const urlParts = args.resume_id.split("/");
+          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_id}`);
+          context?.log?.info(`Resuming with FAL URL: ${args.resume_endpoint}`);
         } else {
           // LEGACY: Try to resolve model from preset_name or parse modelId::requestId
           let modelIdFromPreset: string | undefined;
@@ -165,8 +166,8 @@ export const falGenerate = {
             }
           }
 
-          if (args.resume_id.includes("::")) {
-            const parts = args.resume_id.split("::");
+          if (args.resume_endpoint.includes("::")) {
+            const parts = args.resume_endpoint.split("::");
             const mId = parts[0];
             const rId = parts[1] || "";
 
@@ -181,7 +182,7 @@ export const falGenerate = {
             );
           } else {
             // Legacy/Fallback for raw UUIDs
-            requestId = args.resume_id;
+            requestId = args.resume_endpoint;
 
             if (modelIdFromPreset) {
               // Best case: User provided the preset name!
@@ -192,8 +193,8 @@ export const falGenerate = {
               );
             } else {
               // Worst case: No preset, no model in ID. Try legacy generic URL
-              statusUrl = `${FAL_QUEUE_URL}/requests/${args.resume_id}/status`;
-              responseUrl = `${FAL_QUEUE_URL}/requests/${args.resume_id}`;
+              statusUrl = `${FAL_QUEUE_URL}/requests/${args.resume_endpoint}/status`;
+              responseUrl = `${FAL_QUEUE_URL}/requests/${args.resume_endpoint}`;
 
               // Verify/Recovery: Check if generic URL works, if not try to guess model
               // ... (Smart recovery logic below)
@@ -230,7 +231,7 @@ export const falGenerate = {
               }
             }
             context?.log?.info(
-              `Resuming polling for request: ${args.resume_id}`
+              `Resuming polling for request: ${args.resume_endpoint}`
             );
           }
         } // Close the LEGACY else block (line 149)
@@ -348,13 +349,13 @@ export const falGenerate = {
         if (context?.streamContent) {
           await context.streamContent({
             type: "text" as const,
-            text: `[FAL] Generation started. resume_id: ${statusUrl} (use this URL to check status)`,
+            text: `[FAL] Generation started. resume_endpoint: ${statusUrl} (use this URL to check status)`,
           });
         }
       }
 
       // Stream message for resume calls
-      if (args.resume_id && context?.streamContent) {
+      if (args.resume_endpoint && context?.streamContent) {
         await context.streamContent({
           type: "text" as const,
           text: `[FAL] Resuming status check for job: ${requestId}`,
@@ -362,7 +363,7 @@ export const falGenerate = {
       }
 
       const startTime = Date.now();
-      const MAX_POLL_TIME = 60000; // 60 seconds internal timeout - then return resume_id
+      const MAX_POLL_TIME = 60000; // 60 seconds internal timeout - then return resume_endpoint
       let pollCount = 0;
       const POLL_INTERVAL = 3000;
 
@@ -370,14 +371,14 @@ export const falGenerate = {
         pollCount++;
         let res;
         try {
-          res = await authenticatedRequest(statusUrl, "GET");
+          res = await checkFalStatus(statusUrl);
         } 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 authenticatedRequest(responseUrl, "GET");
+            res = await fetchFalResult(responseUrl);
             // If successful, update statusUrl to match for future polls
             statusUrl = responseUrl;
           } else {
@@ -420,7 +421,7 @@ export const falGenerate = {
             await context.reportProgress({ progress: 100, total: 100 });
           }
           // responseUrl is now guaranteed to be correct/fresh from polling
-          const finalResult = await authenticatedRequest(responseUrl, "GET");
+          const finalResult = await fetchFalResult(responseUrl);
           return JSON.stringify(finalResult);
         }
 
@@ -433,12 +434,12 @@ export const falGenerate = {
         await wait(POLL_INTERVAL);
       }
 
-      // Timeout - return composite resume_id
+      // Timeout - return composite resume_endpoint
       // We need to know modelId here. If we started new, we have 'preset'
       // If we resumed, we parsed 'mId' or used raw.
       const currentModelId =
-        args.resume_id && args.resume_id.includes("::")
-          ? args.resume_id.split("::")[0]
+        args.resume_endpoint && args.resume_endpoint.includes("::")
+          ? args.resume_endpoint.split("::")[0]
           : args.preset_name
           ? config.presets.find((p) => p.presetName === args.preset_name)
               ?.modelId
@@ -447,11 +448,11 @@ export const falGenerate = {
       return JSON.stringify({
         status: "IN_PROGRESS",
         request_id: requestId,
-        resume_id: statusUrl, // Use the FULL URL for reliable resume
+        resume_endpoint: statusUrl, // Use the FULL URL for reliable resume
         status_url: statusUrl,
         response_url: responseUrl,
         message:
-          "The generation is still in progress. Call this tool again with resume_id (the URL) to continue polling.",
+          "The generation is still in progress. Call this tool again with resume_endpoint (the URL) to continue polling.",
       });
     }, "fal_generate");
   },

package/src/tools/get-status.ts

@@ -12,7 +12,20 @@ const FAL_KEY = process.env.FAL_KEY;
 /**
  * Check FAL generation status using the status URL
  */
-async function checkFalStatus(statusUrl: string): Promise<any> {
+interface VertexOperation {
+  done?: boolean;
+  response?: {
+    videos?: Array<{
+      bytesBase64Encoded?: string;
+    }>;
+    saved_videos?: any[];
+    [key: string]: any;
+  };
+  error?: any;
+  [key: string]: any;
+}
+
+export async function checkFalStatus(statusUrl: string): Promise<any> {
   if (!FAL_KEY) {
     throw new Error("FAL_KEY environment variable not set");
   }
@@ -30,45 +43,54 @@ async function checkFalStatus(statusUrl: string): Promise<any> {
     throw new Error(`FAL API error [${response.status}]: ${errorText}`);
   }
 
-  const statusResult = (await response.json()) as { status?: string };
-
-  if (statusResult.status === "COMPLETED") {
-    // Fetch the actual result
-    const responseUrl = statusUrl.replace(/\/status$/, "");
-    const resultResponse = await fetch(responseUrl, {
-      method: "GET",
-      headers: {
-        Authorization: `Key ${FAL_KEY}`,
-        "Content-Type": "application/json",
-      },
-    });
-
-    if (resultResponse.ok) {
-      return await resultResponse.json();
-    }
+  return await response.json();
+}
+
+export async function fetchFalResult(responseUrl: string): Promise<any> {
+  if (!FAL_KEY) {
+    throw new Error("FAL_KEY environment variable not set");
+  }
+
+  const response = await fetch(responseUrl, {
+    method: "GET",
+    headers: {
+      Authorization: `Key ${FAL_KEY}`,
+      "Content-Type": "application/json",
+    },
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`FAL API error [${response.status}]: ${errorText}`);
   }
 
-  return statusResult;
+  return await response.json();
 }
 
-/**
- * Check Vertex AI operation status
- */
-async function checkVertexStatus(
-  operationName: string,
-  projectId: string,
-  locationId: string
+export async function checkVertexStatus(
+  resumeEndpoint: string
 ): Promise<any> {
   const accessToken = await getGoogleAccessToken();
 
-  const operationsUrl = `https://${locationId}-aiplatform.googleapis.com/v1/projects/${projectId}/locations/${locationId}/publishers/google/models/veo-3.1-generate-preview/operations/${operationName}`;
+  // resumeEndpoint is composite format: fetchUrl||operationName||outputPath
+  const parts = resumeEndpoint.split("||");
+  const fetchUrl = parts[0] || "";
+  const operationName = parts[1] || "";
+  const outputPath = parts[2] || ""; // Optional custom output path
 
-  const response = await fetch(operationsUrl, {
-    method: "GET",
+  if (!fetchUrl || !operationName) {
+    throw new Error(
+      "Invalid Vertex resume_endpoint format. Expected 'fetchUrl||operationName[||outputPath]'."
+    );
+  }
+
+  const response = await fetch(fetchUrl, {
+    method: "POST",
     headers: {
       Authorization: `Bearer ${accessToken}`,
       "Content-Type": "application/json",
     },
+    body: JSON.stringify({ operationName }),
   });
 
   if (!response.ok) {
@@ -76,64 +98,94 @@ async function checkVertexStatus(
     throw new Error(`Vertex AI API error [${response.status}]: ${errorText}`);
   }
 
-  return await response.json();
+  const result = (await response.json()) as VertexOperation;
+
+  // If completed, save videos if present
+  const done = !!result.done || !!result.response;
+  if (done) {
+    const resp = result.response || result;
+    if (Array.isArray(resp?.videos) && resp.videos.length > 0) {
+      const { getStorage } = await import("../storage");
+      const { generateTimestampedFilename } = await import("../utils/filename");
+      const storage = getStorage();
+      const savedVideos: any[] = [];
+
+      for (let i = 0; i < resp.videos.length; i++) {
+        const v = resp.videos[i];
+        if (v?.bytesBase64Encoded) {
+          let filePath: string;
+          if (outputPath) {
+            // Use custom path, add index for subsequent videos
+            filePath =
+              i === 0
+                ? outputPath
+                : outputPath.replace(/\.mp4$/i, `_${i}.mp4`);
+          } else {
+            // Default timestamped filename
+            filePath = generateTimestampedFilename(`video_output_${i}.mp4`);
+          }
+          const buf = Buffer.from(v.bytesBase64Encoded, "base64");
+          const url = await storage.writeFile(filePath, buf);
+          savedVideos.push({
+            url,
+            filename: filePath,
+            mimeType: "video/mp4",
+          });
+        }
+      }
+
+      if (savedVideos.length > 0) {
+        resp.saved_videos = savedVideos;
+      }
+    }
+  }
+
+  return result;
 }
 
 export const getGenerationStatus = {
   name: "get_generation_status",
   description:
     "Check the status or retrieve the result of a generation operation that was started by 'fal_generate' or 'generateVideoi2v'. " +
-    "Use this when the original generation tool returned an 'IN_PROGRESS' status with a 'resume_id'. " +
-    "Pass the resume_id exactly as it was returned. " +
-    "For FAL operations, the resume_id is a full URL. " +
-    "For Vertex AI operations, the resume_id is an operation name.",
+    "Use this when the original generation tool returned an 'IN_PROGRESS' status with a 'resume_endpoint'. " +
+    "Pass the resume_endpoint exactly as it was returned. " +
+    "For FAL operations, the resume_endpoint is a full URL. " +
+    "For Vertex AI operations, the resume_endpoint is an operation name or full path.",
   parameters: z.object({
-    resume_id: z
+    resume_endpoint: z
       .string()
       .describe(
-        "The resume_id returned by the original generation tool. " +
+        "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."
+          "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_id format."
+        "Source of the operation: 'fal' for FAL AI, 'vertex' for Google Vertex AI, or 'auto' to auto-detect based on resume_endpoint format."
       ),
-    project_id: z
-      .string()
-      .optional()
-      .default("mixio-pro")
-      .describe("GCP Project ID (only needed for Vertex AI operations)."),
-    location_id: z
-      .string()
-      .optional()
-      .default("us-central1")
-      .describe("GCP region (only needed for Vertex AI operations)."),
   }),
   timeoutMs: 30000, // 30 seconds for status check
   execute: async (args: {
-    resume_id: string;
+    resume_endpoint: string;
     source?: "fal" | "vertex" | "auto";
-    project_id?: string;
-    location_id?: string;
   }) => {
     return safeToolExecute(async () => {
       const {
-        resume_id,
+        resume_endpoint,
         source = "auto",
-        project_id = "mixio-pro",
-        location_id = "us-central1",
       } = args;
+      const project_id = "mixio-pro";
+      const location_id = "us-central1";
 
-      // Auto-detect source based on resume_id format
+      // Auto-detect source based on resume_endpoint format
       let detectedSource = source;
       if (source === "auto") {
         if (
-          resume_id.startsWith("https://queue.fal.run") ||
-          resume_id.startsWith("https://fal.run")
+          resume_endpoint.startsWith("https://queue.fal.run") ||
+          resume_endpoint.startsWith("https://fal.run")
         ) {
           detectedSource = "fal";
         } else {
@@ -144,27 +196,27 @@ export const getGenerationStatus = {
       let result: any;
 
       if (detectedSource === "fal") {
-        result = await checkFalStatus(resume_id);
+        result = await checkFalStatus(resume_endpoint);
       } else {
-        result = await checkVertexStatus(resume_id, project_id, location_id);
+        result = await checkVertexStatus(resume_endpoint);
       }
 
       // Normalize the response
       const status =
-        result.status || (result.done ? "COMPLETED" : "IN_PROGRESS");
+        (result as any).status || ((result as any).done ? "COMPLETED" : "IN_PROGRESS");
 
       return JSON.stringify(
         {
           source: detectedSource,
           status,
-          resume_id,
+          resume_endpoint,
           result,
           message:
             status === "COMPLETED"
               ? "Generation completed! The result is included in the 'result' field."
               : status === "FAILED"
               ? "Generation failed. Check the 'result' field for error details."
-              : "Generation is still in progress. Call this tool again with the same resume_id to check later.",
+              : "Generation is still in progress. Call this tool again with the same resume_endpoint to check later.",
         },
         null,
         2
@@ -172,3 +224,4 @@ export const getGenerationStatus = {
     }, "get_generation_status");
   },
 };
+

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

@@ -8,6 +8,7 @@ import {
 } from "../utils/prompt-enhancer-presets";
 
 import { getGoogleAccessToken } from "../utils/google-auth";
+import { checkVertexStatus } from "./get-status";
 
 async function wait(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -47,7 +48,7 @@ export const imageToVideo = {
   description:
     "Generate professional-quality cinematic videos from a starting image and text prompt using Google's Vertex AI Veo models. " +
     "This tool follows a 'Synchronous Facade' pattern: it handles polling internally but can be paused/resumed. " +
-    "If the generation takes too long, it returns a 'resume_id' that you MUST use to call this tool again to pick up progress. " +
+    "If the generation takes too long, it returns a 'resume_endpoint' that you MUST use to call this tool again to pick up progress. " +
     "It produces state-of-the-art cinematic results. " +
     "ONLY USE WHEN WORKING WITH GOOGLE VERTEX AI MODELS.",
   parameters: z.object({
@@ -109,18 +110,6 @@ export const imageToVideo = {
       .describe(
         "Optional: Local path to save the resulting .mp4 file. Defaults to timestamped filename."
       ),
-    project_id: z
-      .string()
-      .optional()
-      .default("mixio-pro")
-      .describe("GCP Project ID for Vertex billing. Default is mixio-pro."),
-    location_id: z
-      .string()
-      .optional()
-      .default("us-central1")
-      .describe(
-        "GCP region for Vertex AI processing (Default is 'us-central1')."
-      ),
     model_id: z
       .string()
       .optional()
@@ -135,12 +124,12 @@ export const imageToVideo = {
         "If true, Vertex will attempt to synthesize synchronized audio for the video."
       )
       .default(false),
-    resume_id: z
+    resume_endpoint: z
       .string()
       .optional()
       .describe(
         "If provided, the tool will check the status of an existing Vertex operation instead of starting a new one. " +
-          "Use the 'request_id' returned in an 'IN_PROGRESS' response."
+          "Use the 'resume_endpoint' returned in an 'IN_PROGRESS' response."
       ),
     auto_enhance: z
       .boolean()
@@ -169,11 +158,9 @@ export const imageToVideo = {
       person_generation?: string;
       reference_images?: string[] | string;
       output_path?: string;
-      project_id?: string;
-      location_id?: string;
       model_id?: string;
       generate_audio?: boolean;
-      resume_id?: string;
+      resume_endpoint?: string;
       enhancer_preset?: string;
       auto_enhance?: boolean;
     },
@@ -193,8 +180,8 @@ export const imageToVideo = {
     }
   ) {
     return safeToolExecute(async () => {
-      const projectId = args.project_id || "mixio-pro";
-      const location = args.location_id || "us-central1";
+      const projectId = "mixio-pro";
+      const location = "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
@@ -260,13 +247,13 @@ export const imageToVideo = {
 
       // If resuming, reconstruct the full operation path from the UUID
       let operationName: string | undefined;
-      if (args.resume_id) {
+      if (args.resume_endpoint) {
         // Support both UUID-only and full path formats
-        if (args.resume_id.includes("/")) {
-          operationName = args.resume_id; // Already a full path
+        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_id}`;
+          operationName = `projects/${projectId}/locations/${location}/publishers/google/models/${modelId}/operations/${args.resume_endpoint}`;
         }
       }
       let current: any;
@@ -461,46 +448,33 @@ export const imageToVideo = {
         );
       }
 
-      // Extract just the operation UUID from the full path for a cleaner resume_id
-      // Full path: projects/.../operations/<uuid>
-      const operationUuid = operationName.split("/").pop() || operationName;
+      // 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}`;
 
-      // Stream the resume_id to the LLM immediately (before polling starts)
+      // 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
       if (context?.streamContent) {
-        const isResume = !!args.resume_id;
+        const isResume = !!args.resume_endpoint;
         await context.streamContent({
           type: "text" as const,
           text: isResume
-            ? `[Vertex] Resuming status check for job: ${operationUuid}`
-            : `[Vertex] Video generation started. resume_id: ${operationUuid} (use this to check status if needed)`,
+            ? `[Vertex] Resuming status check for job`
+            : `[Vertex] Video generation started. resume_endpoint: ${compositeResumeEndpoint} (use this to check status if needed)`,
         });
       }
 
       // Poll for status - keep polling until done
-      // Resume_id was already streamed, so if MCP client times out the LLM still has it
+      // Resume_endpoint was already streamed, so if MCP client times out the LLM still has it
       let done = current ? !!current.done || !!current.response : false;
       const startTime = Date.now();
-      const MAX_POLL_TIME = 60000; // 60 seconds internal timeout - then return resume_id
+      const MAX_POLL_TIME = 60000; // 60 seconds internal timeout - then return resume_endpoint
 
       while (!done && Date.now() - startTime < MAX_POLL_TIME) {
         await wait(10000); // 10 second intervals
 
-        const poll = await fetch(fetchUrl, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${token}`,
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({ operationName }),
-        });
-        if (!poll.ok) {
-          const text = await poll.text();
-          throw new Error(
-            `Vertex operation poll failed: ${poll.status} ${text}`
-          );
-        }
-        current = (await poll.json()) as any;
+        current = await checkVertexStatus(compositeResumeEndpoint);
         done = !!current.done || !!current.response;
 
         if (context?.reportProgress) {
@@ -529,9 +503,9 @@ export const imageToVideo = {
         return JSON.stringify({
           status: "IN_PROGRESS",
           request_id: operationName,
-          resume_id: operationName,
+          resume_endpoint: compositeResumeEndpoint,
           message:
-            "Still in progress. Call this tool again with resume_id to continue checking.",
+            "Still in progress. Call this tool again with resume_endpoint to continue checking.",
         });
       }