@mixio-pro/kalaasetu-mcp 2.1.0 → 2.1.2-beta

package/src/tools/fal/models.ts

@@ -6,6 +6,7 @@ import {
   DEFAULT_TIMEOUT,
 } from "./config";
 import { safeToolExecute } from "../../utils/tool-wrapper";
+import { logger } from "../../utils/logger";
 
 /**
  * Extract simplified input schema from FAL OpenAPI response.
@@ -20,7 +21,7 @@ function extractInputSchema(openApiSchema: any): Record<string, any> | null {
     const inputSchemaKey = Object.keys(schemas).find(
       (key) =>
         key.toLowerCase().includes("input") &&
-        !key.toLowerCase().includes("output")
+        !key.toLowerCase().includes("output"),
     );
 
     if (!inputSchemaKey) return null;
@@ -31,7 +32,7 @@ function extractInputSchema(openApiSchema: any): Record<string, any> | null {
     // Extract simplified properties
     const simplified: Record<string, any> = {};
     for (const [propName, propDef] of Object.entries(
-      inputSchema.properties as Record<string, any>
+      inputSchema.properties as Record<string, any>,
     )) {
       simplified[propName] = {
         type: propDef.type,
@@ -66,64 +67,81 @@ export const falListPresets = {
   }),
   timeoutMs: 60000, // Allow more time for schema fetching
   execute: async (args: { refresh_schemas?: boolean }) => {
-    return safeToolExecute(async () => {
-      const config = loadFalConfig();
-      let updated = false;
-
-      // Fetch schemas for presets that don't have them (or if refresh requested)
-      for (const preset of config.presets) {
-        const hasSchema =
-          preset.input_schema && Object.keys(preset.input_schema).length > 0;
-        const shouldFetch = !hasSchema || args.refresh_schemas;
-
-
-        if (shouldFetch) {
-          try {
-            const url = `https://fal.ai/api/openapi/queue/openapi.json?endpoint_id=${preset.modelId}`;
-
-            const response = await fetch(url, {
-              method: "GET",
-              signal: AbortSignal.timeout(10000),
-            });
-
-            if (response.ok) {
-              const openApiSchema = await response.json();
-              const simplified = extractInputSchema(openApiSchema);
-
-
-              if (simplified) {
-                preset.input_schema = simplified;
-                updated = true;
+    return safeToolExecute(
+      async () => {
+        const config = loadFalConfig();
+        let updated = false;
+
+        // Fetch schemas for presets that don't have them (or if refresh requested)
+        for (const preset of config.presets) {
+          const hasSchema =
+            preset.input_schema && Object.keys(preset.input_schema).length > 0;
+          const shouldFetch = !hasSchema || args.refresh_schemas;
+          logger.debug(
+            `[fal_list_presets] ${
+              preset.presetName
+            }: shouldFetch=${shouldFetch}, hasSchema=${!!preset.input_schema}, refresh=${
+              args.refresh_schemas
+            }`,
+          );
+
+          if (shouldFetch) {
+            try {
+              const url = `https://fal.ai/api/openapi/queue/openapi.json?endpoint_id=${preset.modelId}`;
+              logger.debug(`[fal_list_presets] Fetching schema from: ${url}`);
+              const response = await fetch(url, {
+                method: "GET",
+                signal: AbortSignal.timeout(10000),
+              });
+
+              if (response.ok) {
+                const openApiSchema = await response.json();
+                const simplified = extractInputSchema(openApiSchema);
+                logger.debug(
+                  `[fal_list_presets] Extracted schema for ${preset.presetName}:`,
+                  simplified ? Object.keys(simplified) : null,
+                );
+
+                if (simplified) {
+                  preset.input_schema = simplified;
+                  updated = true;
+                }
+              } else {
+                logger.warn(
+                  `[fal_list_presets] Fetch failed: ${response.status}`,
+                );
               }
-            } else {
-
+            } catch (e: any) {
+              logger.warn(
+                `[fal_list_presets] Error fetching schema for ${preset.presetName}:`,
+                e.message,
+              );
             }
-          } catch (e: any) {
-            console.error(
-              `[fal_list_presets] Error fetching schema for ${preset.presetName}:`,
-              e.message
-            );
           }
         }
-      }
 
-      // Save updated config if schemas were fetched
-      if (updated) {
-        saveFalConfig(config);
-      }
-
-      // Return enriched preset list
-      const summary = config.presets.map((p) => ({
-        presetName: p.presetName,
-        intent: p.intent,
-        inputType: p.inputType,
-        outputType: p.outputType,
-        description: p.description,
-        inputSchema: p.input_schema,
-      }));
+        // Save updated config if schemas were fetched
+        if (updated) {
+          logger.info(`[fal_list_presets] Saving updated config...`);
+          const saved = saveFalConfig(config);
+          logger.info(`[fal_list_presets] Config saved: ${saved}`);
+        }
 
-      return JSON.stringify(summary, null, 2);
-    }, "fal_list_presets");
+        // Return enriched preset list
+        const summary = config.presets.map((p) => ({
+          presetName: p.presetName,
+          intent: p.intent,
+          inputType: p.inputType,
+          outputType: p.outputType,
+          description: p.description,
+          inputSchema: p.input_schema,
+        }));
+
+        return JSON.stringify(summary, null, 2);
+      },
+      "fal_list_presets",
+      { toolName: "fal_list_presets" },
+    );
   },
 };
 
@@ -146,52 +164,56 @@ export const falGetPresetDetails = {
   }),
   timeoutMs: 30000,
   execute: async (args: { preset_name: string }) => {
-    return safeToolExecute(async () => {
-      const config = loadFalConfig();
-      const preset = config.presets.find(
-        (p) => p.presetName === args.preset_name
-      );
-      if (!preset) {
-        throw new Error(`Preset '${args.preset_name}' not found.`);
-      }
+    return safeToolExecute(
+      async () => {
+        const config = loadFalConfig();
+        const preset = config.presets.find(
+          (p) => p.presetName === args.preset_name,
+        );
+        if (!preset) {
+          throw new Error(`Preset '${args.preset_name}' not found.`);
+        }
 
-      // Fetch live model metadata/schema from fal.ai API
-      // Based on: https://fal.ai/api/openapi/queue/openapi.json?endpoint_id={model_id}
-      let modelMetadata: any = null;
-      let schemaSource = "none";
+        // Fetch live model metadata/schema from fal.ai API
+        // Based on: https://fal.ai/api/openapi/queue/openapi.json?endpoint_id={model_id}
+        let modelMetadata: any = null;
+        let schemaSource = "none";
 
-      try {
-        const url = `https://fal.ai/api/openapi/queue/openapi.json?endpoint_id=${preset.modelId}`;
-        const schema = await publicRequest(url);
+        try {
+          const url = `https://fal.ai/api/openapi/queue/openapi.json?endpoint_id=${preset.modelId}`;
+          const schema = await publicRequest(url);
 
-        // Extract relevant schema parts if possible, or return full schema
-        if (schema) {
-          modelMetadata = schema;
-          schemaSource = "api";
+          // Extract relevant schema parts if possible, or return full schema
+          if (schema) {
+            modelMetadata = schema;
+            schemaSource = "api";
+          }
+        } catch (e) {
+          // console.error(`Failed to fetch schema for ${preset.modelId}:`, e);
+          // Fallback to locally defined schema if available
         }
-      } catch (e) {
-        // console.error(`Failed to fetch schema for ${preset.modelId}:`, e);
-        // Fallback to locally defined schema if available
-      }
 
-      // Fallback: If API failed or returned nothing, use manual schema from config
-      if (!modelMetadata && preset.input_schema) {
-        modelMetadata = preset.input_schema;
-        schemaSource = "local_config";
-      }
+        // Fallback: If API failed or returned nothing, use manual schema from config
+        if (!modelMetadata && preset.input_schema) {
+          modelMetadata = preset.input_schema;
+          schemaSource = "local_config";
+        }
 
-      return JSON.stringify(
-        {
-          preset,
-          modelMetadata,
-          _meta: {
-            schemaSource,
+        return JSON.stringify(
+          {
+            preset,
+            modelMetadata,
+            _meta: {
+              schemaSource,
+            },
           },
-        },
-        null,
-        2
-      );
-    }, "fal_get_preset_details");
+          null,
+          2,
+        );
+      },
+      "fal_get_preset_details",
+      { toolName: "fal_get_preset_details" },
+    );
   },
 };
 

package/src/tools/fal/storage.ts

@@ -8,6 +8,7 @@ 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";
+import { logger } from "../../utils/logger";
 
 /**
  * Get MIME type from file extension.
@@ -46,82 +47,86 @@ export const falUploadFile = {
     path: z
       .string()
       .describe(
-        "The absolute local path to the file to upload (e.g., '/Users/name/images/input.jpg')."
+        "The absolute local path to the file to upload (e.g., '/Users/name/images/input.jpg').",
       ),
   }),
   timeoutMs: 300000,
   execute: async (args: { path: string }) => {
-    return safeToolExecute(async () => {
-      // 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}...`);
+        logger.debug(`[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
+        logger.debug(`[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`);
+        logger.info(`[fal_upload] Upload completed successfully`);
 
-      return JSON.stringify({
-        file_url,
-        file_name: filename,
-        file_size: fileSize,
-        content_type: contentType,
-      });
-    }, "fal_upload_file");
+        return JSON.stringify({
+          file_url,
+          file_name: filename,
+          file_size: fileSize,
+          content_type: contentType,
+        });
+      },
+      "fal_upload_file",
+      { toolName: "fal_upload_file" },
+    );
   },
 };