@centrali-io/centrali-mcp 3.1.4 → 3.1.6

package/dist/index.js

@@ -18,6 +18,9 @@ const records_js_1 = require("./tools/records.js");
 const search_js_1 = require("./tools/search.js");
 const compute_js_1 = require("./tools/compute.js");
 const smart_queries_js_1 = require("./tools/smart-queries.js");
+const orchestrations_js_1 = require("./tools/orchestrations.js");
+const insights_js_1 = require("./tools/insights.js");
+const validation_js_1 = require("./tools/validation.js");
 const structures_js_2 = require("./resources/structures.js");
 function getRequiredEnv(name) {
     const value = process.env[name];
@@ -49,6 +52,9 @@ function main() {
         (0, search_js_1.registerSearchTools)(server, sdk);
         (0, compute_js_1.registerComputeTools)(server, sdk);
         (0, smart_queries_js_1.registerSmartQueryTools)(server, sdk);
+        (0, orchestrations_js_1.registerOrchestrationTools)(server, sdk);
+        (0, insights_js_1.registerInsightTools)(server, sdk);
+        (0, validation_js_1.registerValidationTools)(server, sdk);
         // Register resources
         (0, structures_js_2.registerStructureResources)(server, sdk);
         // Start stdio transport

package/dist/resources/structures.js

@@ -11,59 +11,96 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerStructureResources = registerStructureResources;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+function formatError(error, context) {
+    var _a, _b;
+    if (error && typeof error === 'object') {
+        const e = error;
+        if ('message' in e) {
+            let msg = `Error ${context}`;
+            if ('code' in e || 'status' in e) {
+                msg += `: [${(_b = (_a = e.code) !== null && _a !== void 0 ? _a : e.status) !== null && _b !== void 0 ? _b : 'ERROR'}] ${e.message}`;
+            }
+            else {
+                msg += `: ${e.message}`;
+            }
+            if (Array.isArray(e.fieldErrors) && e.fieldErrors.length > 0) {
+                msg += '\nField errors:\n' + e.fieldErrors
+                    .map(f => `  ${f.field}: ${f.message}`)
+                    .join('\n');
+            }
+            return msg;
+        }
+    }
+    return `Error ${context}: ${error instanceof Error ? error.message : String(error)}`;
+}
 function registerStructureResources(server, sdk) {
     // Static resource: list all structures (gives LLM workspace context)
     server.resource("structures-list", "centrali://structures", {
         description: "List of all data structures in the workspace with name, slug, and description",
         mimeType: "application/json",
     }, (uri) => __awaiter(this, void 0, void 0, function* () {
-        const result = yield sdk.structures.list({ limit: 100 });
-        const summary = (result.data || []).map((s) => {
-            var _a;
-            return ({
-                name: s.name,
-                recordSlug: s.recordSlug,
-                description: s.description || "",
-                propertyCount: ((_a = s.properties) === null || _a === void 0 ? void 0 : _a.length) || 0,
-                status: s.status,
+        try {
+            const result = yield sdk.structures.list({ limit: 100 });
+            const summary = (result.data || []).map((s) => {
+                var _a;
+                return ({
+                    name: s.name,
+                    recordSlug: s.recordSlug,
+                    description: s.description || "",
+                    propertyCount: ((_a = s.properties) === null || _a === void 0 ? void 0 : _a.length) || 0,
+                    status: s.status,
+                });
             });
-        });
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: "application/json",
-                    text: JSON.stringify(summary, null, 2),
-                },
-            ],
-        };
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify(summary, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(formatError(error, "listing structures resource"));
+        }
     }));
     // Resource template: full schema for a specific structure
     server.resource("structure-schema", new mcp_js_1.ResourceTemplate("centrali://structures/{slug}", {
         list: () => __awaiter(this, void 0, void 0, function* () {
-            const result = yield sdk.structures.list({ limit: 100 });
-            return {
-                resources: (result.data || []).map((s) => ({
-                    uri: `centrali://structures/${s.recordSlug}`,
-                    name: s.name,
-                    description: s.description || `Schema for ${s.name}`,
-                    mimeType: "application/json",
-                })),
-            };
+            try {
+                const result = yield sdk.structures.list({ limit: 100 });
+                return {
+                    resources: (result.data || []).map((s) => ({
+                        uri: `centrali://structures/${s.recordSlug}`,
+                        name: s.name,
+                        description: s.description || `Schema for ${s.name}`,
+                        mimeType: "application/json",
+                    })),
+                };
+            }
+            catch (error) {
+                throw new Error(formatError(error, "listing structure schemas"));
+            }
         }),
     }), {
         description: "Full schema definition for a specific structure",
         mimeType: "application/json",
     }, (uri_1, _a) => __awaiter(this, [uri_1, _a], void 0, function* (uri, { slug }) {
-        const result = yield sdk.structures.getBySlug(slug);
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: "application/json",
-                    text: JSON.stringify(result.data, null, 2),
-                },
-            ],
-        };
+        try {
+            const result = yield sdk.structures.getBySlug(slug);
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify(result.data, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(formatError(error, `getting structure schema for '${slug}'`));
+        }
     }));
 }

