@centrali-io/centrali-mcp 4.2.1 → 4.2.2

package/dist/tools/orchestrations.js

@@ -179,4 +179,150 @@ function registerOrchestrationTools(server, sdk) {
             };
         }
     }));
+    server.tool("create_orchestration", "Create a new orchestration workflow. Orchestrations chain compute functions together in multi-step workflows.", {
+        slug: zod_1.z.string().describe("URL-friendly unique slug (e.g., 'order-processing')"),
+        name: zod_1.z.string().describe("Human-readable name"),
+        description: zod_1.z.string().optional().describe("Optional description of the workflow"),
+        trigger: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .describe("Trigger configuration object. Must include 'type' (on-demand, event-driven, scheduled, webhook)"),
+        steps: zod_1.z
+            .array(zod_1.z.record(zod_1.z.string(), zod_1.z.any()))
+            .describe("Array of step definitions. Each step has id, type, functionId, and optional onSuccess/onFailure routing"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ slug, name, description, trigger, steps }) {
+        try {
+            const input = { slug, name, trigger, steps };
+            if (description !== undefined)
+                input.description = description;
+            const result = yield sdk.orchestrations.create(input);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            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: zod_1.z.string().describe("The orchestration ID (UUID) to update"),
+        name: zod_1.z.string().optional().describe("Updated name"),
+        description: zod_1.z.string().optional().describe("Updated description"),
+        status: zod_1.z
+            .enum(["draft", "active", "paused"])
+            .optional()
+            .describe("Updated status"),
+        trigger: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .optional()
+            .describe("Updated trigger configuration"),
+        steps: zod_1.z
+            .array(zod_1.z.record(zod_1.z.string(), zod_1.z.any()))
+            .optional()
+            .describe("Updated step definitions"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ orchestrationId, name, description, status, trigger, steps }) {
+        try {
+            const input = {};
+            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 = yield sdk.orchestrations.update(orchestrationId, input);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            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: zod_1.z.string().describe("The orchestration ID (UUID) to delete"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ orchestrationId }) {
+        try {
+            yield sdk.orchestrations.delete(orchestrationId);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Orchestration '${orchestrationId}' deleted successfully.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            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: zod_1.z.string().describe("The orchestration ID (UUID) to activate"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ orchestrationId }) {
+        try {
+            const result = yield sdk.orchestrations.activate(orchestrationId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            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: zod_1.z.string().describe("The orchestration ID (UUID) to pause"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ orchestrationId }) {
+        try {
+            const result = yield sdk.orchestrations.pause(orchestrationId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `pausing orchestration '${orchestrationId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
 }

package/dist/tools/smart-queries.js

@@ -93,4 +93,156 @@ function registerSmartQueryTools(server, sdk) {
             };
         }
     }));
+    server.tool("get_smart_query", "Get a smart query by ID. Returns the full query definition including filters, sort, and variable declarations.", {
+        recordSlug: zod_1.z.string().describe("The structure's record slug the query belongs to"),
+        queryId: zod_1.z.string().describe("The smart query ID (UUID)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, queryId }) {
+        try {
+            const result = yield sdk.smartQueries.get(recordSlug, queryId);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `getting smart query '${queryId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("create_smart_query", "Create a new smart query for a collection. Smart queries are reusable, parameterized queries with filter, sort, and variable support.", {
+        recordSlug: zod_1.z.string().describe("The structure's record slug to create the query for"),
+        name: zod_1.z.string().describe("Display name for the smart query"),
+        description: zod_1.z.string().optional().describe("Optional description"),
+        queryDefinition: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .describe("The query definition object with where, sort, limit, select, join, etc."),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, name, description, queryDefinition }) {
+        try {
+            const input = { name, queryDefinition };
+            if (description !== undefined)
+                input.description = description;
+            const result = yield sdk.smartQueries.create(recordSlug, input);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `creating smart query '${name}' for '${recordSlug}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("update_smart_query", "Update an existing smart query. Only include the fields you want to change.", {
+        recordSlug: zod_1.z.string().describe("The structure's record slug the query belongs to"),
+        queryId: zod_1.z.string().describe("The smart query ID (UUID) to update"),
+        name: zod_1.z.string().optional().describe("Updated display name"),
+        description: zod_1.z.string().optional().describe("Updated description"),
+        queryDefinition: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .optional()
+            .describe("Updated query definition object"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, queryId, name, description, queryDefinition }) {
+        try {
+            const input = {};
+            if (name !== undefined)
+                input.name = name;
+            if (description !== undefined)
+                input.description = description;
+            if (queryDefinition !== undefined)
+                input.queryDefinition = queryDefinition;
+            const result = yield sdk.smartQueries.update(recordSlug, queryId, input);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `updating smart query '${queryId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("delete_smart_query", "Delete a smart query by ID.", {
+        recordSlug: zod_1.z.string().describe("The structure's record slug the query belongs to"),
+        queryId: zod_1.z.string().describe("The smart query ID (UUID) to delete"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, queryId }) {
+        try {
+            yield sdk.smartQueries.delete(recordSlug, queryId);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Smart query '${queryId}' deleted from '${recordSlug}'.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `deleting smart query '${queryId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("test_smart_query", "Test execute a query definition without saving it. Useful for validating query syntax and previewing results before creating a smart query.", {
+        recordSlug: zod_1.z.string().describe("The structure's record slug to test against"),
+        queryDefinition: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .describe("The query definition to test (where, sort, limit, select, etc.)"),
+        variables: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.string())
+            .optional()
+            .describe("Optional variables to substitute in the query"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, queryDefinition, variables }) {
+        try {
+            const input = { queryDefinition };
+            if (variables !== undefined)
+                input.variables = variables;
+            const result = yield sdk.smartQueries.test(recordSlug, input);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `test-executing smart query for '${recordSlug}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
 }

package/dist/tools/structures.js

@@ -135,4 +135,121 @@ function registerCollectionTools(server, sdk) {
             };
         }
     }));
+    server.tool("create_collection", "Create a new data collection (schema). Define the name, slug, description, and properties (fields) for the collection.", {
+        name: zod_1.z.string().describe("Display name for the collection (e.g., 'Customers')"),
+        slug: zod_1.z.string().describe("URL-safe identifier used in API calls (e.g., 'customers')"),
+        description: zod_1.z.string().optional().describe("Optional description of the collection"),
+        properties: zod_1.z
+            .array(zod_1.z.record(zod_1.z.string(), zod_1.z.any()))
+            .optional()
+            .describe("Array of property definitions. Each property has name, type, and optional config (required, unique, defaultValue, description, config)"),
+        enableVersioning: zod_1.z.boolean().optional().describe("Enable record versioning (default: false)"),
+        schemaDiscoveryMode: zod_1.z
+            .enum(["strict", "flexible"])
+            .optional()
+            .describe("Schema discovery mode: 'strict' rejects unknown fields, 'flexible' auto-adds them"),
+        tags: zod_1.z.array(zod_1.z.string()).optional().describe("Optional tags for organizing collections"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ name, slug, description, properties, enableVersioning, schemaDiscoveryMode, tags }) {
+        try {
+            const input = { name, slug };
+            if (description !== undefined)
+                input.description = description;
+            if (properties !== undefined)
+                input.properties = properties;
+            if (enableVersioning !== undefined)
+                input.enableVersioning = enableVersioning;
+            if (schemaDiscoveryMode !== undefined)
+                input.schemaDiscoveryMode = schemaDiscoveryMode;
+            if (tags !== undefined)
+                input.tags = tags;
+            const result = yield sdk.collections.create(input);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `creating collection '${slug}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("update_collection", "Update an existing collection by ID. Only include the fields you want to change.", {
+        collectionId: zod_1.z.string().describe("The collection ID (UUID) to update"),
+        name: zod_1.z.string().optional().describe("Updated display name"),
+        description: zod_1.z.string().optional().describe("Updated description"),
+        properties: zod_1.z
+            .array(zod_1.z.record(zod_1.z.string(), zod_1.z.any()))
+            .optional()
+            .describe("Updated array of property definitions (replaces existing properties)"),
+        enableVersioning: zod_1.z.boolean().optional().describe("Enable or disable record versioning"),
+        tags: zod_1.z.array(zod_1.z.string()).optional().describe("Updated tags"),
+        defaultTtlSeconds: zod_1.z.number().nullable().optional().describe("Default TTL in seconds for new records. Set to null to clear."),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ collectionId, name, description, properties, enableVersioning, tags, defaultTtlSeconds }) {
+        try {
+            const input = {};
+            if (name !== undefined)
+                input.name = name;
+            if (description !== undefined)
+                input.description = description;
+            if (properties !== undefined)
+                input.properties = properties;
+            if (enableVersioning !== undefined)
+                input.enableVersioning = enableVersioning;
+            if (tags !== undefined)
+                input.tags = tags;
+            if (defaultTtlSeconds !== undefined)
+                input.defaultTtlSeconds = defaultTtlSeconds;
+            const result = yield sdk.collections.update(collectionId, input);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `updating collection '${collectionId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("delete_collection", "Delete a collection by ID. This permanently removes the collection schema and all its records.", {
+        collectionId: zod_1.z.string().describe("The collection ID (UUID) to delete"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ collectionId }) {
+        try {
+            yield sdk.collections.delete(collectionId);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Collection '${collectionId}' deleted successfully.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `deleting collection '${collectionId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@centrali-io/centrali-mcp",
-  "version": "4.2.1",
+  "version": "4.2.2",
   "description": "Centrali MCP Server - AI assistant integration for Centrali workspaces",
   "main": "dist/index.js",
   "type": "commonjs",