@cplace/test-mcp-server 0.1.15 → 1.1.0

package/dist/tools/widgets.js

@@ -2,20 +2,205 @@ import { z } from "zod";
 import { debugLogWithTag } from "../logger.js";
 import { transformMultiplicityToBoolean } from '../utils.js';
 import { PositionSchema, WIDGET_CONFIG_DESCRIPTION } from './common-schemas.js';
-export function registerWidgetTools(server, client) {
-    server.registerTool("cplace_list_widget_definitions", {
-        description: "Get a list of all available widget definitions in the system that support the specified embedding context, with their basic metadata including names, descriptions, and apps",
+import { WIDGET_SPECIFICATIONS } from '../widget-specifications/index.js';
+const TOOL_LIST_WIDGET_DEFINITIONS = 'cplace_list_widget_definitions';
+const TOOL_GET_WIDGET_DEFINITION = 'cplace_get_widget_definition';
+const TOOL_GET_WIDGET_DETAILS = 'cplace_get_widget_details';
+const TOOL_GET_EMBEDDED_LAYOUT = 'cplace_get_embedded_layout';
+const TOOL_ADD_WIDGET_TO_EMBEDDED_LAYOUT = 'cplace_add_widget_to_embedded_layout';
+const TOOL_REMOVE_WIDGET_FROM_EMBEDDED_LAYOUT = 'cplace_remove_widget_from_embedded_layout';
+export const WIDGET_TOOL_DEFINITIONS = {
+    [TOOL_LIST_WIDGET_DEFINITIONS]: {
+        description: `Get a list of all available widget definitions in the system that support the specified embedding context, with their basic metadata including names, descriptions, and apps.
+
+⚠️ APP DEPENDENCY CHECK: Each widget includes a 'requiredApp' field:
+- null: Widget is always available (platform widget, no app dependency)
+- "cf.cplace.someApp": Widget requires this app to be installed in the workspace
+
+BEFORE SELECTING A WIDGET for a specific workspace, verify the required app is installed using cplace_list_workspace_apps. Widgets with uninstalled requiredApp cannot be added to layouts.`,
         inputSchema: {
             embeddingContext: z.enum(["AS_WIDGET", "INSIDE_RICHSTRING", "INSIDE_WIDGET"]).default("AS_WIDGET").describe(`Filter widgets by embedding context support:
 - AS_WIDGET (default): Widgets that support full widget embedding with frame and title
 - INSIDE_RICHSTRING: Widgets that can be embedded in rich text content without frame
-- INSIDE_WIDGET: Widgets that can be embedded inside other widgets without frame`)
+- INSIDE_WIDGET: Widgets that can be embedded inside other widgets without frame`),
+            tags: z.array(z.string()).optional().describe(`Filter widgets by tags (OR logic - returns widgets matching ANY tag).
+
+**Data/Content Type** (what the widget works with):
+- attributes: Page attributes/properties
+- files: File attachments/documents
+- rich-text: Formatted text content
+- media: Images, video, visual content
+- comments: Discussion threads
+- references: Page relationships
+- metadata: System info (versions, timestamps)
+- time-series: Date-based data
+
+**Display Format** (how data is presented):
+- chart: Graphical visualization (bar, pie, line)
+- table: Tabular rows and columns
+- list: Simple sequential display
+- board: Card-based layout (Kanban)
+- timeline: Gantt, roadmap, schedule
+- tree: Hierarchical structure
+- matrix: Two-dimensional grid
+- form: Input fields layout
+- gallery: Visual thumbnail grid
+
+**Interaction** (what users can do):
+- read-only: Display only
+- inline-edit: Edit values in place
+- filterable: User can filter data
+- sortable: User can reorder data
+- searchable: Search-driven content
+- drag-drop: Drag and drop support
+- selectable: Items can be selected
+
+**Purpose/Context** (why to use):
+- dashboard: Aggregated overview, KPIs
+- detail-view: Single page details
+- navigation: Browsing, finding pages
+- collaboration: Team communication
+- reporting: Export, reports
+- scheduling: Time/resource planning
+
+**Technical**:
+- low-code: Requires cplaceJS scripting
+- connected: Links to other widgets
+- container: Holds other widgets`)
         },
         annotations: { title: "List Widget Definitions" }
-    }, async ({ embeddingContext = "AS_WIDGET" }) => {
-        debugLogWithTag('WIDGETS', `Starting widget definitions list request with embeddingContext: ${embeddingContext}`);
+    },
+    [TOOL_GET_WIDGET_DEFINITION]: {
+        description: `Get widget definition with configurable detail level.
+
+ALWAYS includes:
+- widgetKind, localizedName
+- summary (from widget specifications)
+
+OPTIONAL depth control:
+- includeOverview: true → adds conceptual documentation (overview)
+- includeDetails: true → adds attributes array and implementation hints
+
+COMMON USAGE:
+- Quick check: just widgetKinds (minimal response)
+- Understanding: includeOverview: true
+- Implementation: includeDetails: true
+- Full details: both flags true
+
+Widget kinds: 'cf.platform.connectedBarChart', 'cf.platform.wiki', etc.`,
+        inputSchema: {
+            widgetKinds: z.array(z.string()).describe("Array of widget kind identifiers (e.g., ['cf.platform.embeddedSearchAsTable', 'cf.platform.connectedBarChart'])"),
+            includeOverview: z.boolean().default(false).describe("Include conceptual documentation from _overview.md. Use when you need to understand widget purpose and capabilities."),
+            includeDetails: z.boolean().default(false).describe("Include attributes array and implementation hints from _implementation.md. Use when you need to configure the widget.")
+        },
+        annotations: { title: "Get Widget Definition" }
+    },
+    [TOOL_GET_WIDGET_DETAILS]: {
+        description: "Get detailed configuration for a specific widget within a page layout. Use this after cplace_get_page_layout_overview to examine specific widget configurations.",
+        inputSchema: {
+            pageUID: z.string().describe("The unique identifier (UID) of the page containing the widget"),
+            widgetId: z.string().describe("The unique widget identifier from the layout (e.g., 'id_123', 'id_456')")
+        },
+        annotations: { title: "Get Widget Details" }
+    },
+    [TOOL_GET_EMBEDDED_LAYOUT]: {
+        description: "Get embedded widget layout structure for page or type. Retrieves the widget layout structure of embedded widgets within container widgets like AttributesGroup widgets.",
+        inputSchema: {
+            context: z.union([
+                z.object({
+                    type: z.literal("page"),
+                    pageUID: z.string().describe("Page UID (e.g., 'page/abc123')"),
+                    containerWidgetId: z.string().describe("Container widget ID (e.g., 'id_abc123')"),
+                    layoutAttributeName: z.string().describe("Layout attribute name (e.g., 'detailsLayout')")
+                }),
+                z.object({
+                    type: z.literal("type"),
+                    workspaceId: z.string().describe("Workspace ID (e.g., 'workspace123')"),
+                    typeInternalName: z.string().describe("Type internal name (e.g., 'cf.example.myType')"),
+                    alternativeLayoutName: z.string().optional().describe("Alternative layout name (optional)"),
+                    containerWidgetId: z.string().describe("Container widget ID (e.g., 'id_abc123')"),
+                    layoutAttributeName: z.string().describe("Layout attribute name (e.g., 'detailsLayout')")
+                })
+            ]).describe("Embedded layout target - specify whether operating on page or type embedded layout")
+        },
+        annotations: { title: "Get Embedded Layout" }
+    },
+    [TOOL_ADD_WIDGET_TO_EMBEDDED_LAYOUT]: {
+        description: `Add widget to page or type embedded layout. Enables adding widgets to nested layouts like those within AttributesGroup widgets.
+
+⚠️ APP DEPENDENCY: Verify the widget's requiredApp is installed in the workspace using cplace_list_workspace_apps before adding. Widgets with uninstalled requiredApp will fail.`,
+        inputSchema: {
+            context: z.union([
+                z.object({
+                    type: z.literal("page"),
+                    pageUID: z.string().describe("Page UID (e.g., 'page/abc123')"),
+                    containerWidgetId: z.string().describe("Container widget ID (e.g., 'id_abc123')"),
+                    layoutAttributeName: z.string().describe("Layout attribute name (e.g., 'detailsLayout')")
+                }),
+                z.object({
+                    type: z.literal("type"),
+                    workspaceId: z.string().describe("Workspace ID (e.g., 'workspace123')"),
+                    typeInternalName: z.string().describe("Type internal name (e.g., 'cf.example.myType')"),
+                    alternativeLayoutName: z.string().optional().describe("Alternative layout name (optional)"),
+                    containerWidgetId: z.string().describe("Container widget ID (e.g., 'id_abc123')"),
+                    layoutAttributeName: z.string().describe("Layout attribute name (e.g., 'detailsLayout')")
+                })
+            ]).describe("Embedded layout target - specify whether operating on page or type embedded layout"),
+            widgetType: z.string().describe("Widget type identifier (e.g., 'cf.cplace.platform.table', 'cf.platform.wiki')"),
+            position: PositionSchema,
+            configuration: z.record(z.any()).optional().describe(WIDGET_CONFIG_DESCRIPTION)
+        },
+        annotations: { title: "Add Widget to Embedded Layout" }
+    },
+    [TOOL_REMOVE_WIDGET_FROM_EMBEDDED_LAYOUT]: {
+        description: "Remove widget from page or type embedded layout. Enables removing widgets from nested layouts like those within AttributesGroup widgets.",
+        inputSchema: {
+            context: z.union([
+                z.object({
+                    type: z.literal("page"),
+                    pageUID: z.string().describe("Page UID (e.g., 'page/abc123')"),
+                    containerWidgetId: z.string().describe("Container widget ID (e.g., 'id_abc123')"),
+                    layoutAttributeName: z.string().describe("Layout attribute name (e.g., 'detailsLayout')")
+                }),
+                z.object({
+                    type: z.literal("type"),
+                    workspaceId: z.string().describe("Workspace ID (e.g., 'workspace123')"),
+                    typeInternalName: z.string().describe("Type internal name (e.g., 'cf.example.myType')"),
+                    alternativeLayoutName: z.string().optional().describe("Alternative layout name (optional)"),
+                    containerWidgetId: z.string().describe("Container widget ID (e.g., 'id_abc123')"),
+                    layoutAttributeName: z.string().describe("Layout attribute name (e.g., 'detailsLayout')")
+                })
+            ]).describe("Embedded layout target - specify whether operating on page or type embedded layout"),
+            widgetId: z.string().describe("The ID of the existing widget to remove from the embedded layout")
+        },
+        annotations: { title: "Remove Widget from Embedded Layout" }
+    }
+};
+export function registerWidgetTools(server, client) {
+    server.registerTool(TOOL_LIST_WIDGET_DEFINITIONS, WIDGET_TOOL_DEFINITIONS[TOOL_LIST_WIDGET_DEFINITIONS], async ({ embeddingContext = "AS_WIDGET", tags }) => {
+        debugLogWithTag('WIDGETS', `Starting widget definitions list request with embeddingContext: ${embeddingContext}${tags?.length ? `, tags: ${tags.join(', ')}` : ''}`);
         try {
             const result = await client.makeApiRequest('json/widget-definitions', 'GET', { embeddingContext });
+            if (result && typeof result === 'object' && Array.isArray(result.widgetDefinitions)) {
+                result.widgetDefinitions.forEach((widget) => {
+                    const widgetSpecs = WIDGET_SPECIFICATIONS[widget.widgetKind];
+                    if (widgetSpecs?.['_summary']) {
+                        widget.summary = widgetSpecs['_summary'];
+                    }
+                    if (widgetSpecs?._meta?.requiredApp !== undefined) {
+                        widget.requiredApp = widgetSpecs._meta.requiredApp;
+                    }
+                });
+                debugLogWithTag('WIDGETS', `Enriched ${result.widgetDefinitions.filter((w) => w.summary).length} widgets with summaries`);
+            }
+            if (tags?.length && result.widgetDefinitions) {
+                result.widgetDefinitions = result.widgetDefinitions.filter((widget) => {
+                    const widgetSpecs = WIDGET_SPECIFICATIONS[widget.widgetKind];
+                    const widgetTags = widgetSpecs?._meta?.tags || [];
+                    return tags.some(tag => widgetTags.includes(tag));
+                });
+                debugLogWithTag('WIDGETS', `Filtered to ${result.widgetDefinitions.length} widgets matching tags: ${tags.join(', ')}`);
+            }
             debugLogWithTag('WIDGETS', `Retrieved widget definitions for context: ${embeddingContext}`);
             return {
                 content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
@@ -31,67 +216,66 @@ export function registerWidgetTools(server, client) {
             };
         }
     });
-    const WIDGET_ATTRIBUTE_ENHANCEMENTS = {
-        'cf.cplace.platform.attributesGroup': {
-            'cf.cplace.platform.attributesGroup.pageSelection': {
-                validValues: {
-                    'embedding': 'Use the current embedding page (the page containing this widget)',
-                    'parent': 'Use the parent page of the embedding page',
-                    'absolute': 'Use an absolute page reference (requires cf.cplace.platform.attributesGroup.absoluteSelection)',
-                    'relative': 'Use a relative reference through an attribute (requires cf.cplace.platform.attributesGroup.relativeSelection)'
-                },
-                defaultValue: 'embedding',
-                note: 'This attribute determines which page\'s attributes are displayed in the widget'
-            }
-        },
-    };
-    server.registerTool("cplace_get_widget_definition", {
-        description: "Get detailed widget configuration schema.\n\n🔍 ALWAYS USE BEFORE ADDING/CONFIGURING WIDGETS to understand:\n- Required vs optional attributes\n- Correct attribute names (often not intuitive!)\n- Expected data types and formats\n- Available enumeration values\n\nCOMMON GOTCHAS:\n- Bar charts use 'attributeName' not 'attribute'\n- Connected charts need 'tableWidgetId' to link to tables\n- Attribute names often need single quotes: \"'cf.cplace.myAttribute'\"\n- LocalizedString format: {\"en\": \"English\", \"de\": \"German\"}\n\nWidget kinds: 'cf.platform.connectedBarChart', 'cf.platform.wiki', etc.",
-        inputSchema: {
-            widgetKind: z.string().describe("The widget kind identifier (e.g., 'cf.cplace.platform.table', 'cf.platform.wiki')")
-        },
-        annotations: { title: "Get Widget Definition Details" }
-    }, async ({ widgetKind }) => {
-        debugLogWithTag('WIDGETS', `Starting widget definition request for: ${widgetKind}`);
+    server.registerTool(TOOL_GET_WIDGET_DEFINITION, WIDGET_TOOL_DEFINITIONS[TOOL_GET_WIDGET_DEFINITION], async ({ widgetKinds, includeOverview = false, includeDetails = false }) => {
+        debugLogWithTag('WIDGETS', `Starting widget definition request for: ${widgetKinds.join(', ')} (includeOverview: ${includeOverview}, includeDetails: ${includeDetails})`);
         try {
-            const result = await client.makeApiRequest('json/widget-definition', 'GET', { widgetKind });
-            if (result && result.configurationSchema && result.configurationSchema.attributes) {
-                result.configurationSchema.attributes = transformMultiplicityToBoolean(result.configurationSchema.attributes);
-                const widgetEnhancements = WIDGET_ATTRIBUTE_ENHANCEMENTS[widgetKind];
-                if (widgetEnhancements) {
-                    result.configurationSchema.attributes = result.configurationSchema.attributes.map((attr) => {
-                        const enhancement = widgetEnhancements[attr.name];
-                        if (enhancement) {
-                            attr.hiddenKnowledge = enhancement;
-                            debugLogWithTag('WIDGETS', `Enhanced attribute ${attr.name} with hidden knowledge`);
+            const results = await Promise.all(widgetKinds.map(async (widgetKind) => {
+                try {
+                    const result = await client.makeApiRequest('json/widget-definition', 'GET', { widgetKind });
+                    const widgetSpecs = WIDGET_SPECIFICATIONS[widgetKind];
+                    const response = {
+                        widgetKind: result.widgetKind,
+                        localizedName: result.localizedName,
+                        summary: widgetSpecs?.['_summary'] ?? null
+                    };
+                    if (includeOverview) {
+                        response.overview = widgetSpecs?.['_overview'] ?? null;
+                    }
+                    if (includeDetails) {
+                        let attributes = result.configurationSchema?.attributes || [];
+                        attributes = transformMultiplicityToBoolean(attributes);
+                        if (widgetSpecs) {
+                            attributes = attributes.map((attr) => {
+                                const fullAttrName = `${widgetKind}.${attr.name}`;
+                                const specification = widgetSpecs[fullAttrName];
+                                if (specification && typeof specification === 'string') {
+                                    attr.specification = specification;
+                                }
+                                return attr;
+                            });
+                        }
+                        const implementation = widgetSpecs?.['_implementation'];
+                        if (implementation && typeof implementation === 'string') {
+                            response.implementation = implementation;
                         }
-                        return attr;
-                    });
+                        response.attributesCount = result.configurationSchema?.attributesCount;
+                        response.attributes = attributes;
+                    }
+                    return response;
                 }
-            }
-            debugLogWithTag('WIDGETS', `Retrieved widget definition for: ${widgetKind}`);
+                catch (error) {
+                    return {
+                        widgetKind,
+                        error: error instanceof Error ? error.message : String(error)
+                    };
+                }
+            }));
+            debugLogWithTag('WIDGETS', `Retrieved definitions for ${results.filter(r => !('error' in r)).length}/${widgetKinds.length} widgets`);
             return {
-                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
             };
         }
         catch (error) {
             return {
                 content: [{
                         type: "text",
-                        text: `Error retrieving widget definition for ${widgetKind}: ${error instanceof Error ? error.message : String(error)}`
+                        text: `Error retrieving widget definitions: ${error instanceof Error ? error.message : String(error)}`
                     }],
                 isError: true
             };
         }
     });
-    server.registerTool("cplace_get_widget_details", {
-        description: "Get detailed configuration for a specific widget within a page layout. Use this after cplace_get_page_layout_overview to examine specific widget configurations.",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page containing the widget"),
-            widgetId: z.string().describe("The unique widget identifier from the layout (e.g., 'id_123', 'id_456')")
-        },
-        annotations: { title: "Get Widget Details" }
-    }, async ({ pageUID, widgetId }) => {
+    server.registerTool(TOOL_GET_WIDGET_DETAILS, WIDGET_TOOL_DEFINITIONS[TOOL_GET_WIDGET_DETAILS], async ({ pageUID, widgetId }) => {
         debugLogWithTag('LAYOUT', `Starting widget details request for widget ${widgetId} in page ${pageUID}`);
         try {
             const result = await client.makeApiRequest('json/pageLayout', 'GET', { pageUID });
@@ -120,302 +304,22 @@ export function registerWidgetTools(server, client) {
                 };
             }
             debugLogWithTag('LAYOUT', `Retrieved widget details for: ${widgetId} in page`);
-            return {
-                content: [{ type: "text", text: JSON.stringify(foundWidget, null, 2) }]
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: "text",
-                        text: `Error retrieving widget details for ${widgetId} in page ${pageUID}: ${error instanceof Error ? error.message : String(error)}`
-                    }],
-                isError: true
-            };
-        }
-    });
-    server.registerTool("cplace_add_widget_to_layout", {
-        description: "Add a new widget to a page layout at a specific position.\n\n⚠️ REQUIRED BEFORE USE:\n- ALWAYS call cplace_get_widget_definition FIRST to understand required fields\n- Many widgets have non-obvious required attributes that will cause validation errors\n- Widget configurations must match the schema exactly\n\nCRITICAL BEHAVIOR:\n- Row creation: ❌ NOT automatic - use cplace_add_row_to_page_layout to create rows first\n- Column creation: ❌ NOT automatic - columnIndex only references existing columns\n- Invalid columnIndex: Falls back to last existing column (no error)\n\nTO CREATE SIDE-BY-SIDE LAYOUTS:\n1. First use cplace_add_row_to_page_layout to create multi-column structure\n2. Then add widgets to the created columns\n\nEXAMPLES:\n- Add to new row 0: Creates single-column row, widget goes to column 0\n- Add to column 1 when only column 0 exists: Widget goes to column 0 (fallback)\n- Add to pre-created 6/6 row: Works correctly if columns exist\n\nTIP: Always check current layout with cplace_get_page_layout_overview before adding widgets.\n\nSupports both page-level layouts (default) and embedded layouts within container widgets like AttributesGroup.",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page to add the widget to"),
-            widgetType: z.string().describe("The widget type identifier (e.g., 'cf.cplace.platform.table', 'cf.platform.wiki', 'cf.platform.singleAttribute')"),
-            configuration: z.record(z.any()).optional().describe(`${WIDGET_CONFIG_DESCRIPTION}
-
-WIDGET-SPECIFIC PATTERNS:
-- Connected widgets (bar/pie charts): Use 'tableWidgetId' to connect to existing table widget
-  Example: {'tableWidgetId': 'id_abc123', 'title': {'en': 'Chart Title'}}
-- Attribute widgets: Use 'cf.platform.quotedAttributeName' with single quotes
-  Example: {'cf.platform.quotedAttributeName': "'cf.cplace.myAttribute'", 'cf.platform.withLabel': true}
-- Search widgets: Use 'search' with JSON search string
-  Example: {'search': '{"filters":[{"types":["test.project"]}]}', 'title': {'en': 'Results'}}
-
-For embedded attribute widgets: {'cf.platform.quotedAttributeName': "'cf.cplace.myAttribute'", 'cf.platform.withLabel': true}`),
-            position: PositionSchema.extend({}).describe("Grid position where the widget should be added"),
-            layoutContext: z.enum(["page", "widget"]).default("page").describe("Layout context: 'page' for page-level layout (default), 'widget' for embedded layout within a container widget"),
-            containerWidgetId: z.string().optional().describe("Required when layoutContext is 'widget'. The unique identifier of the container widget (e.g., AttributesGroup widget) that contains the embedded layout to modify"),
-            layoutAttributeName: z.string().optional().describe("Optional layout attribute name for embedded layouts. If not provided, it will be auto-detected based on the container widget type")
-        },
-        annotations: { title: "Add Widget to Layout" }
-    }, async ({ pageUID, widgetType, configuration, position, layoutContext = "page", containerWidgetId, layoutAttributeName }) => {
-        debugLogWithTag('LAYOUT_MODIFY', `Starting add widget operation: ${widgetType} to ${layoutContext === "widget" ? "embedded layout in container " + containerWidgetId : "page layout"} ${pageUID} at position ${JSON.stringify(position)}`);
-        try {
-            if (layoutContext === "widget") {
-                if (!containerWidgetId) {
-                    return {
-                        content: [{ type: "text", text: "containerWidgetId is required when layoutContext is 'widget'" }]
-                    };
-                }
-                debugLogWithTag('LAYOUT_MODIFY', `Adding to embedded layout in container widget: ${containerWidgetId}`);
-            }
-            const operation = {
-                type: "ADD",
-                widgetType,
-                position: {
-                    rowIndex: position.rowIndex,
-                    columnIndex: position.columnIndex,
-                    widgetIndex: position.widgetIndex
-                }
-            };
-            if (configuration && Object.keys(configuration).length > 0) {
-                operation.configuration = configuration;
-                debugLogWithTag('LAYOUT_MODIFY', `Including configuration: ${JSON.stringify(Object.keys(configuration))}`);
-            }
-            const requestBody = {
-                pageUID,
-                layoutContext,
-                operation
-            };
-            if (layoutContext === "widget") {
-                requestBody.containerWidgetId = containerWidgetId;
-                if (layoutAttributeName) {
-                    requestBody.layoutAttributeName = layoutAttributeName;
-                }
-            }
-            debugLogWithTag('LAYOUT_MODIFY', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
-            const result = await client.makeApiRequest('json/pageLayout', 'PATCH', undefined, requestBody);
-            debugLogWithTag('LAYOUT_MODIFY', `Successfully added widget ${widgetType} to page ${pageUID}`);
-            const response = {
-                operation: "ADD",
-                status: "SUCCESS",
-                pageUID,
-                widgetType,
-                position,
-                layoutContext,
-                ...(layoutContext === "widget" && containerWidgetId && { containerWidgetId }),
-                message: layoutContext === "widget"
-                    ? "Widget added successfully to embedded layout"
-                    : "Widget added successfully"
-            };
-            return {
-                content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
-            };
-        }
-        catch (error) {
-            debugLogWithTag('LAYOUT_MODIFY', `Error adding widget: ${error instanceof Error ? error.message : String(error)}`);
-            const errorResponse = {
-                operation: "ADD",
-                status: "ERROR",
-                pageUID,
-                widgetType,
-                position,
-                layoutContext,
-                ...(layoutContext === "widget" && containerWidgetId && { containerWidgetId }),
-                error: error instanceof Error ? error.message : String(error),
-                message: "Failed to add widget"
-            };
-            return {
-                content: [{ type: "text", text: JSON.stringify(errorResponse, null, 2) }],
-                isError: true
-            };
-        }
-    });
-    server.registerTool("cplace_remove_widget_from_layout", {
-        description: "Remove an existing widget from a page layout",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page containing the widget"),
-            widgetId: z.string().describe("The unique identifier of the widget to remove")
-        },
-        annotations: { title: "Remove Widget from Layout" }
-    }, async ({ pageUID, widgetId }) => {
-        debugLogWithTag('LAYOUT_MODIFY', `Starting remove widget operation: ${widgetId} from page ${pageUID}`);
-        try {
-            const requestBody = {
-                pageUID,
-                operation: {
-                    type: "REMOVE",
-                    widgetId
-                }
-            };
-            debugLogWithTag('LAYOUT_MODIFY', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
-            const result = await client.makeApiRequest('json/pageLayout', 'PATCH', undefined, requestBody);
-            debugLogWithTag('LAYOUT_MODIFY', `Successfully removed widget ${widgetId} from page ${pageUID}`);
-            const response = {
-                operation: "REMOVE",
-                status: "SUCCESS",
-                pageUID,
-                widgetId,
-                message: "Widget removed successfully"
-            };
-            return {
-                content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
-            };
-        }
-        catch (error) {
-            debugLogWithTag('LAYOUT_MODIFY', `Error removing widget: ${error instanceof Error ? error.message : String(error)}`);
-            const errorResponse = {
-                operation: "REMOVE",
-                status: "ERROR",
-                pageUID,
-                widgetId,
-                error: error instanceof Error ? error.message : String(error),
-                message: "Failed to remove widget"
-            };
-            return {
-                content: [{ type: "text", text: JSON.stringify(errorResponse, null, 2) }],
-                isError: true
-            };
-        }
-    });
-    server.registerTool("cplace_update_widget_in_layout", {
-        description: "Modify widget configuration or display properties.\nUSE CASES:\n- Restore configuration after widget moves (configurations may be lost during moves)\n- Update widget connections (e.g., change tableWidgetId after layout modifications)\n- Modify display properties (titles, collapse state, etc.)\n\nTIP: Widget IDs may change after layout operations - always use current IDs from latest layout overview.",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page containing the widget"),
-            widgetId: z.string().describe("The unique identifier of the widget to update"),
-            newConfiguration: z.record(z.any()).optional().describe(`Updated widget configuration as key-value pairs (optional). ${WIDGET_CONFIG_DESCRIPTION}`),
-            collapsed: z.boolean().optional().describe("Widget collapse state (optional)")
-        },
-        annotations: { title: "Update Widget in Layout" }
-    }, async ({ pageUID, widgetId, newConfiguration, collapsed }) => {
-        debugLogWithTag('LAYOUT_MODIFY', `Starting update widget operation: ${widgetId} in page ${pageUID}`);
-        try {
-            const operation = {
-                type: "UPDATE",
-                widgetId
-            };
-            if (newConfiguration && Object.keys(newConfiguration).length > 0) {
-                operation.newConfiguration = newConfiguration;
-                debugLogWithTag('LAYOUT_MODIFY', `Including new configuration: ${JSON.stringify(Object.keys(newConfiguration))}`);
-            }
-            if (collapsed !== undefined) {
-                operation.collapsed = collapsed;
-                debugLogWithTag('LAYOUT_MODIFY', `Setting collapsed state to: ${collapsed}`);
-            }
-            if (!operation.newConfiguration && operation.collapsed === undefined) {
-                return {
-                    content: [{ type: "text", text: "No updates specified. At least one of newConfiguration or collapsed must be provided." }]
-                };
-            }
-            const requestBody = {
-                pageUID,
-                operation
-            };
-            debugLogWithTag('LAYOUT_MODIFY', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
-            const result = await client.makeApiRequest('json/pageLayout', 'PATCH', undefined, requestBody);
-            debugLogWithTag('LAYOUT_MODIFY', `Successfully updated widget ${widgetId} in page ${pageUID}`);
             const response = {
-                operation: "UPDATE",
-                status: "SUCCESS",
-                pageUID,
-                widgetId,
-                message: "Widget updated successfully"
-            };
-            return {
-                content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
-            };
-        }
-        catch (error) {
-            debugLogWithTag('LAYOUT_MODIFY', `Error updating widget: ${error instanceof Error ? error.message : String(error)}`);
-            const errorResponse = {
-                operation: "UPDATE",
-                status: "ERROR",
-                pageUID,
                 widgetId,
-                error: error instanceof Error ? error.message : String(error),
-                message: "Failed to update widget"
-            };
-            return {
-                content: [{ type: "text", text: JSON.stringify(errorResponse, null, 2) }],
-                isError: true
-            };
-        }
-    });
-    server.registerTool("cplace_move_widget_in_layout", {
-        description: "Relocate a widget to a different position in the layout.\n\nMOVE BEHAVIOR:\n- ✅ Can move between existing rows and columns\n- ❌ Cannot create new columns (only references existing ones)\n- Invalid columnIndex: Falls back to last column in target row\n\nCRITICAL WARNINGS:\n- Widget configurations may be LOST during moves\n- Widget IDs may CHANGE - always get new IDs from response\n- Connected widgets (charts) may lose their tableWidgetId references\n\nPOST-MOVE CHECKLIST:\n1. Get new widget ID from response\n2. Use cplace_get_widget_details to check if configuration was preserved\n3. If lost, use cplace_update_widget_in_layout to restore configuration\n4. Update any widgets that referenced the moved widget's old ID\n\nTIP: For complex layouts, consider removing and re-adding widgets instead of moving.",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page containing the widget"),
-            widgetId: z.string().describe("The unique identifier of the widget to move"),
-            newPosition: PositionSchema.extend({}).describe("Target grid position for the widget")
-        },
-        annotations: { title: "Move Widget in Layout" }
-    }, async ({ pageUID, widgetId, newPosition }) => {
-        debugLogWithTag('LAYOUT_MODIFY', `Starting move widget operation: ${widgetId} in page ${pageUID} to position ${JSON.stringify(newPosition)}`);
-        try {
-            const requestBody = {
-                pageUID,
-                operation: {
-                    type: "MOVE",
-                    widgetId,
-                    newPosition: {
-                        rowIndex: newPosition.rowIndex,
-                        columnIndex: newPosition.columnIndex,
-                        widgetIndex: newPosition.widgetIndex
-                    }
-                }
-            };
-            debugLogWithTag('LAYOUT_MODIFY', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
-            const result = await client.makeApiRequest('json/pageLayout', 'PATCH', undefined, requestBody);
-            debugLogWithTag('LAYOUT_MODIFY', `Successfully moved widget ${widgetId} in page ${pageUID}`);
-            let newWidgetId = widgetId;
-            let widgetIdChanged = false;
-            try {
-                const layoutString = result.result;
-                const layout = JSON.parse(layoutString);
-                if (layout.rows && layout.rows[newPosition.rowIndex]) {
-                    const targetRow = layout.rows[newPosition.rowIndex];
-                    if (targetRow.columns && targetRow.columns[newPosition.columnIndex]) {
-                        const targetColumn = targetRow.columns[newPosition.columnIndex];
-                        if (targetColumn.widgets && targetColumn.widgets[newPosition.widgetIndex]) {
-                            const movedWidget = targetColumn.widgets[newPosition.widgetIndex];
-                            if (movedWidget.id && movedWidget.id !== widgetId) {
-                                newWidgetId = movedWidget.id;
-                                widgetIdChanged = true;
-                            }
-                        }
-                    }
-                }
-            }
-            catch (parseError) {
-                debugLogWithTag('LAYOUT_MODIFY', `Could not parse layout to detect ID change: ${parseError}`);
-            }
-            const response = {
-                operation: "MOVE",
-                status: "SUCCESS",
                 pageUID,
-                oldWidgetId: widgetId,
-                newWidgetId,
-                newPosition,
-                widgetIdChanged,
-                message: widgetIdChanged
-                    ? "Widget moved successfully - widget ID changed, please update any references"
-                    : "Widget moved successfully"
+                widget: foundWidget,
+                validationStatus: foundWidget.validationStatus || null
             };
             return {
                 content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
             };
         }
         catch (error) {
-            debugLogWithTag('LAYOUT_MODIFY', `Error moving widget: ${error instanceof Error ? error.message : String(error)}`);
-            const errorResponse = {
-                operation: "MOVE",
-                status: "ERROR",
-                pageUID,
-                oldWidgetId: widgetId,
-                newPosition,
-                error: error instanceof Error ? error.message : String(error),
-                message: "Failed to move widget"
-            };
             return {
-                content: [{ type: "text", text: JSON.stringify(errorResponse, null, 2) }],
+                content: [{
+                        type: "text",
+                        text: `Error retrieving widget details for ${widgetId} in page ${pageUID}: ${error instanceof Error ? error.message : String(error)}`
+                    }],
                 isError: true
             };
         }
@@ -466,13 +370,7 @@ For embedded attribute widgets: {'cf.platform.quotedAttributeName': "'cf.cplace.
         const operationVerb = operation === "ADD" ? "added" : "removed";
         return `Widget ${operationVerb} successfully`;
     }
-    server.registerTool("cplace_get_embedded_layout", {
-        description: "Get embedded widget layout structure for page or type. Retrieves the widget layout structure of embedded widgets within container widgets like AttributesGroup widgets.",
-        inputSchema: {
-            context: EmbeddedLayoutContextSchema
-        },
-        annotations: { title: "Get Embedded Layout" }
-    }, async ({ context }) => {
+    server.registerTool(TOOL_GET_EMBEDDED_LAYOUT, WIDGET_TOOL_DEFINITIONS[TOOL_GET_EMBEDDED_LAYOUT], async ({ context }) => {
         try {
             debugLogWithTag('EMBEDDED_LAYOUT', `Getting embedded layout for ${context.type} context: ${JSON.stringify({ context, endpoint: determineEmbeddedApiEndpoint(context) })}`);
             const endpoint = determineEmbeddedApiEndpoint(context);
@@ -497,16 +395,7 @@ For embedded attribute widgets: {'cf.platform.quotedAttributeName': "'cf.cplace.
             };
         }
     });
-    server.registerTool("cplace_add_widget_to_embedded_layout", {
-        description: "Add widget to page or type embedded layout. Enables adding widgets to nested layouts like those within AttributesGroup widgets.",
-        inputSchema: {
-            context: EmbeddedLayoutContextSchema,
-            widgetType: z.string().describe("Widget type identifier (e.g., 'cf.cplace.platform.table', 'cf.platform.wiki')"),
-            position: PositionSchema,
-            configuration: z.record(z.any()).optional().describe(WIDGET_CONFIG_DESCRIPTION)
-        },
-        annotations: { title: "Add Widget to Embedded Layout" }
-    }, async ({ context, widgetType, position, configuration }) => {
+    server.registerTool(TOOL_ADD_WIDGET_TO_EMBEDDED_LAYOUT, WIDGET_TOOL_DEFINITIONS[TOOL_ADD_WIDGET_TO_EMBEDDED_LAYOUT], async ({ context, widgetType, position, configuration }) => {
         try {
             debugLogWithTag('EMBEDDED_LAYOUT_ADD', `Adding widget to ${context.type} embedded layout: ${JSON.stringify({ context, widgetType, position, hasConfiguration: !!configuration })}`);
             const endpoint = determineEmbeddedApiEndpoint(context);
@@ -542,14 +431,7 @@ For embedded attribute widgets: {'cf.platform.quotedAttributeName': "'cf.cplace.
             };
         }
     });
-    server.registerTool("cplace_remove_widget_from_embedded_layout", {
-        description: "Remove widget from page or type embedded layout. Enables removing widgets from nested layouts like those within AttributesGroup widgets.",
-        inputSchema: {
-            context: EmbeddedLayoutContextSchema,
-            widgetId: z.string().describe("The ID of the existing widget to remove from the embedded layout")
-        },
-        annotations: { title: "Remove Widget from Embedded Layout" }
-    }, async ({ context, widgetId }) => {
+    server.registerTool(TOOL_REMOVE_WIDGET_FROM_EMBEDDED_LAYOUT, WIDGET_TOOL_DEFINITIONS[TOOL_REMOVE_WIDGET_FROM_EMBEDDED_LAYOUT], async ({ context, widgetId }) => {
         try {
             debugLogWithTag('EMBEDDED_LAYOUT_REMOVE', `Removing widget from ${context.type} embedded layout: ${JSON.stringify({ context, widgetId })}`);
             const endpoint = determineEmbeddedApiEndpoint(context);