package/dist/tools/compute.js

@@ -11,6 +11,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerComputeTools = registerComputeTools;
 const zod_1 = require("zod");
+function formatError(error, context) {
+    var _a, _b;
+    if (error && typeof error === 'object') {
+        const e = error;
+        if ('message' in e) {
+            let msg = `Error ${context}`;
+            if ('code' in e || 'status' in e) {
+                msg += `: [${(_b = (_a = e.code) !== null && _a !== void 0 ? _a : e.status) !== null && _b !== void 0 ? _b : 'ERROR'}] ${e.message}`;
+            }
+            else {
+                msg += `: ${e.message}`;
+            }
+            if (Array.isArray(e.fieldErrors) && e.fieldErrors.length > 0) {
+                msg += '\nField errors:\n' + e.fieldErrors
+                    .map(f => `  ${f.field}: ${f.message}`)
+                    .join('\n');
+            }
+            return msg;
+        }
+    }
+    return `Error ${context}: ${error instanceof Error ? error.message : String(error)}`;
+}
 function registerComputeTools(server, sdk) {
     server.tool("list_functions", "List all compute functions in the workspace. Compute functions are JavaScript code blocks that run server-side.", {
         page: zod_1.z.number().optional().describe("Page number"),
@@ -34,7 +56,7 @@ function registerComputeTools(server, sdk) {
                 content: [
                     {
                         type: "text",
-                        text: `Error listing functions: ${error.message}`,
+                        text: formatError(error, "listing functions"),
                     },
                 ],
                 isError: true,
@@ -69,7 +91,7 @@ function registerComputeTools(server, sdk) {
                 content: [
                     {
                         type: "text",
-                        text: `Error listing triggers: ${error.message}`,
+                        text: formatError(error, "listing triggers"),
                     },
                 ],
                 isError: true,
@@ -100,7 +122,7 @@ function registerComputeTools(server, sdk) {
                 content: [
                     {
                         type: "text",
-                        text: `Error invoking trigger '${triggerId}': ${error.message}`,
+                        text: formatError(error, `invoking trigger '${triggerId}'`),
                     },
                 ],
                 isError: true,

package/dist/tools/insights.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CentraliSDK } from "@centrali-io/centrali-sdk";
+export declare function registerInsightTools(server: McpServer, sdk: CentraliSDK): void;

package/dist/tools/insights.js

@@ -0,0 +1,172 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInsightTools = registerInsightTools;
+const zod_1 = require("zod");
+function formatError(error, context) {
+    var _a, _b;
+    if (error && typeof error === "object") {
+        const e = error;
+        if ("message" in e) {
+            let msg = `Error ${context}`;
+            if ("code" in e || "status" in e) {
+                msg += `: [${(_b = (_a = e.code) !== null && _a !== void 0 ? _a : e.status) !== null && _b !== void 0 ? _b : "ERROR"}] ${e.message}`;
+            }
+            else {
+                msg += `: ${e.message}`;
+            }
+            if (Array.isArray(e.fieldErrors) && e.fieldErrors.length > 0) {
+                msg +=
+                    "\nField errors:\n" +
+                        e.fieldErrors
+                            .map((f) => `  ${f.field}: ${f.message}`)
+                            .join("\n");
+            }
+            return msg;
+        }
+    }
+    return `Error ${context}: ${error instanceof Error ? error.message : String(error)}`;
+}
+function registerInsightTools(server, sdk) {
+    server.tool("list_insights", "List anomaly insights detected by Centrali's AI analysis. Insights flag unusual patterns in your data such as spikes, drops, or outliers.", {
+        structureSlug: zod_1.z
+            .string()
+            .optional()
+            .describe("Filter insights by structure slug. If omitted, returns insights for all structures."),
+        status: zod_1.z
+            .enum(["active", "acknowledged", "dismissed"])
+            .optional()
+            .describe("Filter by insight status"),
+        severity: zod_1.z
+            .enum(["critical", "high", "medium", "low"])
+            .optional()
+            .describe("Filter by severity level"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ structureSlug, status, severity }) {
+        try {
+            const options = {};
+            if (structureSlug)
+                options.structureSlug = structureSlug;
+            if (status)
+                options.status = status;
+            if (severity)
+                options.severity = severity;
+            const result = yield sdk.anomalyInsights.list(Object.keys(options).length > 0 ? options : undefined);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, "listing insights") }],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("get_insight", "Get full details of a single anomaly insight by ID.", {
+        insightId: zod_1.z.string().describe("The insight ID (UUID)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ insightId }) {
+        try {
+            const result = yield sdk.anomalyInsights.get(insightId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    { type: "text", text: formatError(error, `getting insight '${insightId}'`) },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("acknowledge_insight", "Mark an anomaly insight as acknowledged (reviewed/handled). The insight remains visible but is flagged as addressed.", {
+        insightId: zod_1.z.string().describe("The insight ID (UUID) to acknowledge"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ insightId }) {
+        try {
+            const result = yield sdk.anomalyInsights.acknowledge(insightId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `acknowledging insight '${insightId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("dismiss_insight", "Dismiss an anomaly insight, marking it as a false positive or not relevant.", {
+        insightId: zod_1.z.string().describe("The insight ID (UUID) to dismiss"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ insightId }) {
+        try {
+            const result = yield sdk.anomalyInsights.dismiss(insightId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    { type: "text", text: formatError(error, `dismissing insight '${insightId}'`) },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("get_insights_summary", "Get a summary of anomaly insights in the workspace — counts by status and severity. Optionally filter by structure.", {
+        structureSlug: zod_1.z
+            .string()
+            .optional()
+            .describe("Filter summary to a specific structure. If omitted, returns workspace-wide summary."),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ structureSlug }) {
+        try {
+            const result = yield sdk.anomalyInsights.getSummary(structureSlug);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    { type: "text", text: formatError(error, "getting insights summary") },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("trigger_anomaly_analysis", "Trigger AI-powered anomaly analysis for a structure. Starts a background analysis to detect unusual patterns. Check list_insights after the scan completes.", {
+        structureSlug: zod_1.z.string().describe("The structure's record slug to analyze"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ structureSlug }) {
+        try {
+            const result = yield sdk.anomalyInsights.triggerAnalysis(structureSlug);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `triggering anomaly analysis for '${structureSlug}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+}

package/dist/tools/orchestrations.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CentraliSDK } from "@centrali-io/centrali-sdk";
+export declare function registerOrchestrationTools(server: McpServer, sdk: CentraliSDK): void;

package/dist/tools/orchestrations.js

@@ -0,0 +1,182 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerOrchestrationTools = registerOrchestrationTools;
+const zod_1 = require("zod");
+function formatError(error, context) {
+    var _a, _b;
+    if (error && typeof error === "object") {
+        const e = error;
+        if ("message" in e) {
+            let msg = `Error ${context}`;
+            if ("code" in e || "status" in e) {
+                msg += `: [${(_b = (_a = e.code) !== null && _a !== void 0 ? _a : e.status) !== null && _b !== void 0 ? _b : "ERROR"}] ${e.message}`;
+            }
+            else {
+                msg += `: ${e.message}`;
+            }
+            if (Array.isArray(e.fieldErrors) && e.fieldErrors.length > 0) {
+                msg +=
+                    "\nField errors:\n" +
+                        e.fieldErrors
+                            .map((f) => `  ${f.field}: ${f.message}`)
+                            .join("\n");
+            }
+            return msg;
+        }
+    }
+    return `Error ${context}: ${error instanceof Error ? error.message : String(error)}`;
+}
+function registerOrchestrationTools(server, sdk) {
+    server.tool("list_orchestrations", "List all orchestrations in the workspace. Orchestrations are multi-step workflows that chain compute functions together.", {
+        offset: zod_1.z.number().optional().describe("Number of results to skip (for pagination)"),
+        limit: zod_1.z.number().optional().describe("Results per page"),
+        status: zod_1.z
+            .enum(["draft", "active", "paused"])
+            .optional()
+            .describe("Filter by orchestration status"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ offset, limit, status }) {
+        try {
+            const options = {};
+            if (offset !== undefined)
+                options.offset = offset;
+            if (limit !== undefined)
+                options.limit = limit;
+            if (status)
+                options.status = status;
+            const result = yield sdk.orchestrations.list(Object.keys(options).length > 0 ? options : undefined);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, "listing orchestrations") }],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("get_orchestration", "Get full details of a single orchestration by ID, including its step definitions.", {
+        orchestrationId: zod_1.z.string().describe("The orchestration ID (UUID)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ orchestrationId }) {
+        try {
+            const result = yield sdk.orchestrations.get(orchestrationId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `getting orchestration '${orchestrationId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("trigger_orchestration", "Trigger an orchestration run. Creates a new run instance and starts executing the workflow. Optionally pass input data to the run.", {
+        orchestrationId: zod_1.z.string().describe("The orchestration ID (UUID) to trigger"),
+        input: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .optional()
+            .describe("Input data passed to the first step of the orchestration"),
+        correlationId: zod_1.z
+            .string()
+            .optional()
+            .describe("Optional correlation ID for tracing this run"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ orchestrationId, input, correlationId }) {
+        try {
+            const options = {};
+            if (input)
+                options.input = input;
+            if (correlationId)
+                options.correlationId = correlationId;
+            const result = yield sdk.orchestrations.trigger(orchestrationId, Object.keys(options).length > 0 ? options : undefined);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `triggering orchestration '${orchestrationId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("list_orchestration_runs", "List all runs for an orchestration. Runs represent individual executions of the workflow.", {
+        orchestrationId: zod_1.z.string().describe("The orchestration ID (UUID)"),
+        offset: zod_1.z.number().optional().describe("Number of results to skip (for pagination)"),
+        limit: zod_1.z.number().optional().describe("Results per page"),
+        status: zod_1.z
+            .enum(["pending", "running", "waiting", "completed", "failed"])
+            .optional()
+            .describe("Filter by run status"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ orchestrationId, offset, limit, status }) {
+        try {
+            const options = {};
+            if (offset !== undefined)
+                options.offset = offset;
+            if (limit !== undefined)
+                options.limit = limit;
+            if (status)
+                options.status = status;
+            const result = yield sdk.orchestrations.listRuns(orchestrationId, Object.keys(options).length > 0 ? options : undefined);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `listing runs for orchestration '${orchestrationId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("get_orchestration_run", "Get details of a specific orchestration run. Set includeSteps=true to see step-by-step execution history.", {
+        orchestrationId: zod_1.z.string().describe("The orchestration ID (UUID)"),
+        runId: zod_1.z.string().describe("The run ID (UUID)"),
+        includeSteps: zod_1.z
+            .boolean()
+            .optional()
+            .describe("Include step execution history in the response (default: false)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ orchestrationId, runId, includeSteps }) {
+        try {
+            const result = yield sdk.orchestrations.getRun(orchestrationId, runId, includeSteps);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `getting run '${runId}' for orchestration '${orchestrationId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+}