@centrali-io/centrali-mcp 4.2.1 → 4.2.3

package/src/tools/describe.ts

@@ -32,6 +32,9 @@ export function registerDescribeTools(server: McpServer) {
                   tools: [
                     "list_collections",
                     "get_collection",
+                    "create_collection",
+                    "update_collection",
+                    "delete_collection",
                     "list_structures (deprecated)",
                     "get_structure (deprecated)",
                   ],
@@ -61,13 +64,36 @@ export function registerDescribeTools(server: McpServer) {
                   summary:
                     "Server-side JavaScript functions with triggers (on-demand, event-driven, scheduled, webhook).",
                   describeWith: "describe_compute",
-                  tools: ["list_functions", "list_triggers", "invoke_trigger"],
+                  tools: [
+                    "list_functions",
+                    "get_function",
+                    "create_function",
+                    "update_function",
+                    "delete_function",
+                    "test_function",
+                    "list_triggers",
+                    "get_trigger",
+                    "create_trigger",
+                    "update_trigger",
+                    "delete_trigger",
+                    "invoke_trigger",
+                    "pause_trigger",
+                    "resume_trigger",
+                  ],
                 },
                 smart_queries: {
                   summary:
                     "Reusable, parameterized queries defined in the console. Support {{variable}} substitution.",
                   describeWith: "describe_smart_queries",
-                  tools: ["list_smart_queries", "execute_smart_query"],
+                  tools: [
+                    "list_smart_queries",
+                    "get_smart_query",
+                    "create_smart_query",
+                    "update_smart_query",
+                    "delete_smart_query",
+                    "execute_smart_query",
+                    "test_smart_query",
+                  ],
                 },
                 orchestrations: {
                   summary:
@@ -76,6 +102,11 @@ export function registerDescribeTools(server: McpServer) {
                   tools: [
                     "list_orchestrations",
                     "get_orchestration",
+                    "create_orchestration",
+                    "update_orchestration",
+                    "delete_orchestration",
+                    "activate_orchestration",
+                    "pause_orchestration",
                     "trigger_orchestration",
                     "list_orchestration_runs",
                     "get_orchestration_run",
@@ -170,38 +201,70 @@ export function registerDescribeTools(server: McpServer) {
               },
               property_shape: {
                 name: "string — field name (e.g., 'email', 'totalAmount')",
-                type: "string — the field data type (see field_types below)",
+                type: "string — one of: string, number, boolean, datetime, array, object, reference",
+                description: "string | null — optional human-readable description",
                 required: "boolean — whether the field is mandatory",
-                unique: "boolean — whether values must be unique across records",
-                defaultValue: "any | null — default value for new records",
-                description: "string | null — field description",
-                config:
-                  "object | null — type-specific configuration (e.g., min/max for numbers, options for select)",
+                nullable: "boolean — whether the field accepts null values",
+                isUnique: "boolean — whether values must be unique across records",
+                immutable: "boolean — field cannot be changed after creation",
+                default: "any | null — default value for new records",
+                enum: "any[] | null — restrict to specific allowed values",
               },
               field_types: {
-                text: "Short text string",
-                long_text: "Multi-line text / rich text",
-                number: "Numeric value (integer or decimal). Config: { min, max, precision }",
-                boolean: "True/false toggle",
-                date: "Date value (ISO 8601)",
-                datetime: "Date and time value (ISO 8601 with time)",
-                email: "Email address (validated format)",
-                url: "URL (validated format)",
-                select:
-                  "Single choice from predefined options. Config: { options: [{ label, value }] }",
-                multi_select:
-                  "Multiple choices from predefined options. Config: { options: [{ label, value }] }",
+                string:
+                  "Text field. Options: minLength, maxLength, pattern (regex), renderAs ('textarea'|'secret'|'color'|'code'|'html'|'markdown'), enum (string[]), not (disallowed values), isSecret (boolean). Use enum for select-like behavior.",
+                number:
+                  "Numeric field (integer or decimal). Options: minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, enum (number[]), autoIncrement ({ startAt, incrementBy? }).",
+                boolean: "True/false toggle. Options: default (boolean), enum ([true]|[false]).",
+                datetime:
+                  "ISO 8601 date/time field. Options: earliestDate, latestDate, exclusiveEarliest, exclusiveLatest, default (ISO string), enum (ISO string[]).",
+                array:
+                  "Array of typed items. Required: items: { type: 'string'|'number'|'boolean'|'datetime'|'object' }. Options: minItems, maxItems, uniqueItems, itemSchema (PropertyDefinition[] when items.type='object').",
+                object:
+                  "Nested object. Options: properties (PropertyDefinition[]), requiredProperties (string[]), strictProperties (boolean — reject unknown fields).",
+                reference:
+                  "Foreign key to another collection. Required: target (collection recordSlug), relationship ('many-to-one'|'one-to-one'|'many-to-many'), onDelete ('restrict'|'cascade'|'set_null'). Options: targetField (default: 'id'), displayField, nullable (required if onDelete='set_null').",
+              },
+              examples: {
+                string_with_enum:
+                  '{ "name": "status", "type": "string", "required": true, "enum": ["active", "inactive", "archived"] }',
+                number_with_range:
+                  '{ "name": "price", "type": "number", "minimum": 0, "maximum": 10000 }',
                 reference:
-                  "Foreign key to another collection. Config: { referenceSlug: 'other-collection-slug' }",
-                file: "File attachment (stored in Azure Blob Storage)",
-                json: "Arbitrary JSON object",
-                auto_increment: "Auto-incrementing integer (read-only)",
+                  '{ "name": "categoryId", "type": "reference", "target": "categories", "relationship": "many-to-one", "onDelete": "restrict" }',
+                array_of_strings:
+                  '{ "name": "tags", "type": "array", "items": { "type": "string" } }',
+                nested_object:
+                  '{ "name": "address", "type": "object", "properties": [{ "name": "street", "type": "string" }, { "name": "city", "type": "string" }] }',
+              },
+              crud_tools: {
+                create_collection: {
+                  description: "Create a new collection with name, slug, properties, and optional settings",
+                  required_params: ["name", "slug"],
+                  optional_params: ["description", "properties", "enableVersioning", "schemaDiscoveryMode", "tags"],
+                },
+                update_collection: {
+                  description: "Update an existing collection by ID. Partial updates supported.",
+                  required_params: ["collectionId"],
+                  optional_params: ["name", "description", "properties", "enableVersioning", "tags", "defaultTtlSeconds"],
+                },
+                delete_collection: {
+                  description: "Delete a collection by ID. Permanently removes the schema and all records.",
+                  required_params: ["collectionId"],
+                },
               },
               tips: [
                 "Use list_collections to see all collections in the workspace",
                 "Use get_collection with a recordSlug to see the full property definitions",
                 "The recordSlug is what you use in query_records, create_record, etc.",
                 "Reference fields create relationships between collections — use 'expand' parameter in queries to join them",
+                "Use create_collection to define new data schemas with typed properties",
+                "Properties array defines the fields — each needs at minimum a name and type",
+                "Use schemaDiscoveryMode: 'flexible' to auto-add new fields when records are created",
+                "For enum/select behavior, use type 'string' with an 'enum' array — there is no 'select' type",
+                "For multi-line text, use type 'string' with renderAs: 'textarea'",
+                "For JSON blobs, use type 'object' with strictProperties: false",
+                "Property options go at the top level of the property object, NOT nested inside a 'config' key",
               ],
             },
             null,
@@ -418,12 +481,72 @@ export function registerDescribeTools(server: McpServer) {
                 status: "'active' | 'paused'",
                 config: "object — type-specific configuration (cron, event filters, etc.)",
               },
+              function_crud: {
+                get_function: {
+                  description: "Get a compute function by ID, including its code",
+                  required_params: ["functionId"],
+                },
+                create_function: {
+                  description: "Create a new compute function",
+                  required_params: ["name", "slug", "code"],
+                  optional_params: ["description", "timeout"],
+                  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"],
+                },
+                delete_function: {
+                  description: "Delete a compute function by ID",
+                  required_params: ["functionId"],
+                },
+                test_function: {
+                  description: "Test execute code without saving. Returns output, duration, and logs.",
+                  required_params: ["code"],
+                  optional_params: ["input"],
+                },
+              },
+              trigger_crud: {
+                get_trigger: {
+                  description: "Get any trigger by ID (all execution types)",
+                  required_params: ["triggerId"],
+                },
+                create_trigger: {
+                  description: "Create a new function trigger",
+                  required_params: ["name", "functionId", "executionType"],
+                  optional_params: ["description", "triggerMetadata", "enabled"],
+                  triggerMetadata_examples: {
+                    "event-driven": { event: "record.created", recordSlug: "orders" },
+                    scheduled: { scheduleType: "cron", cronExpression: "0 9 * * *", timezone: "America/New_York" },
+                  },
+                },
+                update_trigger: {
+                  description: "Update an existing trigger. Partial updates supported.",
+                  required_params: ["triggerId"],
+                  optional_params: ["name", "description", "enabled", "triggerMetadata"],
+                },
+                delete_trigger: {
+                  description: "Delete a trigger by ID",
+                  required_params: ["triggerId"],
+                },
+                pause_trigger: {
+                  description: "Pause a trigger to temporarily disable it",
+                  required_params: ["triggerId"],
+                },
+                resume_trigger: {
+                  description: "Resume a paused trigger",
+                  required_params: ["triggerId"],
+                },
+              },
               tips: [
                 "Use list_functions to see all available functions",
                 "Use list_triggers to see how functions are wired to execution events",
                 "Only on-demand triggers can be invoked via invoke_trigger — other types fire automatically",
                 "Functions receive the trigger payload in their execution context",
-                "Triggers can be paused (status: 'paused') without deleting them",
+                "Use pause_trigger/resume_trigger to temporarily disable triggers without deleting them",
+                "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",
               ],
             },
             null,
@@ -474,11 +597,43 @@ export function registerDescribeTools(server: McpServer) {
                 },
                 note: "Variable values are always passed as strings — the query engine handles type coercion",
               },
+              crud_tools: {
+                get_smart_query: {
+                  description: "Get a smart query by ID, including its full definition",
+                  required_params: ["recordSlug", "queryId"],
+                },
+                create_smart_query: {
+                  description: "Create a new smart query for a collection",
+                  required_params: ["recordSlug", "name", "queryDefinition"],
+                  optional_params: ["description"],
+                  queryDefinition_example: {
+                    where: { status: { "$eq": "active" } },
+                    sort: [{ field: "createdAt", direction: "desc" }],
+                    limit: 100,
+                  },
+                },
+                update_smart_query: {
+                  description: "Update an existing smart query. Partial updates supported.",
+                  required_params: ["recordSlug", "queryId"],
+                  optional_params: ["name", "description", "queryDefinition"],
+                },
+                delete_smart_query: {
+                  description: "Delete a smart query by ID",
+                  required_params: ["recordSlug", "queryId"],
+                },
+                test_smart_query: {
+                  description: "Test execute a query definition without saving it. Preview results before creating.",
+                  required_params: ["recordSlug", "queryDefinition"],
+                  optional_params: ["variables"],
+                },
+              },
               tips: [
                 "Use list_smart_queries to discover available queries (optionally filter by collection slug)",
                 "Smart queries return the same result shape as query_records",
                 "Variables are defined when creating the query in the console — check the query's variables array to see what's expected",
                 "Prefer smart queries over ad-hoc query_records filters for complex/reusable logic",
+                "Use test_smart_query to validate query syntax and preview results before saving",
+                "Use create_smart_query to save reusable queries that can be executed with execute_smart_query",
               ],
             },
             null,
