@mixio-pro/kalaasetu-mcp 1.1.3 → 1.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mixio-pro/kalaasetu-mcp",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "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,5 +1,6 @@
 #!/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 {
@@ -15,7 +16,7 @@ import {
 
 const server = new FastMCP({
   name: "Kalaasetu MCP Server",
-  version: "1.1.0",
+  version: pkg.version as any,
 });
 
 // Gemini Image Tools
@@ -40,14 +41,14 @@ server.addTool(imageToVideo);
 // server.addTool(perplexityVideos);
 
 // Fal AI Tools
-server.addTool(falListModels);
-server.addTool(falSearchModels);
-server.addTool(falGetSchema);
-server.addTool(falGenerateContent);
-server.addTool(falGetResult);
-server.addTool(falGetStatus);
-server.addTool(falCancelRequest);
-server.addTool(falUploadFile);
+// server.addTool(falListModels);
+// server.addTool(falSearchModels);
+// server.addTool(falGetSchema);
+// server.addTool(falGenerateContent);
+// server.addTool(falGetResult);
+// server.addTool(falGetStatus);
+// server.addTool(falCancelRequest);
+// server.addTool(falUploadFile);
 
 server.start({
   transportType: "stdio",

package/src/test-context.ts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { safeToolExecute } from "./utils/tool-wrapper";
+
+async function runTest() {
+  console.log("Running Error Context Verification Test...");
+
+  // 1. Mock Schema Validation Error
+  const schema = z.object({
+    prompt: z.string(),
+    count: z.number().min(1).max(5),
+  });
+
+  const mockToolWithValidation = async (args: any) => {
+    // Simulate what happens in a real tool when Zod parsing fails inside the execute block
+    // OR if we manually parse and it fails
+    // Most tools currently don't re-parse inside execute because MCP handles it?
+    // Wait, the tools define `parameters` schema, but the `execute` function receives `args`.
+    // The MCP server framework usually does the validation BEFORE calling execute.
+    // BUT if we look at the code, some tools do manual checks or parsing.
+
+    // Let's simulate a manual validation failure inside execute, or a deep validation failure
+    try {
+      schema.parse(args);
+    } catch (error) {
+      throw error;
+    }
+    return "success";
+  };
+
+  const zodResult = await safeToolExecute(
+    async () => mockToolWithValidation({ prompt: 123, count: 10 }),
+    "ZodTool"
+  );
+  console.log("\n--- Zod Error Result ---");
+  console.log(JSON.stringify(zodResult, null, 2));
+
+  // 2. Mock API Error with Status
+  const mockToolWithApiError = async () => {
+    // Simulate a fetch error structure
+    const err: any = new Error("API request failed");
+    err.status = 429;
+    err.statusText = "Too Many Requests";
+    err.responseBody = "Rate limit exceeded. Retry in 60s.";
+    throw err;
+  };
+
+  const apiResult = await safeToolExecute(mockToolWithApiError, "ApiTool");
+  console.log("\n--- API Error Result ---");
+  console.log(JSON.stringify(apiResult, null, 2));
+}
+
+runTest();

package/src/test-error-handling.ts

@@ -0,0 +1,31 @@
+import { safeToolExecute } from "./utils/tool-wrapper";
+
+async function runTest() {
+  console.log("Running Error Handling Verification Test...");
+
+  // Mock tool that throws an error
+  const mockTool = async () => {
+    throw new Error("Simulated tool failure");
+  };
+
+  const result = await safeToolExecute(mockTool, "MockTool");
+
+  console.log("Result:", JSON.stringify(result, null, 2));
+
+  if (
+    result.isError === true &&
+    result.content &&
+    result.content[0]?.text.includes(
+      "Tool execution failed in MockTool: Simulated tool failure"
+    )
+  ) {
+    console.log(
+      "✅ Verification PASSED: Error was correctly caught and formatted."
+    );
+  } else {
+    console.error("❌ Verification FAILED: Unexpected result format.");
+    process.exit(1);
+  }
+}
+
+runTest();

package/src/tools/fal/generate.ts

@@ -4,6 +4,7 @@
  */
 
 import { z } from "zod";
+import { safeToolExecute } from "../../utils/tool-wrapper";
 import {
   FAL_QUEUE_URL,
   FAL_DIRECT_URL,
@@ -80,18 +81,20 @@ export const falGenerateContent = {
     parameters: Record<string, any>;
     queue?: boolean;
   }) => {
-    const sanitizedParams = sanitizeParameters(args.parameters);
+    return safeToolExecute(async () => {
+      const sanitizedParams = sanitizeParameters(args.parameters);
 
-    const baseUrl = args.queue ? FAL_QUEUE_URL : FAL_DIRECT_URL;
-    const url = `${baseUrl}/${args.model}`;
+      const baseUrl = args.queue ? FAL_QUEUE_URL : FAL_DIRECT_URL;
+      const url = `${baseUrl}/${args.model}`;
 
-    console.error(`[fal_generate] Submitting request to ${url}...`);
+      console.error(`[fal_generate] Submitting request to ${url}...`);
 
-    const result = await authenticatedRequest(url, "POST", sanitizedParams);
+      const result = await authenticatedRequest(url, "POST", sanitizedParams);
 
-    console.error(`[fal_generate] Request completed successfully`);
+      console.error(`[fal_generate] Request completed successfully`);
 
-    return JSON.stringify(result);
+      return JSON.stringify(result);
+    }, "fal_generate_content");
   },
 };
 
@@ -135,7 +138,9 @@ export const falCancelRequest = {
     url: z.string().describe("The cancel_url from a queued request"),
   }),
   execute: async (args: { url: string }) => {
-    const result = await authenticatedRequest(args.url, "PUT");
-    return JSON.stringify(result);
+    return safeToolExecute(async () => {
+      const result = await authenticatedRequest(args.url, "PUT");
+      return JSON.stringify(result);
+    }, "fal_cancel_request");
   },
 };

