@centrali-io/centrali-mcp 4.2.5 → 4.2.7

package/dist/tools/compute.js

@@ -63,9 +63,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, webhook).", {
+    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).", {
         executionType: zod_1.z
-            .enum(["on-demand", "event-driven", "scheduled", "webhook"])
+            .enum(["on-demand", "event-driven", "scheduled", "http-trigger"])
             .optional()
             .describe("Filter by trigger execution type"),
         page: zod_1.z.number().optional().describe("Page number"),
@@ -155,17 +155,16 @@ function registerComputeTools(server, sdk) {
     }));
     server.tool("create_function", "Create a new compute function. Compute functions are JavaScript code blocks that run server-side.", {
         name: zod_1.z.string().describe("Display name for the function"),
-        slug: zod_1.z.string().describe("URL-safe unique identifier (e.g., 'process-order')"),
         code: zod_1.z.string().describe("JavaScript source code. Must export an async function: module.exports = async (ctx) => { ... }"),
         description: zod_1.z.string().optional().describe("Optional description of what the function does"),
-        timeout: zod_1.z.number().optional().describe("Execution timeout in milliseconds (default: 30000)"),
-    }, (_a) => __awaiter(this, [_a], void 0, function* ({ name, slug, code, description, timeout }) {
+        timeoutMs: zod_1.z.number().optional().describe("Execution timeout in milliseconds (default: 30000, min: 1000, max: 300000)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ name, code, description, timeoutMs }) {
         try {
-            const input = { name, slug, code };
+            const input = { name, code };
             if (description !== undefined)
                 input.description = description;
-            if (timeout !== undefined)
-                input.timeout = timeout;
+            if (timeoutMs !== undefined)
+                input.timeoutMs = timeoutMs;
             const result = yield sdk.functions.create(input);
             return {
                 content: [
@@ -178,7 +177,7 @@ function registerComputeTools(server, sdk) {
                 content: [
                     {
                         type: "text",
-                        text: formatError(error, `creating function '${slug}'`),
+                        text: formatError(error, `creating function '${name}'`),
                     },
                 ],
                 isError: true,
@@ -190,8 +189,8 @@ function registerComputeTools(server, sdk) {
         name: zod_1.z.string().optional().describe("Updated display name"),
         description: zod_1.z.string().optional().describe("Updated description"),
         code: zod_1.z.string().optional().describe("Updated JavaScript source code"),
-        timeout: zod_1.z.number().optional().describe("Updated execution timeout in milliseconds"),
-    }, (_a) => __awaiter(this, [_a], void 0, function* ({ functionId, name, description, code, timeout }) {
+        timeoutMs: zod_1.z.number().optional().describe("Updated execution timeout in milliseconds (min: 1000, max: 300000)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ functionId, name, description, code, timeoutMs }) {
         try {
             const input = {};
             if (name !== undefined)
@@ -200,8 +199,8 @@ function registerComputeTools(server, sdk) {
                 input.description = description;
             if (code !== undefined)
                 input.code = code;
-            if (timeout !== undefined)
-                input.timeout = timeout;
+            if (timeoutMs !== undefined)
+                input.timeoutMs = timeoutMs;
             const result = yield sdk.functions.update(functionId, input);
             return {
                 content: [
@@ -249,15 +248,18 @@ function registerComputeTools(server, sdk) {
     }));
     server.tool("test_function", "Test execute code without saving it as a function. Useful for validating function code before creating or updating.", {
         code: zod_1.z.string().describe("JavaScript code to test. Must export an async function: module.exports = async (ctx) => { ... }"),
-        input: zod_1.z
+        params: zod_1.z
             .record(zod_1.z.string(), zod_1.z.any())
             .optional()
-            .describe("Optional input data passed to the function as ctx.input"),
-    }, (_a) => __awaiter(this, [_a], void 0, function* ({ code, input }) {
+            .describe("Optional parameters passed to the function as executionParams"),
+        timeoutMs: zod_1.z.number().optional().describe("Execution timeout in milliseconds (default: 30000, min: 1000, max: 300000)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ code, params, timeoutMs }) {
         try {
             const testInput = { code };
-            if (input !== undefined)
-                testInput.input = input;
+            if (params !== undefined)
+                testInput.params = params;
+            if (timeoutMs !== undefined)
+                testInput.timeoutMs = timeoutMs;
             const result = yield sdk.functions.testExecute(testInput);
             return {
                 content: [
@@ -305,13 +307,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", "webhook"])
-            .describe("How the trigger fires: on-demand (manual), event-driven (data events), scheduled (cron), or webhook (HTTP)"),
+            .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)"),
         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: { event, recordSlug }. For scheduled: { scheduleType, cronExpression, timezone }. For webhook: auto-generated URL."),
+            .describe("Type-specific configuration. For event-driven: { event, recordSlug }. For scheduled: { scheduleType, cronExpression, timezone }. For http-trigger: auto-generated URL."),
         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 {
@@ -452,4 +454,75 @@ function registerComputeTools(server, sdk) {
             };
         }
     }));
+    // ── 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 {
+            const result = yield sdk.allowedDomains.list();
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, "listing allowed domains"),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("add_allowed_domain", "Add a domain to the allowlist so compute functions can make HTTP requests to it. Supports wildcards (e.g., '*.example.com').", {
+        domain: zod_1.z.string().describe("Domain to allow (e.g., 'api.stripe.com' or '*.googleapis.com')"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ domain }) {
+        try {
+            const result = yield sdk.allowedDomains.add({ domain });
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `adding allowed domain '${domain}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("remove_allowed_domain", "Remove a domain from the allowlist. Compute functions will no longer be able to call this domain.", {
+        domainId: zod_1.z.string().describe("The allowed domain ID (UUID) to remove"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ domainId }) {
+        try {
+            yield sdk.allowedDomains.remove(domainId);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Allowed domain '${domainId}' removed successfully.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `removing allowed domain '${domainId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
 }

package/dist/tools/describe.js

@@ -62,7 +62,7 @@ function registerDescribeTools(server) {
                                 tools: ["search_records"],
                             },
                             compute: {
-                                summary: "Server-side JavaScript functions with triggers (on-demand, event-driven, scheduled, webhook).",
+                                summary: "Server-side JavaScript functions with triggers (on-demand, event-driven, scheduled, http-trigger) and domain allowlisting for external API calls.",
                                 describeWith: "describe_compute",
                                 tools: [
                                     "list_functions",
@@ -79,6 +79,9 @@ function registerDescribeTools(server) {
                                     "invoke_trigger",
                                     "pause_trigger",
                                     "resume_trigger",
+                                    "list_allowed_domains",
+                                    "add_allowed_domain",
+                                    "remove_allowed_domain",
                                 ],
                             },
                             smart_queries: {
@@ -211,8 +214,8 @@ function registerDescribeTools(server) {
                         },
                         crud_tools: {
                             create_collection: {
-                                description: "Create a new collection with name, slug, properties, and optional settings",
-                                required_params: ["name", "slug"],
+                                description: "Create a new collection with name, recordSlug, properties, and optional settings",
+                                required_params: ["name", "recordSlug"],
                                 optional_params: ["description", "properties", "enableVersioning", "schemaDiscoveryMode", "tags"],
                             },
                             update_collection: {
@@ -369,11 +372,14 @@ function registerDescribeTools(server) {
                         function_shape: {
                             id: "UUID",
                             name: "string — display name",
-                            slug: "string — unique identifier",
                             description: "string | null",
                             code: "string — the JavaScript source code",
-                            status: "'active' | 'inactive'",
-                            testPayload: "object | null — sample payload for testing",
+                            timeoutMs: "number | null — execution timeout in milliseconds (default: 30000, max: 300000)",
+                            workspaceSlug: "string",
+                            createdBy: "UUID",
+                            updatedBy: "UUID | null",
+                            createdAt: "ISO 8601 datetime",
+                            updatedAt: "ISO 8601 datetime",
                         },
                         trigger_types: {
                             "on-demand": {
@@ -398,18 +404,24 @@ function registerDescribeTools(server) {
                                 description: "Runs on a cron schedule (e.g., every hour, daily at midnight).",
                                 config: "Uses standard cron expression syntax (e.g., '0 * * * *' for hourly)",
                             },
-                            webhook: {
+                            "http-trigger": {
                                 description: "Triggered by an external HTTP POST to a generated webhook URL.",
-                                config: "Each webhook trigger gets a unique URL to share with external services",
+                                config: "Each http-trigger gets a unique URL to share with external services",
                             },
                         },
                         trigger_shape: {
                             id: "UUID",
                             name: "string",
+                            description: "string | null",
                             functionId: "UUID — the compute function to execute",
-                            executionType: "'on-demand' | 'event-driven' | 'scheduled' | 'webhook'",
-                            status: "'active' | 'paused'",
-                            config: "object — type-specific configuration (cron, event filters, etc.)",
+                            executionType: "'on-demand' | 'event-driven' | 'scheduled' | 'http-trigger'",
+                            triggerMetadata: "object — type-specific configuration (event, cron, params, etc.)",
+                            enabled: "boolean — whether the trigger is active (default: true)",
+                            workspaceSlug: "string",
+                            createdBy: "UUID",
+                            updatedBy: "UUID",
+                            createdAt: "ISO 8601 datetime",
+                            updatedAt: "ISO 8601 datetime",
                         },
                         function_crud: {
                             get_function: {
@@ -418,14 +430,14 @@ function registerDescribeTools(server) {
                             },
                             create_function: {
                                 description: "Create a new compute function",
-                                required_params: ["name", "slug", "code"],
-                                optional_params: ["description", "timeout"],
+                                required_params: ["name", "code"],
+                                optional_params: ["description", "timeoutMs"],
                                 code_format: "module.exports = async (ctx) => { /* your code */ return result; }",
                             },
                             update_function: {
                                 description: "Update an existing function. Partial updates supported.",
                                 required_params: ["functionId"],
-                                optional_params: ["name", "description", "code", "timeout"],
+                                optional_params: ["name", "description", "code", "timeoutMs"],
                             },
                             delete_function: {
                                 description: "Delete a compute function by ID",
@@ -434,7 +446,7 @@ function registerDescribeTools(server) {
                             test_function: {
                                 description: "Test execute code without saving. Returns output, duration, and logs.",
                                 required_params: ["code"],
-                                optional_params: ["input"],
+                                optional_params: ["params", "timeoutMs"],
                             },
                         },
                         trigger_crud: {
@@ -469,6 +481,30 @@ function registerDescribeTools(server) {
                                 required_params: ["triggerId"],
                             },
                         },
+                        allowed_domains: {
+                            description: "Workspace-level allowlist controlling which external domains compute functions can call via api.httpGet/httpPost/etc. Functions attempting to reach unlisted domains get an error.",
+                            domain_shape: {
+                                id: "UUID",
+                                domain: "string — the allowed domain (e.g., 'api.stripe.com' or '*.googleapis.com')",
+                                createdAt: "ISO 8601 datetime",
+                                createdBy: "UUID",
+                            },
+                            tools: {
+                                list_allowed_domains: {
+                                    description: "List all allowed domains in the workspace",
+                                },
+                                add_allowed_domain: {
+                                    description: "Add a domain to the allowlist",
+                                    required_params: ["domain"],
+                                },
+                                remove_allowed_domain: {
+                                    description: "Remove a domain from the allowlist by ID",
+                                    required_params: ["domainId"],
+                                },
+                            },
+                            wildcards: "Use '*.example.com' to allow all subdomains of example.com",
+                            note: "Functions can only make HTTP requests to domains on this list. Add domains before creating functions that call external APIs.",
+                        },
                         sandbox_api: {
                             description: "Functions receive an `api` object with built-in utilities. Key crypto methods:",
                             crypto: {
@@ -488,6 +524,7 @@ function registerDescribeTools(server) {
                             "Use test_function to validate code before creating or updating a function",
                             "Use create_function + create_trigger together to set up a complete compute pipeline",
                             "Use api.crypto.signJwt() for GitHub App, Google Cloud, or Azure AD authentication flows",
+                            "Before creating functions that call external APIs, add the target domains with add_allowed_domain",
                         ],
                     }, null, 2),
                 },

package/package.json

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

package/src/tools/compute.ts

@@ -61,10 +61,10 @@ export function registerComputeTools(server: McpServer, sdk: CentraliSDK) {
 
   server.tool(
     "list_triggers",
-    "List function triggers in the workspace. Triggers define how and when compute functions are executed (on-demand, event-driven, scheduled, webhook).",
+    "List function triggers in the workspace. Triggers define how and when compute functions are executed (on-demand, event-driven, scheduled, http-trigger).",
     {
       executionType: z
-        .enum(["on-demand", "event-driven", "scheduled", "webhook"])
+        .enum(["on-demand", "event-driven", "scheduled", "http-trigger"])
         .optional()
         .describe("Filter by trigger execution type"),
       page: z.number().optional().describe("Page number"),
@@ -174,16 +174,15 @@ export function registerComputeTools(server: McpServer, sdk: CentraliSDK) {
     "Create a new compute function. Compute functions are JavaScript code blocks that run server-side.",
     {
       name: z.string().describe("Display name for the function"),
-      slug: z.string().describe("URL-safe unique identifier (e.g., 'process-order')"),
       code: z.string().describe("JavaScript source code. Must export an async function: module.exports = async (ctx) => { ... }"),
       description: z.string().optional().describe("Optional description of what the function does"),
-      timeout: z.number().optional().describe("Execution timeout in milliseconds (default: 30000)"),
+      timeoutMs: z.number().optional().describe("Execution timeout in milliseconds (default: 30000, min: 1000, max: 300000)"),
     },
-    async ({ name, slug, code, description, timeout }) => {
+    async ({ name, code, description, timeoutMs }) => {
       try {
-        const input: Record<string, any> = { name, slug, code };
+        const input: Record<string, any> = { name, code };
         if (description !== undefined) input.description = description;
-        if (timeout !== undefined) input.timeout = timeout;
+        if (timeoutMs !== undefined) input.timeoutMs = timeoutMs;
 
         const result = await sdk.functions.create(input as any);
         return {
@@ -196,7 +195,7 @@ export function registerComputeTools(server: McpServer, sdk: CentraliSDK) {
           content: [
             {
               type: "text",
-              text: formatError(error, `creating function '${slug}'`),
+              text: formatError(error, `creating function '${name}'`),
             },
           ],
           isError: true,
@@ -213,15 +212,15 @@ export function registerComputeTools(server: McpServer, sdk: CentraliSDK) {
       name: z.string().optional().describe("Updated display name"),
       description: z.string().optional().describe("Updated description"),
       code: z.string().optional().describe("Updated JavaScript source code"),
-      timeout: z.number().optional().describe("Updated execution timeout in milliseconds"),
+      timeoutMs: z.number().optional().describe("Updated execution timeout in milliseconds (min: 1000, max: 300000)"),
     },
-    async ({ functionId, name, description, code, timeout }) => {
+    async ({ functionId, name, description, code, timeoutMs }) => {
       try {
         const input: Record<string, any> = {};
         if (name !== undefined) input.name = name;
         if (description !== undefined) input.description = description;
         if (code !== undefined) input.code = code;
-        if (timeout !== undefined) input.timeout = timeout;
+        if (timeoutMs !== undefined) input.timeoutMs = timeoutMs;
 
         const result = await sdk.functions.update(functionId, input as any);
         return {
@@ -279,15 +278,17 @@ export function registerComputeTools(server: McpServer, sdk: CentraliSDK) {
     "Test execute code without saving it as a function. Useful for validating function code before creating or updating.",
     {
       code: z.string().describe("JavaScript code to test. Must export an async function: module.exports = async (ctx) => { ... }"),
-      input: z
+      params: z
         .record(z.string(), z.any())
         .optional()
-        .describe("Optional input data passed to the function as ctx.input"),
+        .describe("Optional parameters passed to the function as executionParams"),
+      timeoutMs: z.number().optional().describe("Execution timeout in milliseconds (default: 30000, min: 1000, max: 300000)"),
     },
-    async ({ code, input }) => {
+    async ({ code, params, timeoutMs }) => {
       try {
         const testInput: Record<string, any> = { code };
-        if (input !== undefined) testInput.input = input;
+        if (params !== undefined) testInput.params = params;
+        if (timeoutMs !== undefined) testInput.timeoutMs = timeoutMs;
 
         const result = await sdk.functions.testExecute(testInput as any);
         return {
@@ -346,13 +347,13 @@ export function registerComputeTools(server: McpServer, sdk: CentraliSDK) {
       name: z.string().describe("Display name for the trigger"),
       functionId: z.string().describe("The compute function ID (UUID) to execute"),
       executionType: z
-        .enum(["on-demand", "event-driven", "scheduled", "webhook"])
-        .describe("How the trigger fires: on-demand (manual), event-driven (data events), scheduled (cron), or webhook (HTTP)"),
+        .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)"),
       description: z.string().optional().describe("Optional description"),
       triggerMetadata: z
         .record(z.string(), z.any())
         .optional()
-        .describe("Type-specific configuration. For event-driven: { event, recordSlug }. For scheduled: { scheduleType, cronExpression, timezone }. For webhook: auto-generated URL."),
+        .describe("Type-specific configuration. For event-driven: { event, recordSlug }. For scheduled: { scheduleType, cronExpression, timezone }. For http-trigger: auto-generated URL."),
       enabled: z.boolean().optional().describe("Whether the trigger is enabled (default: true)"),
     },
     async ({ name, functionId, executionType, description, triggerMetadata, enabled }) => {
@@ -509,4 +510,91 @@ export function registerComputeTools(server: McpServer, sdk: CentraliSDK) {
       }
     }
   );
+
+  // ── 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.",
+    {},
+    async () => {
+      try {
+        const result = await sdk.allowedDomains.list();
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, "listing allowed domains"),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "add_allowed_domain",
+    "Add a domain to the allowlist so compute functions can make HTTP requests to it. Supports wildcards (e.g., '*.example.com').",
+    {
+      domain: z.string().describe("Domain to allow (e.g., 'api.stripe.com' or '*.googleapis.com')"),
+    },
+    async ({ domain }) => {
+      try {
+        const result = await sdk.allowedDomains.add({ domain });
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `adding allowed domain '${domain}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "remove_allowed_domain",
+    "Remove a domain from the allowlist. Compute functions will no longer be able to call this domain.",
+    {
+      domainId: z.string().describe("The allowed domain ID (UUID) to remove"),
+    },
+    async ({ domainId }) => {
+      try {
+        await sdk.allowedDomains.remove(domainId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Allowed domain '${domainId}' removed successfully.`,
+            },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `removing allowed domain '${domainId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
 }

package/src/tools/describe.ts

@@ -62,7 +62,7 @@ export function registerDescribeTools(server: McpServer) {
                 },
                 compute: {
                   summary:
-                    "Server-side JavaScript functions with triggers (on-demand, event-driven, scheduled, webhook).",
+                    "Server-side JavaScript functions with triggers (on-demand, event-driven, scheduled, http-trigger) and domain allowlisting for external API calls.",
                   describeWith: "describe_compute",
                   tools: [
                     "list_functions",
@@ -79,6 +79,9 @@ export function registerDescribeTools(server: McpServer) {
                     "invoke_trigger",
                     "pause_trigger",
                     "resume_trigger",
+                    "list_allowed_domains",
+                    "add_allowed_domain",
+                    "remove_allowed_domain",
                   ],
                 },
                 smart_queries: {
@@ -239,8 +242,8 @@ export function registerDescribeTools(server: McpServer) {
               },
               crud_tools: {
                 create_collection: {
-                  description: "Create a new collection with name, slug, properties, and optional settings",
-                  required_params: ["name", "slug"],
+                  description: "Create a new collection with name, recordSlug, properties, and optional settings",
+                  required_params: ["name", "recordSlug"],
                   optional_params: ["description", "properties", "enableVersioning", "schemaDiscoveryMode", "tags"],
                 },
                 update_collection: {
@@ -434,11 +437,14 @@ export function registerDescribeTools(server: McpServer) {
               function_shape: {
                 id: "UUID",
                 name: "string — display name",
-                slug: "string — unique identifier",
                 description: "string | null",
                 code: "string — the JavaScript source code",
-                status: "'active' | 'inactive'",
-                testPayload: "object | null — sample payload for testing",
+                timeoutMs: "number | null — execution timeout in milliseconds (default: 30000, max: 300000)",
+                workspaceSlug: "string",
+                createdBy: "UUID",
+                updatedBy: "UUID | null",
+                createdAt: "ISO 8601 datetime",
+                updatedAt: "ISO 8601 datetime",
               },
               trigger_types: {
                 "on-demand": {
@@ -467,19 +473,25 @@ export function registerDescribeTools(server: McpServer) {
                     "Runs on a cron schedule (e.g., every hour, daily at midnight).",
                   config: "Uses standard cron expression syntax (e.g., '0 * * * *' for hourly)",
                 },
-                webhook: {
+                "http-trigger": {
                   description:
                     "Triggered by an external HTTP POST to a generated webhook URL.",
-                  config: "Each webhook trigger gets a unique URL to share with external services",
+                  config: "Each http-trigger gets a unique URL to share with external services",
                 },
               },
               trigger_shape: {
                 id: "UUID",
                 name: "string",
+                description: "string | null",
                 functionId: "UUID — the compute function to execute",
-                executionType: "'on-demand' | 'event-driven' | 'scheduled' | 'webhook'",
-                status: "'active' | 'paused'",
-                config: "object — type-specific configuration (cron, event filters, etc.)",
+                executionType: "'on-demand' | 'event-driven' | 'scheduled' | 'http-trigger'",
+                triggerMetadata: "object — type-specific configuration (event, cron, params, etc.)",
+                enabled: "boolean — whether the trigger is active (default: true)",
+                workspaceSlug: "string",
+                createdBy: "UUID",
+                updatedBy: "UUID",
+                createdAt: "ISO 8601 datetime",
+                updatedAt: "ISO 8601 datetime",
               },
               function_crud: {
                 get_function: {
@@ -488,14 +500,14 @@ export function registerDescribeTools(server: McpServer) {
                 },
                 create_function: {
                   description: "Create a new compute function",
-                  required_params: ["name", "slug", "code"],
-                  optional_params: ["description", "timeout"],
+                  required_params: ["name", "code"],
+                  optional_params: ["description", "timeoutMs"],
                   code_format: "module.exports = async (ctx) => { /* your code */ return result; }",
                 },
                 update_function: {
                   description: "Update an existing function. Partial updates supported.",
                   required_params: ["functionId"],
-                  optional_params: ["name", "description", "code", "timeout"],
+                  optional_params: ["name", "description", "code", "timeoutMs"],
                 },
                 delete_function: {
                   description: "Delete a compute function by ID",
@@ -504,7 +516,7 @@ export function registerDescribeTools(server: McpServer) {
                 test_function: {
                   description: "Test execute code without saving. Returns output, duration, and logs.",
                   required_params: ["code"],
-                  optional_params: ["input"],
+                  optional_params: ["params", "timeoutMs"],
                 },
               },
               trigger_crud: {
@@ -539,6 +551,30 @@ export function registerDescribeTools(server: McpServer) {
                   required_params: ["triggerId"],
                 },
               },
+              allowed_domains: {
+                description: "Workspace-level allowlist controlling which external domains compute functions can call via api.httpGet/httpPost/etc. Functions attempting to reach unlisted domains get an error.",
+                domain_shape: {
+                  id: "UUID",
+                  domain: "string — the allowed domain (e.g., 'api.stripe.com' or '*.googleapis.com')",
+                  createdAt: "ISO 8601 datetime",
+                  createdBy: "UUID",
+                },
+                tools: {
+                  list_allowed_domains: {
+                    description: "List all allowed domains in the workspace",
+                  },
+                  add_allowed_domain: {
+                    description: "Add a domain to the allowlist",
+                    required_params: ["domain"],
+                  },
+                  remove_allowed_domain: {
+                    description: "Remove a domain from the allowlist by ID",
+                    required_params: ["domainId"],
+                  },
+                },
+                wildcards: "Use '*.example.com' to allow all subdomains of example.com",
+                note: "Functions can only make HTTP requests to domains on this list. Add domains before creating functions that call external APIs.",
+              },
               sandbox_api: {
                 description: "Functions receive an `api` object with built-in utilities. Key crypto methods:",
                 crypto: {
@@ -558,6 +594,7 @@ export function registerDescribeTools(server: McpServer) {
                 "Use test_function to validate code before creating or updating a function",
                 "Use create_function + create_trigger together to set up a complete compute pipeline",
                 "Use api.crypto.signJwt() for GitHub App, Google Cloud, or Azure AD authentication flows",
+                "Before creating functions that call external APIs, add the target domains with add_allowed_domain",
               ],
             },
             null,