@@ -541,8 +696,42 @@ export function registerDescribeTools(server: McpServer) {
                 startedAt: "ISO 8601 datetime | null",
                 completedAt: "ISO 8601 datetime | null",
               },
+              crud_tools: {
+                create_orchestration: {
+                  description: "Create a new orchestration workflow",
+                  required_params: ["slug", "name", "trigger", "steps"],
+                  optional_params: ["description"],
+                  trigger_example: { type: "on-demand" },
+                  step_example: {
+                    id: "validate",
+                    type: "compute",
+                    functionId: "func-uuid",
+                    onSuccess: { nextStepId: "process" },
+                  },
+                },
+                update_orchestration: {
+                  description: "Update an existing orchestration. Partial updates supported.",
+                  required_params: ["orchestrationId"],
+                  optional_params: ["name", "description", "status", "trigger", "steps"],
+                },
+                delete_orchestration: {
+                  description: "Delete an orchestration and all its runs",
+                  required_params: ["orchestrationId"],
+                },
+                activate_orchestration: {
+                  description: "Set orchestration status to 'active' so it can be triggered",
+                  required_params: ["orchestrationId"],
+                },
+                pause_orchestration: {
+                  description: "Set orchestration status to 'paused' to prevent triggering",
+                  required_params: ["orchestrationId"],
+                },
+              },
               tips: [
                 "Use list_orchestrations to see available workflows",
+                "Use create_orchestration to define new multi-step workflows",
+                "Use activate_orchestration to enable a draft orchestration for triggering",
+                "Use pause_orchestration to temporarily disable an orchestration without deleting it",
                 "Use trigger_orchestration with an input object to start a run",
                 "Use get_orchestration_run with includeSteps=true to see step-by-step execution details",
                 "Orchestrations must be 'active' to be triggered — draft orchestrations cannot run",

package/src/tools/orchestrations.ts

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

package/src/tools/smart-queries.ts

@@ -100,4 +100,179 @@ export function registerSmartQueryTools(server: McpServer, sdk: CentraliSDK) {
       }
     }
   );
