@kadoa/mcp 0.3.12-rc.1 → 0.3.12-rc.3

package/dist/index.js

@@ -51062,6 +51062,261 @@ function registerTools(server, ctx) {
       message: `Variable "${variableKey}" (${args.variableId}) deleted.`
     });
   }));
+  server.registerTool("list_templates", {
+    description: "List all templates in the current team. Templates define reusable configurations (prompt, schema, validation, notifications) that can be linked to multiple workflows.",
+    inputSchema: strictSchema({}),
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+  }, withErrorHandling("list_templates", async () => {
+    const templates = await ctx.client.template.list();
+    return jsonResult({ templates, count: templates.length });
+  }));
+  server.registerTool("get_template", {
+    description: "Get a template by ID, including all published versions.",
+    inputSchema: strictSchema({
+      templateId: exports_external.string().describe("The template ID")
+    }),
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+  }, withErrorHandling("get_template", async (args) => {
+    const template = await ctx.client.template.get(args.templateId);
+    return jsonResult({ template });
+  }));
+  server.registerTool("create_template", {
+    description: "Create a new template. Templates define reusable configurations that can be linked to workflows. After creation, use create_template_version to publish a version with prompt, schema, and validation rules.",
+    inputSchema: strictSchema({
+      name: exports_external.string().describe("Template name (1-255 chars)"),
+      description: exports_external.string().optional().describe("Template description (max 2000 chars)")
+    }),
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+  }, withErrorHandling("create_template", async (args) => {
+    const template = await ctx.client.template.create({
+      name: args.name,
+      ...args.description != null && { description: args.description }
+    });
+    return jsonResult({
+      success: true,
+      template,
+      message: `Template "${template.name}" created. Use create_template_version to publish a version.`
+    });
+  }));
+  server.registerTool("update_template", {
+    description: "Update a template's name or description. At least one field must be provided.",
+    inputSchema: strictSchema({
+      templateId: exports_external.string().describe("The template ID to update"),
+      name: exports_external.string().optional().describe("New template name"),
+      description: exports_external.string().optional().describe("New template description")
+    }),
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
+  }, withErrorHandling("update_template", async (args) => {
+    const { templateId, ...updates } = args;
+    const template = await ctx.client.template.update(templateId, updates);
+    return jsonResult({
+      success: true,
+      template,
+      message: "Template updated."
+    });
+  }));
+  server.registerTool("delete_template", {
+    description: "Delete (archive) a template. Existing linked workflows keep their current config but are unlinked. " + "You MUST first call this tool without confirmed=true to preview what will be deleted, " + "then show the user the template name and ask for confirmation, " + "then call again with confirmed=true only after the user explicitly agrees.",
+    inputSchema: strictSchema({
+      templateId: exports_external.string().describe("The template ID to delete"),
+      confirmed: exports_external.preprocess(coerceBoolean(), exports_external.boolean()).optional().describe("Set to true only after the user has explicitly confirmed deletion. Omit or set to false for the initial preview call.")
+    }),
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true }
+  }, withErrorHandling("delete_template", async (args) => {
+    let templateName = args.templateId;
+    try {
+      const template = await ctx.client.template.get(args.templateId);
+      templateName = template.name || args.templateId;
+    } catch {}
+    if (!args.confirmed) {
+      return jsonResult({
+        pending: true,
+        templateId: args.templateId,
+        templateName,
+        message: `⚠️ You are about to delete template "${templateName}". Linked workflows will keep their current config but will be unlinked. Ask the user to confirm, then call delete_template again with confirmed=true.`
+      });
+    }
+    await ctx.client.template.delete(args.templateId);
+    return jsonResult({
+      success: true,
+      message: `Template "${templateName}" (${args.templateId}) deleted.`
+    });
+  }));
+  const TemplateSchemaFieldShape = {
+    name: exports_external.string().describe("Field name"),
+    description: exports_external.string().optional().describe("Field description"),
+    fieldType: exports_external.string().optional().describe("Field type (e.g. SCHEMA)"),
+    example: exports_external.string().optional().describe("Example value"),
+    dataType: exports_external.string().optional().describe("Data type (STRING, NUMBER, DATE, LINK, etc.)"),
+    isKey: exports_external.preprocess(coerceBoolean(), exports_external.boolean()).optional().describe("Whether the field is a key field")
+  };
+  server.registerTool("create_template_version", {
+    description: "Publish a new version of a template. Versions capture the full workflow config: prompt, schema, validation rules, and notifications. All fields are optional — include only what this version should set.",
+    inputSchema: strictSchema({
+      templateId: exports_external.string().describe("The template ID to publish a version for"),
+      prompt: exports_external.string().optional().describe("User prompt to copy into workflow config"),
+      schemaId: exports_external.string().optional().describe("Existing schema ID to reference (mutually exclusive with schemaFields)"),
+      schemaFields: exports_external.preprocess(coerceArray(), exports_external.array(exports_external.object(TemplateSchemaFieldShape))).optional().describe("Inline schema fields to create a new schema (mutually exclusive with schemaId)"),
+      schemaEntity: exports_external.string().optional().describe("Entity name for the inline schema"),
+      dataValidation: exports_external.preprocess(coerceJson(), exports_external.object({
+        config: exports_external.object({
+          enabled: exports_external.preprocess(coerceBoolean(), exports_external.boolean()).describe("Whether data validation is enabled"),
+          alerting: exports_external.object({
+            system: exports_external.object({
+              enabled: exports_external.preprocess(coerceBoolean(), exports_external.boolean()),
+              threshold: exports_external.preprocess(coerceNumber(), exports_external.number()).optional()
+            }).optional().describe("System alerting configuration"),
+            user: exports_external.object({
+              enabled: exports_external.preprocess(coerceBoolean(), exports_external.boolean()),
+              threshold: exports_external.preprocess(coerceNumber(), exports_external.number()).optional()
+            }).optional().describe("User alerting configuration")
+          }).optional().describe("Alerting configuration")
+        }).optional().describe("Data validation config to copy into workflow.config.dataValidation"),
+        rules: exports_external.preprocess(coerceArray(), exports_external.array(exports_external.object({
+          name: exports_external.string().describe("Rule name"),
+          description: exports_external.string().optional().describe("Rule description"),
+          ruleType: exports_external.enum(["regex", "custom_sql", "llm"]).describe("Type of validation rule"),
+          targetColumns: exports_external.preprocess(coerceArray(), exports_external.array(exports_external.string())).optional().describe("Columns this rule targets"),
+          parameters: exports_external.preprocess(coerceJson(), exports_external.record(exports_external.string(), exports_external.unknown())).describe("Rule parameters (e.g., {sql: '...', pattern: '...'})"),
+          status: exports_external.enum(["preview", "enabled", "disabled"]).optional().describe("Initial rule status (defaults to 'enabled')"),
+          metadata: exports_external.preprocess(coerceJson(), exports_external.record(exports_external.string(), exports_external.unknown())).optional().describe("Additional metadata")
+        }))).optional().describe("Validation rules to clone as data_validation rows")
+      })).optional().describe("Data validation configuration: { config?: { enabled, alerting? }, rules?: [{ name, ruleType, parameters, ... }] }"),
+      notifications: exports_external.preprocess(coerceArray(), exports_external.array(exports_external.object({
+        eventType: exports_external.string().describe("Notification event type"),
+        eventConfiguration: exports_external.preprocess(coerceJson(), exports_external.record(exports_external.string(), exports_external.unknown())).optional(),
+        enabled: exports_external.preprocess(coerceBoolean(), exports_external.boolean()).optional(),
+        channelIds: exports_external.preprocess(coerceArray(), exports_external.array(exports_external.string())).optional(),
+        channels: exports_external.preprocess(coerceArray(), exports_external.array(exports_external.object({ channelId: exports_external.string() }))).optional()
+      }))).optional().describe("Notification configuration for this version")
+    }),
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+  }, withErrorHandling("create_template_version", async (args) => {
+    const { templateId, ...body } = args;
+    const version2 = await ctx.client.template.createVersion(templateId, body);
+    return jsonResult({
+      success: true,
+      version: version2,
+      message: `Version ${version2.version} published for template ${templateId}.`
+    });
+  }));
+  server.registerTool("list_template_workflows", {
+    description: "List all workflows linked to a template.",
+    inputSchema: strictSchema({
+      templateId: exports_external.string().describe("The template ID")
+    }),
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+  }, withErrorHandling("list_template_workflows", async (args) => {
+    const workflows = await ctx.client.template.listWorkflows(args.templateId);
+    return jsonResult({ workflows, count: workflows.length });
+  }));
+  server.registerTool("link_workflows_to_template", {
+    description: "Link workflows to a template. Linking applies the template's latest version config to the workflows. " + "Without force, fails if any workflow is already linked to a different template. With force=true, relinks them. " + "You MUST first call without confirmed=true to preview, then ask the user for confirmation, " + "then call again with confirmed=true.",
+    inputSchema: strictSchema({
+      templateId: exports_external.string().describe("The template ID to link workflows to"),
+      workflowIds: exports_external.preprocess(coerceArray(), exports_external.array(exports_external.string())).describe("Array of workflow IDs to link"),
+      force: exports_external.preprocess(coerceBoolean(), exports_external.boolean()).optional().describe("If true, relink workflows already linked to another template"),
+      confirmed: exports_external.preprocess(coerceBoolean(), exports_external.boolean()).optional().describe("Set to true only after user confirms. Omit for preview.")
+    }),
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+  }, withErrorHandling("link_workflows_to_template", async (args) => {
+    if (!args.confirmed) {
+      const forceNote = args.force ? " Workflows already linked to other templates will be relinked (force=true)." : " Will fail if any workflow is already linked to a different template.";
+      return jsonResult({
+        pending: true,
+        templateId: args.templateId,
+        workflowIds: args.workflowIds,
+        force: !!args.force,
+        message: `⚠️ You are about to link ${args.workflowIds.length} workflow(s) to template ${args.templateId}. This will apply the template's latest version config to these workflows.${forceNote} Ask the user to confirm, then call again with confirmed=true.`
+      });
+    }
+    const result = await ctx.client.template.linkWorkflows(args.templateId, {
+      workflowIds: args.workflowIds,
+      ...args.force != null && { force: args.force }
+    });
+    return jsonResult({
+      success: true,
+      result,
+      message: `Linked ${args.workflowIds.length} workflow(s) to template ${args.templateId}.`
+    });
+  }));
+  server.registerTool("unlink_workflows_from_template", {
+    description: "Unlink workflows from a template. Workflows keep their current config but are no longer associated with the template. " + "You MUST first call without confirmed=true to preview, then ask the user for confirmation, " + "then call again with confirmed=true.",
+    inputSchema: strictSchema({
+      templateId: exports_external.string().describe("The template ID to unlink workflows from"),
+      workflowIds: exports_external.preprocess(coerceArray(), exports_external.array(exports_external.string())).describe("Array of workflow IDs to unlink"),
+      confirmed: exports_external.preprocess(coerceBoolean(), exports_external.boolean()).optional().describe("Set to true only after user confirms. Omit for preview.")
+    }),
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false }
+  }, withErrorHandling("unlink_workflows_from_template", async (args) => {
+    if (!args.confirmed) {
+      return jsonResult({
+        pending: true,
+        templateId: args.templateId,
+        workflowIds: args.workflowIds,
+        message: `⚠️ You are about to unlink ${args.workflowIds.length} workflow(s) from template ${args.templateId}. Workflows will keep their current config. Ask the user to confirm, then call again with confirmed=true.`
+      });
+    }
+    const result = await ctx.client.template.unlinkWorkflows(args.templateId, {
+      workflowIds: args.workflowIds
+    });
+    return jsonResult({
+      success: true,
+      result,
+      message: `Unlinked ${args.workflowIds.length} workflow(s) from template ${args.templateId}.`
+    });
+  }));
+  server.registerTool("apply_template_update", {
+    description: "Apply a specific template version to workflows. Updates the workflows' config (prompt, schema, validation, notifications) to match the specified version.",
+    inputSchema: strictSchema({
+      templateId: exports_external.string().describe("The template ID"),
+      targetVersion: exports_external.preprocess(coerceNumber(), exports_external.number().int().min(1)).describe("Version number to apply"),
+      workflowIds: exports_external.preprocess(coerceArray(), exports_external.array(exports_external.string())).describe("Array of workflow IDs to update (max 100)")
+    }),
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+  }, withErrorHandling("apply_template_update", async (args) => {
+    const result = await ctx.client.template.applyUpdate(args.templateId, {
+      targetVersion: args.targetVersion,
+      workflowIds: args.workflowIds
+    });
+    return jsonResult({
+      success: true,
+      result,
+      message: `Applied version ${args.targetVersion} to ${args.workflowIds.length} workflow(s).`
+    });
+  }));
+  server.registerTool("save_workflow_as_template", {
+    description: "Create a template from an existing workflow's configuration (prompt, schema, validation, notifications). " + "Provide 'name' to create a new template, or 'templateId' to add a new version to an existing template.",
+    inputSchema: strictSchema({
+      workflowId: exports_external.string().describe("Source workflow ID to extract config from"),
+      name: exports_external.string().optional().describe("Name for the new template (required if templateId is not set)"),
+      description: exports_external.string().optional().describe("Description for the new template"),
+      templateId: exports_external.string().optional().describe("Existing template ID to add a new version to (mutually exclusive with name)")
+    }),
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+  }, withErrorHandling("save_workflow_as_template", async (args) => {
+    const result = await ctx.client.template.createFromWorkflow({
+      workflowId: args.workflowId,
+      ...args.name != null && { name: args.name },
+      ...args.description != null && { description: args.description },
+      ...args.templateId != null && { templateId: args.templateId }
+    });
+    return jsonResult({
+      success: true,
+      result,
+      message: `Template created from workflow ${args.workflowId}.`
+    });
+  }));
+  server.registerTool("list_template_schemas", {
+    description: "List schemas associated with a template.",
+    inputSchema: strictSchema({
+      templateId: exports_external.string().describe("The template ID")
+    }),
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+  }, withErrorHandling("list_template_schemas", async (args) => {
+    const schemas4 = await ctx.client.template.listSchemas(args.templateId);
+    return jsonResult({ schemas: schemas4, count: schemas4.length });
+  }));
 }
 var SchemaFieldShape, DASHBOARD_BASE_URL = "https://www.kadoa.com";
 var init_tools = __esm(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kadoa/mcp",
-  "version": "0.3.12-rc.1",
+  "version": "0.3.12-rc.3",
   "description": "Kadoa MCP Server — manage workflows from Claude Desktop, Cursor, and other MCP clients",
   "type": "module",
   "main": "dist/index.js",
@@ -24,7 +24,7 @@
     "prepublishOnly": "bun run check-types && bun run test:unit && bun run build"
   },
   "dependencies": {
-    "@kadoa/node-sdk": "^0.25.0",
+    "@kadoa/node-sdk": "^0.26.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "express": "^5.2.1",
     "ioredis": "^5.6.1",