@centrali-io/centrali-mcp 4.4.5 → 4.4.7

package/dist/tools/compute.js

@@ -8,8 +8,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerComputeTools = registerComputeTools;
+const axios_1 = __importDefault(require("axios"));
 const zod_1 = require("zod");
 function formatError(error, context) {
     var _a, _b;
@@ -33,7 +37,22 @@ function formatError(error, context) {
     }
     return `Error ${context}: ${error instanceof Error ? error.message : String(error)}`;
 }
-function registerComputeTools(server, sdk) {
+/**
+ * Ensures the SDK has a valid token.
+ */
+function ensureToken(sdk) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = sdk.getToken();
+        if (token)
+            return token;
+        try {
+            yield sdk.functions.list({ limit: 1 });
+        }
+        catch ( /* token refresh side effect */_a) { /* token refresh side effect */ }
+        return sdk.getToken();
+    });
+}
+function registerComputeTools(server, sdk, centraliUrl, workspaceId) {
     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"),
         limit: zod_1.z.number().optional().describe("Results per page"),
@@ -63,9 +82,9 @@ function registerComputeTools(server, sdk) {
             };
         }
     }));
-    server.tool("list_triggers", "List function triggers in the workspace. Triggers define how and when compute functions are executed (on-demand, event-driven, scheduled, http-trigger).", {
+    server.tool("list_triggers", "List function triggers in the workspace. Triggers define how and when compute functions are executed (on-demand, event-driven, scheduled, http-trigger, endpoint).", {
         executionType: zod_1.z
-            .enum(["on-demand", "event-driven", "scheduled", "http-trigger"])
+            .enum(["on-demand", "event-driven", "scheduled", "http-trigger", "endpoint"])
             .optional()
             .describe("Filter by trigger execution type"),
         page: zod_1.z.number().optional().describe("Page number"),
@@ -112,7 +131,11 @@ function registerComputeTools(server, sdk) {
                 content: [
                     {
                         type: "text",
-                        text: JSON.stringify({ jobId: result.data, message: "Trigger invoked successfully" }, null, 2),
+                        text: JSON.stringify({
+                            jobId: result.data,
+                            message: "Trigger invoked successfully. Execution is async — the function is running in the background.",
+                            next_step: `To check the result, call get_compute_job_status with jobId='${result.data}'. It returns the job state (queued → running → completed | failed) and the return value or error.`,
+                        }, null, 2),
                     },
                 ],
             };
@@ -129,6 +152,37 @@ function registerComputeTools(server, sdk) {
             };
         }
     }));