+
+  server.tool(
+    "get_smart_query",
+    "Get a smart query by ID. Returns the full query definition including filters, sort, and variable declarations.",
+    {
+      recordSlug: z.string().describe("The structure's record slug the query belongs to"),
+      queryId: z.string().describe("The smart query ID (UUID)"),
+    },
+    async ({ recordSlug, queryId }) => {
+      try {
+        const result = await sdk.smartQueries.get(recordSlug, queryId);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        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: z.string().describe("The structure's record slug to create the query for"),
+      name: z.string().describe("Display name for the smart query"),
+      description: z.string().optional().describe("Optional description"),
+      queryDefinition: z
+        .record(z.string(), z.any())
+        .describe("The query definition object with where, sort, limit, select, join, etc."),
+    },
+    async ({ recordSlug, name, description, queryDefinition }) => {
+      try {
+        const input: Record<string, any> = { name, queryDefinition };
+        if (description !== undefined) input.description = description;
+
+        const result = await sdk.smartQueries.create(recordSlug, input as any);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `creating 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: z.string().describe("The structure's record slug the query belongs to"),
+      queryId: z.string().describe("The smart query ID (UUID) to update"),
+      name: z.string().optional().describe("Updated display name"),
+      description: z.string().optional().describe("Updated description"),
+      queryDefinition: z
+        .record(z.string(), z.any())
+        .optional()
+        .describe("Updated query definition object"),
+    },
+    async ({ recordSlug, queryId, name, description, queryDefinition }) => {
+      try {
+        const input: Record<string, any> = {};
+        if (name !== undefined) input.name = name;
+        if (description !== undefined) input.description = description;
+        if (queryDefinition !== undefined) input.queryDefinition = queryDefinition;
+
+        const result = await sdk.smartQueries.update(recordSlug, queryId, input as any);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `updating smart query '${queryId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "delete_smart_query",
+    "Delete a smart query by ID.",
+    {
+      recordSlug: z.string().describe("The structure's record slug the query belongs to"),
+      queryId: z.string().describe("The smart query ID (UUID) to delete"),
+    },
+    async ({ recordSlug, queryId }) => {
+      try {
+        await sdk.smartQueries.delete(recordSlug, queryId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Smart query '${queryId}' deleted from '${recordSlug}'.`,
+            },
+          ],
+        };
+      } catch (error: unknown) {
+        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: z.string().describe("The structure's record slug to test against"),
+      queryDefinition: z
+        .record(z.string(), z.any())
+        .describe("The query definition to test (where, sort, limit, select, etc.)"),
+      variables: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe("Optional variables to substitute in the query"),
+    },
+    async ({ recordSlug, queryDefinition, variables }) => {
+      try {
+        const input: Record<string, any> = { queryDefinition };
+        if (variables !== undefined) input.variables = variables;
+
+        const result = await sdk.smartQueries.test(recordSlug, input as any);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `test-executing smart query for '${recordSlug}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
 }