@mixio-pro/kalaasetu-mcp 1.2.2 → 2.0.1-beta

package/src/tools/fal/models.ts

@@ -1,54 +1,159 @@
+import { z } from "zod";
+import {
+  loadFalConfig,
+  saveFalConfig,
+  FAL_BASE_URL,
+  DEFAULT_TIMEOUT,
+} from "./config";
+import { safeToolExecute } from "../../utils/tool-wrapper";
+
 /**
- * Models module for fal.ai MCP server.
- * Provides tools for retrieving information about configured fal.ai models.
+ * Extract simplified input schema from FAL OpenAPI response.
+ * Returns only the properties object from the input schema.
  */
+function extractInputSchema(openApiSchema: any): Record<string, any> | null {
+  try {
+    const schemas = openApiSchema?.components?.schemas;
+    if (!schemas) return null;
 
-import { z } from "zod";
-import { loadFalConfig, FAL_BASE_URL, DEFAULT_TIMEOUT } from "./config";
-import { safeToolExecute } from "../../utils/tool-wrapper";
+    // Find the input schema - usually named like "Ltx2ImageToVideoInput" or similar
+    const inputSchemaKey = Object.keys(schemas).find(
+      (key) =>
+        key.toLowerCase().includes("input") &&
+        !key.toLowerCase().includes("output")
+    );
+
+    if (!inputSchemaKey) return null;
+
+    const inputSchema = schemas[inputSchemaKey];
+    if (!inputSchema?.properties) return null;
+
+    // Extract simplified properties
+    const simplified: Record<string, any> = {};
+    for (const [propName, propDef] of Object.entries(
+      inputSchema.properties as Record<string, any>
+    )) {
+      simplified[propName] = {
+        type: propDef.type,
+        description: propDef.description,
+        ...(propDef.enum && { enum: propDef.enum }),
+        ...(propDef.default !== undefined && { default: propDef.default }),
+        ...(propDef.examples && { example: propDef.examples[0] }),
+      };
+    }
+
+    return simplified;
+  } catch (e) {
+    return null;
+  }
+}
 
 /**
  * Tool to list available generation presets and their intents.
+ * Dynamically fetches and caches input schemas from FAL API.
  */
 export const falListPresets = {
   name: "fal_list_presets",
   description:
     "The entry point for discovering fal.ai capabilities on this server. " +
     "Lists all available generation presets, including their high-level 'intent' (e.g., 'Generate cinematic video'), " +
-    "and the types of input/output they support. Call this first when you need to perform an AI generation task.",
-  parameters: z.object({}),
-  timeoutMs: 30000,
-  execute: async () => {
+    "input/output types, and INPUT SCHEMA with parameter details. Call this first when you need to perform an AI generation task.",
+  parameters: z.object({
+    refresh_schemas: z
+      .boolean()
+      .optional()
+      .describe("If true, re-fetch schemas from FAL API even if cached."),
+  }),
+  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 shouldFetch = !preset.input_schema || args.refresh_schemas;
+        console.log(
+          `[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}`;
+            console.log(`[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);
+              console.log(
+                `[fal_list_presets] Extracted schema for ${preset.presetName}:`,
+                simplified ? Object.keys(simplified) : null
+              );
+
+              if (simplified) {
+                preset.input_schema = simplified;
+                updated = true;
+              }
+            } else {
+              console.log(
+                `[fal_list_presets] Fetch failed: ${response.status}`
+              );
+            }
+          } catch (e: any) {
+            console.log(
+              `[fal_list_presets] Error fetching schema for ${preset.presetName}:`,
+              e.message
+            );
+          }
+        }
+      }
+
+      // Save updated config if schemas were fetched
+      if (updated) {
+        console.log(`[fal_list_presets] Saving updated config...`);
+        const saved = saveFalConfig(config);
+        console.log(`[fal_list_presets] Config saved: ${saved}`);
+      }
+
+      // 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");
   },
 };
 
 /**
- * Tool to get full details for a specific preset, including default parameters.
+ * Tool to get full details for a specific preset, including default parameters
+ * and real-time model metadata from fal.ai.
  */
 export const falGetPresetDetails = {
   name: "fal_get_preset_details",
   description:
     "Retrieve full details for a specific generation preset. " +
-    "Use this to see the 'modelId' being used and, most importantly, the 'defaultParams'. " +
-    "The default parameters shown here can be overridden in the 'parameters' argument of 'fal_generate'. " +
+    "This tool fetches both the local preset configuration (like 'defaultParams') " +
+    "and the live model metadata (schema, benchmarks, etc.) from fal.ai. " +
+    "Use this to understand the full capabilities and constraints of a model. " +
     "ONLY USE WHEN WORKING WITH FAL MODELS/PRESETS.",
   parameters: z.object({
     preset_name: z
       .string()
-      .describe(
-        "The name of the preset to inspect (e.g., 'ltx_image_to_video')."
-      ),
+      .describe("The name of the preset to inspect (e.g., 'cinematic_image')."),
   }),
   timeoutMs: 30000,
   execute: async (args: { preset_name: string }) => {
@@ -60,7 +165,43 @@ export const falGetPresetDetails = {
       if (!preset) {
         throw new Error(`Preset '${args.preset_name}' not found.`);
       }
-      return JSON.stringify(preset, null, 2);
+
+      // 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);
+
+        // 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
+      }
+
+      // 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,
+          },
+        },
+        null,
+        2
+      );
     }, "fal_get_preset_details");
   },
 };
@@ -82,22 +223,6 @@ async function publicRequest(url: string): Promise<any> {
   return response.json();
 }
 
-/**
- * Tool to retrieve the current full FAL configuration.
- */
-export const falGetConfig = {
-  name: "fal_get_config",
-  description: "Retrieve the full FAL configuration JSON file content.",
-  parameters: z.object({}),
-  timeoutMs: 30000,
-  execute: async () => {
-    return safeToolExecute(async () => {
-      const config = loadFalConfig();
-      return JSON.stringify(config, null, 2);
-    }, "fal_get_config");
-  },
-};
-
 /* 
 // ORIGINAL UNRESTRICTED TOOLS - Commented out for reference
 

package/src/tools/gemini.ts

@@ -12,6 +12,10 @@ import { PassThrough } from "stream";
 import { getStorage } from "../storage";
 import { generateTimestampedFilename } from "../utils/filename";
 import { safeToolExecute } from "../utils/tool-wrapper";
+import {
+  resolveEnhancer,
+  listImageEnhancerPresets,
+} from "../utils/prompt-enhancer-presets";
 
 const ai = new GoogleGenAI({
   apiKey: process.env.GEMINI_API_KEY || "",
@@ -232,6 +236,13 @@ export const geminiTextToImage = {
       .describe(
         "Optional: local paths or URLs of images to use as visual references for style or composition."
       ),
+    enhancer_preset: z
+      .string()
+      .optional()
+      .describe(
+        "Optional: Name of a prompt enhancer preset to apply (e.g., 'cinematic', 'photorealistic', 'anime'). " +
+          "Automatically enhances the prompt with professional style modifiers."
+      ),
   }),
   timeoutMs: 300000,
   execute: async (args: {
@@ -239,10 +250,20 @@ export const geminiTextToImage = {
     aspect_ratio?: string;
     output_path?: string;
     reference_images?: string[];
+    enhancer_preset?: string;
   }) => {
     return safeToolExecute(async () => {
       try {
-        const contents: any[] = [args.prompt];
+        // Apply prompt enhancement if preset specified
+        let enhancedPrompt = args.prompt;
+        if (args.enhancer_preset) {
+          const enhancer = resolveEnhancer(args.enhancer_preset);
+          if (enhancer.hasTransformations()) {
+            enhancedPrompt = enhancer.enhance(args.prompt);
+          }
+        }
+
+        const contents: any[] = [enhancedPrompt];
 
         if (args.reference_images && Array.isArray(args.reference_images)) {
           for (const refPath of args.reference_images) {
@@ -337,6 +358,13 @@ export const geminiEditImage = {
       .describe(
         "Optional: additional images to guide the edit (e.g., to reference a specific character or object style)."
       ),
+    enhancer_preset: z
+      .string()
+      .optional()
+      .describe(
+        "Optional: Name of a prompt enhancer preset to apply (e.g., 'cinematic', 'photorealistic'). " +
+          "Enhances the edit instructions with professional style modifiers."
+      ),
   }),
   timeoutMs: 300000,
   execute: async (args: {
@@ -344,11 +372,21 @@ export const geminiEditImage = {
     prompt: string;
     output_path?: string;
     reference_images?: string[];
+    enhancer_preset?: string;
   }) => {
     return safeToolExecute(async () => {
       try {
+        // Apply prompt enhancement if preset specified
+        let enhancedPrompt = args.prompt;
+        if (args.enhancer_preset) {
+          const enhancer = resolveEnhancer(args.enhancer_preset);
+          if (enhancer.hasTransformations()) {
+            enhancedPrompt = enhancer.enhance(args.prompt);
+          }
+        }
+
         const imagePart = await fileToGenerativePart(args.image_path);
-        const contents: any[] = [args.prompt, imagePart];
+        const contents: any[] = [enhancedPrompt, imagePart];
 
         if (args.reference_images) {
           for (const refPath of args.reference_images) {