+    server.tool("get_compute_job_status", "Check the status of an async compute job by job ID. Returns the current state (queued, running, completed, failed), the return value on success, or the failure reason on error. Use this after invoke_trigger to poll for results.", {
+        jobId: zod_1.z.string().describe("The job ID returned by invoke_trigger"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ jobId }) {
+        try {
+            const token = yield ensureToken(sdk);
+            const url = new URL(centraliUrl);
+            const hostname = url.hostname.startsWith("api.")
+                ? url.hostname
+                : `api.${url.hostname}`;
+            const apiUrl = `${url.protocol}//${hostname}/data/workspace/${workspaceId}/api/v1/jobs/compute/${jobId}`;
+            const result = yield axios_1.default.get(apiUrl, {
+                headers: token ? { Authorization: `Bearer ${token}` } : {},
+            });
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `getting job status for '${jobId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
     // ── Function CRUD tools ──────────────────────────────────────────
     server.tool("get_function", "Get a compute function by ID. Returns the full function definition including code.", {
         functionId: zod_1.z.string().describe("The compute function ID (UUID)"),
@@ -340,13 +394,13 @@ function registerComputeTools(server, sdk) {
         name: zod_1.z.string().describe("Display name for the trigger"),
         functionId: zod_1.z.string().describe("The compute function ID (UUID) to execute"),
         executionType: zod_1.z
-            .enum(["on-demand", "event-driven", "scheduled", "http-trigger"])
-            .describe("How the trigger fires: on-demand (manual), event-driven (data events), scheduled (cron), or http-trigger (external HTTP POST)"),
+            .enum(["on-demand", "event-driven", "scheduled", "http-trigger", "endpoint"])
+            .describe("How the trigger fires: on-demand (manual), event-driven (data events), scheduled (cron), http-trigger (external HTTP POST), or endpoint (synchronous HTTP API — returns response inline)"),
         description: zod_1.z.string().optional().describe("Optional description"),
         triggerMetadata: zod_1.z
             .record(zod_1.z.string(), zod_1.z.any())
             .optional()
-            .describe("Type-specific configuration. For event-driven: { eventType, recordSlug } where eventType is record_created | record_updated | record_deleted. For scheduled: { scheduleType, cronExpression, timezone }. For http-trigger: auto-generated URL."),
+            .describe("Type-specific configuration. For event-driven: { eventType, recordSlug }. For scheduled: { scheduleType, cronExpression, timezone }. For http-trigger: auto-generated URL. For endpoint: { path, allowedMethods?, timeoutMs?, auth? } where path is URL-safe (e.g., 'create-order'), allowedMethods defaults to ['POST'], timeoutMs 1000-30000 (default 30000), auth is { mode: 'bearer'|'public'|'apiKey'|'hmac' }."),
         enabled: zod_1.z.boolean().optional().describe("Whether the trigger is enabled (default: true)"),
     }, (_a) => __awaiter(this, [_a], void 0, function* ({ name, functionId, executionType, description, triggerMetadata, enabled }) {
         try {
@@ -487,6 +541,129 @@ function registerComputeTools(server, sdk) {
             };
         }
     }));
+    // ── Function Runs tools ────────────────────────────────────────────
+    server.tool("get_function_run", "Get a function run by ID. Returns status, output, error, timing, and execution metadata. Use this to check the result of an async trigger invocation or test execution.", {
+        runId: zod_1.z.string().describe("The function run ID (UUID)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ runId }) {
+        try {
+            const result = yield sdk.runs.get(runId);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `getting function run '${runId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("list_function_runs", "List function runs filtered by trigger ID or function ID. Returns execution history with status, timing, and errors. Useful for checking whether a trigger invocation completed and what it returned.", {
+        triggerId: zod_1.z.string().optional().describe("Filter runs by trigger ID (UUID)"),
+        functionId: zod_1.z.string().optional().describe("Filter runs by function ID (UUID)"),
+        status: zod_1.z
+            .enum(["pending", "running", "completed", "failure", "timeout"])
+            .optional()
+            .describe("Filter by run status"),
+        page: zod_1.z.number().optional().describe("Page number"),
+        limit: zod_1.z.number().optional().describe("Results per page"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ triggerId, functionId, status, page, limit }) {
+        try {
+            if (!triggerId && !functionId) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Error: provide either triggerId or functionId to list runs.",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const options = {};
+            if (status)
+                options.status = status;
+            if (page !== undefined)
+                options.page = page;
+            if (limit !== undefined)
+                options.limit = limit;
+            const opts = Object.keys(options).length > 0 ? options : undefined;
+            const result = triggerId
+                ? yield sdk.runs.listByTrigger(triggerId, opts)
+                : yield sdk.runs.listByFunction(functionId, opts);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `listing function runs`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    // ── Endpoint Trigger (Sync Execution) ─────────────────────────────
+    server.tool("invoke_endpoint", "Invoke a compute endpoint trigger by path. The function executes synchronously — Centrali waits for the function to complete and returns its output directly in the response. No polling needed. Max execution time: 30 seconds (configurable via triggerMetadata.timeoutMs, range 1–30s). If the function exceeds the timeout, returns 504. Endpoint triggers must be created first with executionType='endpoint'. Use this for real-time API responses; use invoke_trigger for long-running background work that doesn't need an immediate response.", {
+        path: zod_1.z.string().describe("The endpoint path (e.g., 'create-order', 'webhook/shipments'). This is set in the trigger's triggerMetadata.path."),
+        method: zod_1.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional().describe("HTTP method (default: POST). Must be in the trigger's allowedMethods."),
+        payload: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional().describe("Request body payload (sent as JSON)"),
+        headers: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional().describe("Additional headers (e.g., X-API-Key for apiKey auth)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ path, method, payload, headers: extraHeaders }) {
+        try {
+            const token = yield ensureToken(sdk);
+            const url = new URL(centraliUrl);
+            const hostname = url.hostname.startsWith("api.")
+                ? url.hostname
+                : `api.${url.hostname}`;
+            const apiUrl = `${url.protocol}//${hostname}/data/workspace/${workspaceId}/api/v1/endpoints/${path}`;
+            const reqHeaders = {};
+            if (token)
+                reqHeaders.Authorization = `Bearer ${token}`;
+            if (extraHeaders)
+                Object.assign(reqHeaders, extraHeaders);
+            const httpMethod = (method || "POST").toLowerCase();
+            const result = yield (0, axios_1.default)({
+                method: httpMethod,
+                url: apiUrl,
+                data: ["get", "delete"].includes(httpMethod) ? undefined : (payload || {}),
+                headers: reqHeaders,
+                validateStatus: () => true, // Don't throw on non-2xx — return the function's response as-is
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            status: result.status,
+                            headers: {
+                                "content-type": result.headers["content-type"],
+                                "x-execution-id": result.headers["x-execution-id"],
+                            },
+                            body: result.data,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, `invoking endpoint '${path}'`) }],
+                isError: true,
+            };
+        }
+    }));
     // ── Allowed Domains tools ──────────────────────────────────────────
     server.tool("list_allowed_domains", "List all allowed domains for compute function HTTP requests. Functions can only call external APIs on domains in this allowlist.", {}, () => __awaiter(this, void 0, void 0, function* () {
         try {