@centrali-io/centrali-mcp 1.0.0

package/README.md

@@ -0,0 +1,94 @@
+# @centrali-io/centrali-mcp
+
+MCP (Model Context Protocol) server for the Centrali platform. Lets AI assistants (Claude, Cursor, etc.) interact with Centrali workspaces — query data, manage records, search, trigger compute functions, and more.
+
+Built on `@centrali-io/centrali-sdk` v3.1.0. Authenticates via service account client credentials.
+
+## Setup
+
+Add to your MCP client configuration (e.g., Claude Desktop, Cursor):
+
+```json
+{
+  "mcpServers": {
+    "centrali": {
+      "command": "npx",
+      "args": ["@centrali-io/centrali-mcp"],
+      "env": {
+        "CENTRALI_URL": "https://dev.centrali.io",
+        "CENTRALI_CLIENT_ID": "<service-account-client-id>",
+        "CENTRALI_CLIENT_SECRET": "<service-account-secret>",
+        "CENTRALI_WORKSPACE": "my-workspace"
+      }
+    }
+  }
+}
+```
+
+### Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `CENTRALI_URL` | Yes | Centrali instance URL (e.g., `https://dev.centrali.io`) |
+| `CENTRALI_CLIENT_ID` | Yes | Service account client ID |
+| `CENTRALI_CLIENT_SECRET` | Yes | Service account client secret |
+| `CENTRALI_WORKSPACE` | Yes | Workspace slug to operate in |
+
+## Available Tools
+
+### Structures
+| Tool | Description |
+|------|-------------|
+| `list_structures` | List all data structures (schemas) in the workspace |
+| `get_structure` | Get full schema for a structure by record slug |
+
+### Records
+| Tool | Description |
+|------|-------------|
+| `query_records` | Query records with filters, sorting, pagination |
+| `get_record` | Get a single record by ID |
+| `create_record` | Create a new record |
+| `update_record` | Update an existing record |
+| `delete_record` | Soft or hard delete a record |
+
+### Search
+| Tool | Description |
+|------|-------------|
+| `search_records` | Full-text search across workspace records |
+
+### Compute
+| Tool | Description |
+|------|-------------|
+| `list_functions` | List compute functions |
+| `list_triggers` | List function triggers (on-demand, event-driven, scheduled, webhook) |
+| `invoke_trigger` | Invoke an on-demand trigger with optional payload |
+
+### Smart Queries
+| Tool | Description |
+|------|-------------|
+| `list_smart_queries` | List smart queries, optionally filtered by structure |
+| `execute_smart_query` | Execute a smart query with optional variables |
+
+## Resources
+
+| URI | Description |
+|-----|-------------|
+| `centrali://structures` | List of all structures with name, slug, description |
+| `centrali://structures/{slug}` | Full schema for a specific structure |
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Test with MCP inspector
+CENTRALI_URL=https://dev.centrali.io \
+CENTRALI_CLIENT_ID=... \
+CENTRALI_CLIENT_SECRET=... \
+CENTRALI_WORKSPACE=my-workspace \
+npx @modelcontextprotocol/inspector node dist/index.js
+```

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+"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 });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const centrali_sdk_1 = require("@centrali-io/centrali-sdk");
+const structures_js_1 = require("./tools/structures.js");
+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 structures_js_2 = require("./resources/structures.js");
+function getRequiredEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        console.error(`Missing required environment variable: ${name}`);
+        process.exit(1);
+    }
+    return value;
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const baseUrl = getRequiredEnv("CENTRALI_URL");
+        const clientId = getRequiredEnv("CENTRALI_CLIENT_ID");
+        const clientSecret = getRequiredEnv("CENTRALI_CLIENT_SECRET");
+        const workspaceId = getRequiredEnv("CENTRALI_WORKSPACE");
+        const sdk = new centrali_sdk_1.CentraliSDK({
+            baseUrl,
+            workspaceId,
+            clientId,
+            clientSecret,
+        });
+        const server = new mcp_js_1.McpServer({
+            name: "centrali",
+            version: "1.0.0",
+        });
+        // Register all tools
+        (0, structures_js_1.registerStructureTools)(server, sdk);
+        (0, records_js_1.registerRecordTools)(server, sdk);
+        (0, search_js_1.registerSearchTools)(server, sdk);
+        (0, compute_js_1.registerComputeTools)(server, sdk);
+        (0, smart_queries_js_1.registerSmartQueryTools)(server, sdk);
+        // Register resources
+        (0, structures_js_2.registerStructureResources)(server, sdk);
+        // Start stdio transport
+        const transport = new stdio_js_1.StdioServerTransport();
+        yield server.connect(transport);
+    });
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/resources/structures.d.ts

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

package/dist/resources/structures.js

@@ -0,0 +1,69 @@
+"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.registerStructureResources = registerStructureResources;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+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,
+            });
+        });
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(summary, null, 2),
+                },
+            ],
+        };
+    }));
+    // 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",
+                })),
+            };
+        }),
+    }), {
+        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),
+                },
+            ],
+        };
+    }));
+}

package/dist/tools/compute.d.ts

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

package/dist/tools/compute.js

@@ -0,0 +1,110 @@
+"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.registerComputeTools = registerComputeTools;
+const zod_1 = require("zod");
+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"),
+        limit: zod_1.z.number().optional().describe("Results per page"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ page, limit }) {
+        try {
+            const options = {};
+            if (page !== undefined)
+                options.page = page;
+            if (limit !== undefined)
+                options.limit = limit;
+            const result = yield sdk.functions.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: `Error listing functions: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    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).", {
+        executionType: zod_1.z
+            .enum(["on-demand", "event-driven", "scheduled", "webhook"])
+            .optional()
+            .describe("Filter by trigger execution type"),
+        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* ({ executionType, page, limit }) {
+        try {
+            const options = {};
+            if (executionType)
+                options.executionType = executionType;
+            if (page !== undefined)
+                options.page = page;
+            if (limit !== undefined)
+                options.limit = limit;
+            const result = yield sdk.triggers.listAll(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: `Error listing triggers: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("invoke_trigger", "Invoke an on-demand function trigger by ID. Optionally pass a custom payload. Returns the queued job ID.", {
+        triggerId: zod_1.z.string().describe("The trigger ID (UUID) to invoke"),
+        payload: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .optional()
+            .describe("Custom payload to pass to the function execution"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ triggerId, payload }) {
+        try {
+            const options = payload ? { payload } : undefined;
+            const result = yield sdk.triggers.invoke(triggerId, options);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ jobId: result.data, message: "Trigger invoked successfully" }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error invoking trigger '${triggerId}': ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+}

package/dist/tools/records.d.ts

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

package/dist/tools/records.js

@@ -0,0 +1,180 @@
+"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.registerRecordTools = registerRecordTools;
+const zod_1 = require("zod");
+function registerRecordTools(server, sdk) {
+    server.tool("query_records", "Query records from a structure with optional filters, sorting, and pagination. Filters use 'data.' prefix for custom fields and bracket notation for operators (e.g., 'data.status': 'active', 'data.price[lte]': 100).", {
+        recordSlug: zod_1.z
+            .string()
+            .describe("The structure's record slug (e.g., 'orders')"),
+        filters: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .optional()
+            .describe("Filter object with keys like 'data.fieldName' or 'data.fieldName[operator]'. Operators: eq, ne, gt, gte, lt, lte, in, nin, contains, startswith, endswith"),
+        sort: zod_1.z
+            .string()
+            .optional()
+            .describe("Sort field with optional '-' prefix for descending (e.g., '-createdAt')"),
+        page: zod_1.z.number().optional().describe("Page number (1-indexed, default: 1)"),
+        pageSize: zod_1.z
+            .number()
+            .optional()
+            .describe("Records per page (default: 50, max: 500)"),
+        expand: zod_1.z
+            .string()
+            .optional()
+            .describe("Comma-separated reference fields to expand (e.g., 'customer,product')"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, filters, sort, page, pageSize, expand }) {
+        try {
+            const params = Object.assign(Object.assign({}, filters), { sort,
+                page,
+                pageSize,
+                expand });
+            // Remove undefined values
+            Object.keys(params).forEach((key) => params[key] === undefined && delete params[key]);
+            const result = yield sdk.queryRecords(recordSlug, params);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error querying records from '${recordSlug}': ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("get_record", "Get a single record by its ID from a structure. Optionally expand reference fields.", {
+        recordSlug: zod_1.z.string().describe("The structure's record slug"),
+        id: zod_1.z.string().describe("The record ID (UUID)"),
+        expand: zod_1.z
+            .string()
+            .optional()
+            .describe("Comma-separated reference fields to expand"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, id, expand }) {
+        try {
+            const options = expand ? { expand } : undefined;
+            const result = yield sdk.getRecord(recordSlug, id, options);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error getting record '${id}' from '${recordSlug}': ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("create_record", "Create a new record in a structure. Pass the record data as a JSON object with field names matching the structure's properties.", {
+        recordSlug: zod_1.z
+            .string()
+            .describe("The structure's record slug (e.g., 'orders')"),
+        data: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .describe("The record data object (field names as keys)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, data }) {
+        try {
+            const result = yield sdk.createRecord(recordSlug, data);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error creating record in '${recordSlug}': ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("update_record", "Update an existing record by ID. Only include the fields you want to change.", {
+        recordSlug: zod_1.z.string().describe("The structure's record slug"),
+        id: zod_1.z.string().describe("The record ID (UUID) to update"),
+        data: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .describe("Object with fields to update (partial update)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, id, data }) {
+        try {
+            const result = yield sdk.updateRecord(recordSlug, id, data);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error updating record '${id}' in '${recordSlug}': ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("delete_record", "Delete a record by ID. Performs a soft delete by default (can be restored). Set hard=true for permanent deletion.", {
+        recordSlug: zod_1.z.string().describe("The structure's record slug"),
+        id: zod_1.z.string().describe("The record ID (UUID) to delete"),
+        hard: zod_1.z
+            .boolean()
+            .optional()
+            .describe("If true, permanently delete. Default: false (soft delete, can be restored)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, id, hard }) {
+        try {
+            const options = hard !== undefined ? { hard } : undefined;
+            yield sdk.deleteRecord(recordSlug, id, options);
+            const deleteType = hard ? "permanently deleted" : "soft-deleted";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Record '${id}' ${deleteType} from '${recordSlug}'.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error deleting record '${id}' from '${recordSlug}': ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+}

package/dist/tools/search.d.ts

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

package/dist/tools/search.js

@@ -0,0 +1,51 @@
+"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.registerSearchTools = registerSearchTools;
+const zod_1 = require("zod");
+function registerSearchTools(server, sdk) {
+    server.tool("search_records", "Full-text search across records in the workspace. Powered by Meilisearch. Optionally filter by structure(s) and limit results.", {
+        query: zod_1.z.string().describe("The search query string"),
+        structures: zod_1.z
+            .union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())])
+            .optional()
+            .describe("Filter by structure slug(s). Single slug string or array of slugs"),
+        limit: zod_1.z
+            .number()
+            .optional()
+            .describe("Maximum results to return (default: 20, max: 100)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ query, structures, limit }) {
+        try {
+            const options = {};
+            if (structures)
+                options.structures = structures;
+            if (limit)
+                options.limit = limit;
+            const result = yield sdk.search(query, 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: `Error searching records: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+}

package/dist/tools/smart-queries.d.ts

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

package/dist/tools/smart-queries.js

@@ -0,0 +1,74 @@
+"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.registerSmartQueryTools = registerSmartQueryTools;
+const zod_1 = require("zod");
+function registerSmartQueryTools(server, sdk) {
+    server.tool("list_smart_queries", "List smart queries. Smart queries are reusable, parameterized queries defined in the Centrali console. Optionally filter by structure slug.", {
+        recordSlug: zod_1.z
+            .string()
+            .optional()
+            .describe("Filter by structure slug. If omitted, lists all smart queries in the workspace"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug }) {
+        try {
+            const result = recordSlug
+                ? yield sdk.smartQueries.list(recordSlug)
+                : yield sdk.smartQueries.listAll();
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error listing smart queries: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("execute_smart_query", "Execute a smart query by ID and return the results. Smart queries can have parameterized variables using {{variableName}} syntax.", {
+        recordSlug: zod_1.z
+            .string()
+            .describe("The structure's record slug the query belongs to"),
+        queryId: zod_1.z.string().describe("The smart query ID (UUID) to execute"),
+        variables: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.string())
+            .optional()
+            .describe("Variables to substitute in the query (key-value pairs matching {{variableName}} placeholders)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, queryId, variables }) {
+        try {
+            const options = variables ? { variables } : undefined;
+            const result = yield sdk.smartQueries.execute(recordSlug, queryId, options);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error executing smart query '${queryId}': ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+}