package/src/tools/fal/storage.ts

@@ -5,6 +5,7 @@
 
 import { z } from "zod";
 import * as fs from "fs";
+import { safeToolExecute } from "../../utils/tool-wrapper";
 import * as path from "path";
 import { FAL_REST_URL, AUTHENTICATED_TIMEOUT, getApiKey } from "./config";
 
@@ -42,75 +43,77 @@ export const falUploadFile = {
     path: z.string().describe("The absolute path to the file to upload"),
   }),
   execute: async (args: { path: string }) => {
-    // Validate file exists
-    if (!fs.existsSync(args.path)) {
-      throw new Error(`File not found: ${args.path}`);
-    }
+    return safeToolExecute(async () => {
+      // Validate file exists
+      if (!fs.existsSync(args.path)) {
+        throw new Error(`File not found: ${args.path}`);
+      }
 
-    const filename = path.basename(args.path);
-    const fileSize = fs.statSync(args.path).size;
-    const contentType = getMimeType(args.path);
+      const filename = path.basename(args.path);
+      const fileSize = fs.statSync(args.path).size;
+      const contentType = getMimeType(args.path);
 
-    // Step 1: Initiate upload
-    const initiateUrl = `${FAL_REST_URL}/storage/upload/initiate?storage_type=fal-cdn-v3`;
-    const initiatePayload = {
-      content_type: contentType,
-      file_name: filename,
-    };
+      // Step 1: Initiate upload
+      const initiateUrl = `${FAL_REST_URL}/storage/upload/initiate?storage_type=fal-cdn-v3`;
+      const initiatePayload = {
+        content_type: contentType,
+        file_name: filename,
+      };
 
-    console.error(`[fal_upload] Initiating upload for ${filename}...`);
+      console.error(`[fal_upload] Initiating upload for ${filename}...`);
 
-    const initiateResponse = await fetch(initiateUrl, {
-      method: "POST",
-      headers: {
-        Authorization: `Key ${getApiKey()}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(initiatePayload),
-      signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
-    });
+      const initiateResponse = await fetch(initiateUrl, {
+        method: "POST",
+        headers: {
+          Authorization: `Key ${getApiKey()}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(initiatePayload),
+        signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+      });
 
-    if (!initiateResponse.ok) {
-      const errorText = await initiateResponse.text();
-      throw new Error(
-        `[${initiateResponse.status}] Failed to initiate upload: ${errorText}`
-      );
-    }
+      if (!initiateResponse.ok) {
+        const errorText = await initiateResponse.text();
+        throw new Error(
+          `[${initiateResponse.status}] Failed to initiate upload: ${errorText}`
+        );
+      }
 
-    const initiateData = (await initiateResponse.json()) as {
-      file_url: string;
-      upload_url: string;
-    };
-    const { file_url, upload_url } = initiateData;
+      const initiateData = (await initiateResponse.json()) as {
+        file_url: string;
+        upload_url: string;
+      };
+      const { file_url, upload_url } = initiateData;
 
-    // Step 2: Upload file content
-    console.error(`[fal_upload] Uploading file content...`);
+      // Step 2: Upload file content
+      console.error(`[fal_upload] Uploading file content...`);
 
-    const fileContent = fs.readFileSync(args.path);
+      const fileContent = fs.readFileSync(args.path);
 
-    const uploadResponse = await fetch(upload_url, {
-      method: "PUT",
-      headers: {
-        "Content-Type": contentType,
-      },
-      body: fileContent,
-      signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
-    });
+      const uploadResponse = await fetch(upload_url, {
+        method: "PUT",
+        headers: {
+          "Content-Type": contentType,
+        },
+        body: fileContent,
+        signal: AbortSignal.timeout(AUTHENTICATED_TIMEOUT),
+      });
 
-    if (!uploadResponse.ok) {
-      const errorText = await uploadResponse.text();
-      throw new Error(
-        `[${uploadResponse.status}] Failed to upload file: ${errorText}`
-      );
-    }
+      if (!uploadResponse.ok) {
+        const errorText = await uploadResponse.text();
+        throw new Error(
+          `[${uploadResponse.status}] Failed to upload file: ${errorText}`
+        );
+      }
 
-    console.error(`[fal_upload] Upload completed successfully`);
+      console.error(`[fal_upload] Upload completed successfully`);
 
-    return JSON.stringify({
-      file_url,
-      file_name: filename,
-      file_size: fileSize,
-      content_type: contentType,
-    });
+      return JSON.stringify({
+        file_url,
+        file_name: filename,
+        file_size: fileSize,
+        content_type: contentType,
+      });
+    }, "fal_upload_file");
   },
 };