@centrali-io/centrali-mcp 4.2.0 → 4.2.2

package/src/tools/orchestrations.ts

@@ -206,4 +206,171 @@ export function registerOrchestrationTools(server: McpServer, sdk: CentraliSDK)
       }
     }
   );
+
+  server.tool(
+    "create_orchestration",
+    "Create a new orchestration workflow. Orchestrations chain compute functions together in multi-step workflows.",
+    {
+      slug: z.string().describe("URL-friendly unique slug (e.g., 'order-processing')"),
+      name: z.string().describe("Human-readable name"),
+      description: z.string().optional().describe("Optional description of the workflow"),
+      trigger: z
+        .record(z.string(), z.any())
+        .describe("Trigger configuration object. Must include 'type' (on-demand, event-driven, scheduled, webhook)"),
+      steps: z
+        .array(z.record(z.string(), z.any()))
+        .describe("Array of step definitions. Each step has id, type, functionId, and optional onSuccess/onFailure routing"),
+    },
+    async ({ slug, name, description, trigger, steps }) => {
+      try {
+        const input: Record<string, any> = { slug, name, trigger, steps };
+        if (description !== undefined) input.description = description;
+
+        const result = await sdk.orchestrations.create(input as any);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `creating orchestration '${slug}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "update_orchestration",
+    "Update an existing orchestration by ID. Only include the fields you want to change.",
+    {
+      orchestrationId: z.string().describe("The orchestration ID (UUID) to update"),
+      name: z.string().optional().describe("Updated name"),
+      description: z.string().optional().describe("Updated description"),
+      status: z
+        .enum(["draft", "active", "paused"])
+        .optional()
+        .describe("Updated status"),
+      trigger: z
+        .record(z.string(), z.any())
+        .optional()
+        .describe("Updated trigger configuration"),
+      steps: z
+        .array(z.record(z.string(), z.any()))
+        .optional()
+        .describe("Updated step definitions"),
+    },
+    async ({ orchestrationId, name, description, status, trigger, steps }) => {
+      try {
+        const input: Record<string, any> = {};
+        if (name !== undefined) input.name = name;
+        if (description !== undefined) input.description = description;
+        if (status !== undefined) input.status = status;
+        if (trigger !== undefined) input.trigger = trigger;
+        if (steps !== undefined) input.steps = steps;
+
+        const result = await sdk.orchestrations.update(orchestrationId, input as any);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `updating orchestration '${orchestrationId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "delete_orchestration",
+    "Delete an orchestration by ID. This also deletes all runs associated with the orchestration.",
+    {
+      orchestrationId: z.string().describe("The orchestration ID (UUID) to delete"),
+    },
+    async ({ orchestrationId }) => {
+      try {
+        await sdk.orchestrations.delete(orchestrationId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Orchestration '${orchestrationId}' deleted successfully.`,
+            },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `deleting orchestration '${orchestrationId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "activate_orchestration",
+    "Activate an orchestration. Active orchestrations can be triggered by scheduled events, record events, and webhooks.",
+    {
+      orchestrationId: z.string().describe("The orchestration ID (UUID) to activate"),
+    },
+    async ({ orchestrationId }) => {
+      try {
+        const result = await sdk.orchestrations.activate(orchestrationId);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `activating orchestration '${orchestrationId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "pause_orchestration",
+    "Pause an orchestration. Paused orchestrations cannot be triggered by any mechanism.",
+    {
+      orchestrationId: z.string().describe("The orchestration ID (UUID) to pause"),
+    },
+    async ({ orchestrationId }) => {
+      try {
+        const result = await sdk.orchestrations.pause(orchestrationId);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `pausing orchestration '${orchestrationId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
 }