@centrali-io/centrali-mcp 4.2.0 → 4.2.2

package/dist/tools/orchestrations.js

@@ -179,4 +179,150 @@ function registerOrchestrationTools(server, sdk) {
             };
         }
     }));
+    server.tool("create_orchestration", "Create a new orchestration workflow. Orchestrations chain compute functions together in multi-step workflows.", {
+        slug: zod_1.z.string().describe("URL-friendly unique slug (e.g., 'order-processing')"),
+        name: zod_1.z.string().describe("Human-readable name"),
+        description: zod_1.z.string().optional().describe("Optional description of the workflow"),
+        trigger: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .describe("Trigger configuration object. Must include 'type' (on-demand, event-driven, scheduled, webhook)"),
+        steps: zod_1.z
+            .array(zod_1.z.record(zod_1.z.string(), zod_1.z.any()))
+            .describe("Array of step definitions. Each step has id, type, functionId, and optional onSuccess/onFailure routing"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ slug, name, description, trigger, steps }) {
+        try {
+            const input = { slug, name, trigger, steps };
+            if (description !== undefined)
+                input.description = description;
+            const result = yield sdk.orchestrations.create(input);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            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: zod_1.z.string().describe("The orchestration ID (UUID) to update"),
+        name: zod_1.z.string().optional().describe("Updated name"),
+        description: zod_1.z.string().optional().describe("Updated description"),
+        status: zod_1.z
+            .enum(["draft", "active", "paused"])
+            .optional()
+            .describe("Updated status"),
+        trigger: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .optional()
+            .describe("Updated trigger configuration"),
+        steps: zod_1.z
+            .array(zod_1.z.record(zod_1.z.string(), zod_1.z.any()))
+            .optional()
+            .describe("Updated step definitions"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ orchestrationId, name, description, status, trigger, steps }) {
+        try {
+            const input = {};
+            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 = yield sdk.orchestrations.update(orchestrationId, input);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            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: zod_1.z.string().describe("The orchestration ID (UUID) to delete"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ orchestrationId }) {
+        try {
+            yield sdk.orchestrations.delete(orchestrationId);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Orchestration '${orchestrationId}' deleted successfully.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            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: zod_1.z.string().describe("The orchestration ID (UUID) to activate"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ orchestrationId }) {
+        try {
+            const result = yield sdk.orchestrations.activate(orchestrationId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            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: zod_1.z.string().describe("The orchestration ID (UUID) to pause"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ orchestrationId }) {
+        try {
+            const result = yield sdk.orchestrations.pause(orchestrationId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `pausing orchestration '${orchestrationId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
 }

package/dist/tools/pages.d.ts

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

package/dist/tools/pages.js

@@ -0,0 +1,477 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPageTools = registerPageTools;
+const zod_1 = require("zod");
+const axios_1 = __importDefault(require("axios"));
+function formatError(error, context) {
+    var _a, _b, _c;
+    if (axios_1.default.isAxiosError(error) && ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data)) {
+        const body = error.response.data;
+        const status = error.response.status;
+        const message = body.message || body.error || error.message;
+        return `Error ${context}: [${status}] ${message}`;
+    }
+    if (error && typeof error === "object") {
+        const e = error;
+        if ("message" in e) {
+            let msg = `Error ${context}`;
+            if ("code" in e || "status" in e) {
+                msg += `: [${(_c = (_b = e.code) !== null && _b !== void 0 ? _b : e.status) !== null && _c !== void 0 ? _c : "ERROR"}] ${e.message}`;
+            }
+            else {
+                msg += `: ${e.message}`;
+            }
+            return msg;
+        }
+    }
+    return `Error ${context}: ${error instanceof Error ? error.message : String(error)}`;
+}
+/**
+ * Derives the pages API base URL from the CENTRALI_URL.
+ * Pattern: https://centrali.io -> https://api.centrali.io/pages
+ * Or uses CENTRALI_PAGES_URL env var if explicitly set.
+ */
+function getPagesBaseUrl(centraliUrl) {
+    const override = process.env.CENTRALI_PAGES_URL;
+    if (override)
+        return override.replace(/\/$/, "");
+    const url = new URL(centraliUrl);
+    const hostname = url.hostname.startsWith("api.")
+        ? url.hostname
+        : `api.${url.hostname}`;
+    return `${url.protocol}//${hostname}/pages`;
+}
+/**
+ * Creates an axios instance for the pages API that uses the SDK's token.
+ */
+function createPagesClient(sdk, centraliUrl, workspaceId) {
+    const baseURL = getPagesBaseUrl(centraliUrl);
+    const client = axios_1.default.create({ baseURL });
+    // Attach the SDK's bearer token to every request
+    client.interceptors.request.use((config) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        const token = (_c = (_b = (_a = sdk).getToken) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : sdk.token;
+        if (!token) {
+            // Force the SDK to fetch a token by calling getTokenOrFetch
+            const freshToken = yield ((_e = (_d = sdk).getTokenOrFetch) === null || _e === void 0 ? void 0 : _e.call(_d));
+            if (freshToken) {
+                config.headers.Authorization = `Bearer ${freshToken}`;
+            }
+        }
+        else {
+            config.headers.Authorization = `Bearer ${token}`;
+        }
+        return config;
+    }));
+    return { client, workspaceId };
+}
+function registerPageTools(server, sdk, centraliUrl, workspaceId) {
+    const { client } = createPagesClient(sdk, centraliUrl, workspaceId);
+    const basePath = `/ws/${workspaceId}/api/v1/pages`;
+    // ── Page CRUD ──────────────────────────────────────────────────────
+    server.tool("list_pages", "List all pages in the workspace. Pages are pre-built UI views (lists, detail views, forms, dashboards) that surface data from structures.", {
+        page: zod_1.z.number().optional().describe("Page number (1-indexed, default: 1)"),
+        pageSize: zod_1.z.number().optional().describe("Items per page (default: 20)"),
+        pageType: zod_1.z
+            .enum(["list", "detail", "form", "dashboard"])
+            .optional()
+            .describe("Filter by page type"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ page, pageSize, pageType }) {
+        try {
+            const params = {};
+            if (page !== undefined)
+                params.page = page;
+            if (pageSize !== undefined)
+                params.pageSize = pageSize;
+            if (pageType)
+                params.pageType = pageType;
+            const resp = yield client.get(basePath, { params });
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, "listing pages") }],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("get_page", "Get a page by its ID. Returns the page metadata including name, slug, type, and description.", {
+        pageId: zod_1.z.string().describe("The page ID (UUID)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ pageId }) {
+        try {
+            const resp = yield client.get(`${basePath}/${pageId}`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, `getting page '${pageId}'`) }],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("create_page", "Create a new page in the workspace. A page is a UI view backed by data from structures. Specify the page type: 'list' for data tables, 'detail' for single-record views, 'form' for data entry, 'dashboard' for metrics and charts.", {
+        name: zod_1.z.string().describe("Display name for the page (e.g., 'Customer List')"),
+        slug: zod_1.z.string().describe("URL-safe slug (e.g., 'customer-list')"),
+        pageType: zod_1.z
+            .enum(["list", "detail", "form", "dashboard"])
+            .describe("The type of page to create"),
+        description: zod_1.z.string().optional().describe("Optional description of the page's purpose"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ name, slug, pageType, description }) {
+        try {
+            const resp = yield client.post(basePath, { name, slug, pageType, description });
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, "creating page") }],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("update_page", "Update a page's metadata (name, slug, description). Does not modify the page definition — use save_page_draft for that.", {
+        pageId: zod_1.z.string().describe("The page ID (UUID) to update"),
+        name: zod_1.z.string().optional().describe("New display name"),
+        slug: zod_1.z.string().optional().describe("New URL slug"),
+        description: zod_1.z.string().optional().describe("New description"),
+        showInNavShell: zod_1.z.boolean().optional().describe("Whether to show this page in the navigation shell"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ pageId, name, slug, description, showInNavShell }) {
+        try {
+            const body = {};
+            if (name !== undefined)
+                body.name = name;
+            if (slug !== undefined)
+                body.slug = slug;
+            if (description !== undefined)
+                body.description = description;
+            if (showInNavShell !== undefined)
+                body.showInNavShell = showInNavShell;
+            const resp = yield client.patch(`${basePath}/${pageId}`, body);
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, `updating page '${pageId}'`) }],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("delete_page", "Soft-delete a page by its ID. The page will no longer be accessible but can potentially be restored.", {
+        pageId: zod_1.z.string().describe("The page ID (UUID) to delete"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ pageId }) {
+        try {
+            yield client.delete(`${basePath}/${pageId}`);
+            return {
+                content: [{ type: "text", text: `Page '${pageId}' deleted successfully.` }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, `deleting page '${pageId}'`) }],
+                isError: true,
+            };
+        }
+    }));
+    // ── Drafts & Versions ─────────────────────────────────────────────
+    server.tool("save_page_draft", "Save or update the draft definition for a page. The definition describes the page's layout: sections, blocks, data sources, actions, and presentation. This does NOT publish the page — use publish_page after saving.", {
+        pageId: zod_1.z.string().describe("The page ID (UUID)"),
+        definition: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .describe("The page definition object containing sections with blocks. Each section has: id, kind (content|metrics|exceptions|actions|hero|supporting), title, layout (single-column|two-column|metric-strip|stack), and blocks array."),
+        changeSummary: zod_1.z.string().optional().describe("Summary of changes in this draft"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ pageId, definition, changeSummary }) {
+        try {
+            const body = { definition };
+            if (changeSummary)
+                body.changeSummary = changeSummary;
+            const resp = yield client.put(`${basePath}/${pageId}/draft`, body);
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, `saving draft for page '${pageId}'`) }],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("get_page_draft", "Get the current draft version of a page, including its full definition (sections, blocks, data sources).", {
+        pageId: zod_1.z.string().describe("The page ID (UUID)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ pageId }) {
+        try {
+            const resp = yield client.get(`${basePath}/${pageId}/draft`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, `getting draft for page '${pageId}'`) }],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("list_page_versions", "List all versions of a page. Each version captures a snapshot of the page definition at a point in time.", {
+        pageId: zod_1.z.string().describe("The page ID (UUID)"),
+        page: zod_1.z.number().optional().describe("Page number (1-indexed, default: 1)"),
+        pageSize: zod_1.z.number().optional().describe("Items per page (default: 20)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ pageId, page, pageSize }) {
+        try {
+            const params = {};
+            if (page !== undefined)
+                params.page = page;
+            if (pageSize !== undefined)
+                params.pageSize = pageSize;
+            const resp = yield client.get(`${basePath}/${pageId}/versions`, { params });
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, `listing versions for page '${pageId}'`) }],
+                isError: true,
+            };
+        }
+    }));
+    // ── Publishing ────────────────────────────────────────────────────
+    server.tool("validate_page", "Run validation checks on a page's current draft to determine if it is ready to publish. Returns a list of issues (errors and warnings) that must be resolved before publishing.", {
+        pageId: zod_1.z.string().describe("The page ID (UUID) to validate"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ pageId }) {
+        try {
+            const resp = yield client.post(`${basePath}/${pageId}/validate`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, `validating page '${pageId}'`) }],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("publish_page", "Publish the current draft of a page, making it accessible at its runtime URL. Validates the draft first — if there are errors, publishing is rejected with details. Returns the publication record and the public runtime URL.", {
+        pageId: zod_1.z.string().describe("The page ID (UUID) to publish"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ pageId }) {
+        try {
+            const resp = yield client.post(`${basePath}/${pageId}/publish`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, `publishing page '${pageId}'`) }],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("unpublish_page", "Unpublish a page, making it no longer accessible at its runtime URL. The page definition is preserved and can be re-published later.", {
+        pageId: zod_1.z.string().describe("The page ID (UUID) to unpublish"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ pageId }) {
+        try {
+            const resp = yield client.post(`${basePath}/${pageId}/unpublish`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, `unpublishing page '${pageId}'`) }],
+                isError: true,
+            };
+        }
+    }));
+    // ── Access Policy ─────────────────────────────────────────────────
+    server.tool("set_page_access_policy", "Set the access policy for a page. Controls who can view the published page: 'public' (anyone), 'authenticated' (logged-in users), or 'role-gated' (users with specific roles).", {
+        pageId: zod_1.z.string().describe("The page ID (UUID)"),
+        accessMode: zod_1.z
+            .enum(["public", "authenticated", "role-gated"])
+            .describe("Access control mode"),
+        requiredRoles: zod_1.z
+            .array(zod_1.z.string())
+            .optional()
+            .describe("Required roles (only used when accessMode is 'role-gated')"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ pageId, accessMode, requiredRoles }) {
+        try {
+            const body = { accessMode };
+            if (requiredRoles)
+                body.requiredRoles = requiredRoles;
+            const resp = yield client.put(`${basePath}/${pageId}/access-policy`, body);
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, `setting access policy for page '${pageId}'`) }],
+                isError: true,
+            };
+        }
+    }));
+    // ── Theme ─────────────────────────────────────────────────────────
+    server.tool("get_page_theme", "Get the workspace theme configuration used by published pages. Includes primary color, accent color, optional logo URL, and font family.", {}, () => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const resp = yield client.get(`${basePath}/theme`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, "getting page theme") }],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("set_page_theme", "Set the workspace theme for published pages. Controls the visual branding of all published pages.", {
+        primaryColor: zod_1.z.string().describe("Primary brand color (hex, e.g., '#1a73e8')"),
+        accentColor: zod_1.z.string().describe("Accent color (hex, e.g., '#ff6d00')"),
+        logoUrl: zod_1.z.string().optional().describe("URL to the workspace logo"),
+        fontFamily: zod_1.z.string().optional().describe("Font family name (e.g., 'Inter', 'Roboto')"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ primaryColor, accentColor, logoUrl, fontFamily }) {
+        try {
+            const config = { primaryColor, accentColor };
+            if (logoUrl !== undefined)
+                config.logoUrl = logoUrl;
+            if (fontFamily !== undefined)
+                config.fontFamily = fontFamily;
+            const resp = yield client.put(`${basePath}/theme`, { config });
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, "setting page theme") }],
+                isError: true,
+            };
+        }
+    }));
+    // ── Navigation ────────────────────────────────────────────────────
+    server.tool("get_navigation", "Get the workspace navigation configuration. Controls the sidebar/nav shell that wraps published pages.", {}, () => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const resp = yield client.get(`${basePath}/navigation`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, "getting navigation config") }],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("set_navigation", "Set the workspace navigation configuration. Defines the sidebar items, branding, and grouping for the page navigation shell.", {
+        config: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .describe("Navigation config object with: enabled (boolean), branding ({ logoUrl, displayName }), items (array of nav items with pageId, label, icon, group)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ config }) {
+        try {
+            const resp = yield client.put(`${basePath}/navigation`, { config });
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, "setting navigation config") }],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("delete_navigation", "Delete the workspace navigation configuration. Pages revert to standalone rendering without a sidebar/nav shell.", {}, () => __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield client.delete(`${basePath}/navigation`);
+            return {
+                content: [{ type: "text", text: "Navigation config deleted. Pages will render standalone." }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, "deleting navigation config") }],
+                isError: true,
+            };
+        }
+    }));
+    // ── Assembly (AI-assisted page generation) ────────────────────────
+    server.tool("generate_starter_pages", "Generate page proposals from structure IDs. Uses guided assembly to create page definitions (list, detail, form, dashboard) tailored to the data schema. Returns proposals that can be reviewed and accepted.", {
+        structureIds: zod_1.z
+            .array(zod_1.z.string())
+            .describe("Array of structure IDs (UUIDs) to generate pages for"),
+        goals: zod_1.z
+            .array(zod_1.z.string())
+            .optional()
+            .describe("Optional goals to guide page generation (e.g., 'customer management dashboard', 'order tracking')"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ structureIds, goals }) {
+        try {
+            const body = { structureIds };
+            if (goals)
+                body.goals = goals;
+            const resp = yield client.post(`${basePath}/generate-starter-pages`, body);
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, "generating starter pages") }],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("accept_page_proposal", "Accept a generated page proposal and create the page with its initial draft definition. Use after reviewing proposals from generate_starter_pages.", {
+        name: zod_1.z.string().describe("Display name for the page"),
+        slug: zod_1.z.string().describe("URL-safe slug for the page"),
+        pageType: zod_1.z
+            .enum(["list", "detail", "form", "dashboard"])
+            .describe("Page type"),
+        definition: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .describe("The page definition from the proposal"),
+        generationSource: zod_1.z
+            .string()
+            .describe("The source that generated this proposal (from the proposal object)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ name, slug, pageType, definition, generationSource }) {
+        try {
+            const resp = yield client.post(`${basePath}/accept-proposal`, {
+                name,
+                slug,
+                pageType,
+                definition,
+                generationSource,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(resp.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatError(error, "accepting page proposal") }],
+                isError: true,
+            };
+        }
+    }));
+}