@cplace/test-mcp-server 0.1.14 → 1.0.0

package/dist/tools/widgets.js

@@ -2,8 +2,14 @@ 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", {
+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",
         inputSchema: {
             embeddingContext: z.enum(["AS_WIDGET", "INSIDE_RICHSTRING", "INSIDE_WIDGET"]).default("AS_WIDGET").describe(`Filter widgets by embedding context support:
@@ -12,7 +18,109 @@ export function registerWidgetTools(server, client) {
 - INSIDE_WIDGET: Widgets that can be embedded inside other widgets without frame`)
         },
         annotations: { title: "List Widget Definitions" }
-    }, async ({ embeddingContext = "AS_WIDGET" }) => {
+    },
+    [TOOL_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" }
+    },
+    [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.",
+        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) {
+    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(TOOL_LIST_WIDGET_DEFINITIONS, WIDGET_TOOL_DEFINITIONS[TOOL_LIST_WIDGET_DEFINITIONS], async ({ embeddingContext = "AS_WIDGET" }) => {
         debugLogWithTag('WIDGETS', `Starting widget definitions list request with embeddingContext: ${embeddingContext}`);
         try {
             const result = await client.makeApiRequest('json/widget-definitions', 'GET', { embeddingContext });
@@ -31,27 +139,7 @@ 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 }) => {
+    server.registerTool(TOOL_GET_WIDGET_DEFINITION, WIDGET_TOOL_DEFINITIONS[TOOL_GET_WIDGET_DEFINITION], async ({ widgetKind }) => {
         debugLogWithTag('WIDGETS', `Starting widget definition request for: ${widgetKind}`);
         try {
             const result = await client.makeApiRequest('json/widget-definition', 'GET', { widgetKind });
@@ -84,53 +172,7 @@ export function registerWidgetTools(server, client) {
             };
         }
     });
-    server.registerTool("cplace_get_page_layout_overview", {
-        description: "Get the high-level layout structure of a page including rows, columns, and widget summaries. Provides an overview of the page layout grid without detailed widget configurations.",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page to get layout for, e.g. 'page/kkt8ol745jqur4581kelm5ply'")
-        },
-        annotations: { title: "Get Page Layout Overview" }
-    }, async ({ pageUID }) => {
-        debugLogWithTag('LAYOUT', `Starting page layout overview request for: ${pageUID}`);
-        try {
-            const result = await client.makeApiRequest('json/pageLayout', 'GET', { pageUID });
-            const overview = {
-                rows: result.rows?.map((row, rowIndex) => ({
-                    rowIndex,
-                    columns: row.columns?.map((column, colIndex) => ({
-                        columnIndex: colIndex,
-                        proportion: column.proportion,
-                        widgets: column.widgets?.map((widget) => ({
-                            id: widget.id,
-                            widgetType: widget.widgetType,
-                            configurationCount: widget.configuration?.length || 0
-                        })) || []
-                    })) || []
-                })) || []
-            };
-            debugLogWithTag('LAYOUT', `Retrieved page layout overview for: ${pageUID}`);
-            return {
-                content: [{ type: "text", text: JSON.stringify(overview, null, 2) }]
-            };
-        }
-        catch (error) {
-            return {
-                content: [{
-                        type: "text",
-                        text: `Error retrieving page layout overview for ${pageUID}: ${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 });
@@ -159,582 +201,163 @@ 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_WIDGET",
-                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_WIDGET",
-                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_WIDGET",
-                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_WIDGET",
-                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_WIDGET",
-                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_WIDGET",
-                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_WIDGET",
-                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_WIDGET",
-                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) }],
-                isError: true
-            };
-        }
-    });
-    server.registerTool("cplace_get_embedded_layout", {
-        description: "Get the widget layout structure of an embedded widget within a container widget on a specific page. This endpoint accesses nested widget layouts embedded within other widgets, such as AttributesGroup widgets.",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page containing the container widget"),
-            containerWidgetId: z.string().describe("The ID of the container widget that contains the embedded layout"),
-            layoutAttributeName: z.string().describe("The name of the attribute that defines the embedded layout structure")
-        },
-        annotations: { title: "Get Embedded Layout" }
-    }, async ({ pageUID, containerWidgetId, layoutAttributeName }) => {
-        debugLogWithTag('EMBEDDED_LAYOUT', `Starting embedded widget layout request for container ${containerWidgetId} in page ${pageUID}`);
-        try {
-            const result = await client.makeApiRequest('json/page/embeddedWidgetLayout', 'GET', {
-                pageUID,
-                containerWidgetId,
-                layoutAttributeName
-            });
-            debugLogWithTag('EMBEDDED_LAYOUT', `Retrieved embedded widget layout for container: ${containerWidgetId}`);
-            return {
-                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-            };
-        }
         catch (error) {
             return {
                 content: [{
                         type: "text",
-                        text: `Error retrieving embedded widget layout: ${error instanceof Error ? error.message : String(error)}`
+                        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_embedded_layout", {
-        description: "Add a new widget to an embedded layout within a container widget. This enables adding widgets to nested layouts like those within AttributesGroup widgets.\n\nSAME LIMITATIONS AS PAGE LAYOUTS:\n- Column creation: ❌ Never happens via widget placement\n- Invalid columnIndex falls back to last existing column\n- Can only add widgets to existing column structures in embedded layouts",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page containing the container widget"),
-            containerWidgetId: z.string().describe("The ID of the container widget that contains the embedded layout to modify"),
-            layoutAttributeName: z.string().describe("The name of the attribute that defines the embedded layout structure"),
-            widgetType: z.string().describe("Widget type identifier (e.g., 'cf.cplace.platform.table', 'cf.platform.wiki')"),
-            position: PositionSchema.extend({}).describe("Position where the widget should be added in the embedded layout"),
-            configuration: z.record(z.any()).optional().describe(`Widget configuration as key-value pairs. ${WIDGET_CONFIG_DESCRIPTION}
-
-Examples: {'title': {'en': 'Embedded Widget', 'de': 'Eingebettetes Widget'}, 'showHeader': true}`)
-        },
-        annotations: { title: "Add Widget to Embedded Layout" }
-    }, async ({ pageUID, containerWidgetId, layoutAttributeName, widgetType, position, configuration }) => {
-        debugLogWithTag('EMBEDDED_LAYOUT_ADD', `Starting add widget to embedded layout: ${widgetType} to container ${containerWidgetId} in page ${pageUID}`);
-        try {
-            const operation = {
-                type: "ADD",
-                widgetType,
-                position
-            };
-            if (configuration && Object.keys(configuration).length > 0) {
-                operation.configuration = configuration;
-                debugLogWithTag('EMBEDDED_LAYOUT_ADD', `Including configuration: ${JSON.stringify(Object.keys(configuration))}`);
-            }
-            const requestBody = {
-                pageUID,
-                containerWidgetId,
-                layoutAttributeName,
-                operation
-            };
-            debugLogWithTag('EMBEDDED_LAYOUT_ADD', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
-            const result = await client.makeApiRequest('json/page/embeddedWidgetLayout', 'PATCH', undefined, requestBody);
-            debugLogWithTag('EMBEDDED_LAYOUT_ADD', `Successfully added widget ${widgetType} to embedded layout`);
-            const response = {
-                operation: "ADD_EMBEDDED_WIDGET",
-                status: "SUCCESS",
-                pageUID,
-                containerWidgetId,
-                layoutAttributeName,
-                widgetType,
-                position,
-                message: "Widget added successfully to embedded layout"
-            };
+    const EmbeddedLayoutContextSchema = 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");
+    function determineEmbeddedApiEndpoint(context) {
+        return context.type === "page"
+            ? "json/page/embeddedWidgetLayout"
+            : "json/type/embeddedWidgetLayout";
+    }
+    function buildEmbeddedRequestParams(context, additionalParams = {}) {
+        const commonParams = {
+            containerWidgetId: context.containerWidgetId,
+            layoutAttributeName: context.layoutAttributeName,
+            ...additionalParams
+        };
+        if (context.type === "page") {
             return {
-                content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+                pageUID: context.pageUID,
+                ...commonParams
             };
         }
-        catch (error) {
-            debugLogWithTag('EMBEDDED_LAYOUT_ADD', `Error adding widget to embedded layout: ${error instanceof Error ? error.message : String(error)}`);
-            const errorResponse = {
-                operation: "ADD_EMBEDDED_WIDGET",
-                status: "ERROR",
-                pageUID,
-                containerWidgetId,
-                layoutAttributeName,
-                widgetType,
-                position,
-                error: error instanceof Error ? error.message : String(error),
-                message: "Failed to add widget to embedded layout"
-            };
+        else {
             return {
-                content: [{ type: "text", text: JSON.stringify(errorResponse, null, 2) }],
-                isError: true
+                workspaceId: context.workspaceId,
+                typeInternalName: context.typeInternalName,
+                ...(context.alternativeLayoutName && { alternativeLayoutName: context.alternativeLayoutName }),
+                ...commonParams
             };
         }
-    });
-    server.registerTool("cplace_remove_widget_from_embedded_layout", {
-        description: "Remove an existing widget from an embedded layout within a container widget. This enables removing widgets from nested layouts like those within AttributesGroup widgets.",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page containing the container widget"),
-            containerWidgetId: z.string().describe("The ID of the container widget that contains the embedded layout to modify"),
-            layoutAttributeName: z.string().describe("The name of the attribute that defines the embedded layout structure"),
-            widgetId: z.string().describe("The ID of the existing widget to remove from the embedded layout")
-        },
-        annotations: { title: "Remove Widget from Embedded Layout" }
-    }, async ({ pageUID, containerWidgetId, layoutAttributeName, widgetId }) => {
-        debugLogWithTag('EMBEDDED_LAYOUT_REMOVE', `Starting remove widget from embedded layout: ${widgetId} from container ${containerWidgetId} in page ${pageUID}`);
+    }
+    function normalizeEmbeddedResponse(result, operation) {
+        const operationVerb = operation === "ADD" ? "added" : "removed";
+        return `Widget ${operationVerb} successfully`;
+    }
+    server.registerTool(TOOL_GET_EMBEDDED_LAYOUT, WIDGET_TOOL_DEFINITIONS[TOOL_GET_EMBEDDED_LAYOUT], async ({ context }) => {
         try {
-            const requestBody = {
-                pageUID,
-                containerWidgetId,
-                layoutAttributeName,
-                operation: {
-                    type: "REMOVE",
-                    widgetId
-                }
-            };
-            debugLogWithTag('EMBEDDED_LAYOUT_REMOVE', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
-            const result = await client.makeApiRequest('json/page/embeddedWidgetLayout', 'PATCH', undefined, requestBody);
-            debugLogWithTag('EMBEDDED_LAYOUT_REMOVE', `Successfully removed widget ${widgetId} from embedded layout`);
-            const response = {
-                operation: "REMOVE_EMBEDDED_WIDGET",
-                status: "SUCCESS",
-                pageUID,
-                containerWidgetId,
-                layoutAttributeName,
-                widgetId,
-                message: "Widget removed successfully from embedded layout"
-            };
+            debugLogWithTag('EMBEDDED_LAYOUT', `Getting embedded layout for ${context.type} context: ${JSON.stringify({ context, endpoint: determineEmbeddedApiEndpoint(context) })}`);
+            const endpoint = determineEmbeddedApiEndpoint(context);
+            const requestParams = buildEmbeddedRequestParams(context);
+            const result = await client.makeApiRequest(endpoint, 'GET', requestParams);
+            debugLogWithTag('EMBEDDED_LAYOUT', `Successfully retrieved embedded layout for ${context.type} context: ${JSON.stringify({ context, hasResult: !!result })}`);
             return {
-                content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+                content: [{
+                        type: "text",
+                        text: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
+                    }]
             };
         }
         catch (error) {
-            debugLogWithTag('EMBEDDED_LAYOUT_REMOVE', `Error removing widget from embedded layout: ${error instanceof Error ? error.message : String(error)}`);
-            const errorResponse = {
-                operation: "REMOVE_EMBEDDED_WIDGET",
-                status: "ERROR",
-                pageUID,
-                containerWidgetId,
-                layoutAttributeName,
-                widgetId,
-                error: error instanceof Error ? error.message : String(error),
-                message: "Failed to remove widget from embedded layout"
-            };
+            debugLogWithTag('EMBEDDED_LAYOUT', `Failed to get embedded layout for ${context.type} context: ${JSON.stringify({ context, error: error instanceof Error ? error.message : String(error) })}`);
             return {
-                content: [{ type: "text", text: JSON.stringify(errorResponse, null, 2) }],
+                content: [{
+                        type: "text",
+                        text: `Failed to get embedded layout: ${error instanceof Error ? error.message : String(error)}`
+                    }],
                 isError: true
             };
         }
     });
-    server.registerTool("cplace_compact_page_layout", {
-        description: "Remove all empty rows from a page layout, effectively compacting the layout by keeping only rows that contain widgets. This operation automatically identifies and removes rows where all columns have no widgets while preserving the order and content of non-empty rows and maintaining all widget configurations and positions.",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page to compact the layout for")
-        },
-        annotations: { title: "Compact Page Layout" }
-    }, async ({ pageUID }) => {
-        debugLogWithTag('LAYOUT_MODIFY', `Starting compact layout operation for page ${pageUID}`);
+    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);
+            const requestParams = buildEmbeddedRequestParams(context);
+            const operationType = "ADD";
             const requestBody = {
-                pageUID,
+                ...requestParams,
                 operation: {
-                    type: "COMPACT"
+                    type: operationType,
+                    widgetType,
+                    position,
+                    ...(configuration && Object.keys(configuration).length > 0 && { configuration })
                 }
             };
-            debugLogWithTag('LAYOUT_MODIFY', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
-            const result = await client.makeApiRequest('json/pageLayout', 'PATCH', undefined, requestBody);
-            debugLogWithTag('LAYOUT_MODIFY', `Successfully compacted layout for page ${pageUID}`);
-            let emptyRowsRemoved = 0;
-            try {
-                const originalLayoutResult = await client.makeApiRequest('json/pageLayout', 'GET', { pageUID });
-                const originalLayout = JSON.parse(originalLayoutResult.result || '{}');
-                const originalRowCount = originalLayout.rows ? originalLayout.rows.length : 0;
-                const compactedLayoutString = result.result;
-                const compactedLayout = JSON.parse(compactedLayoutString);
-                const compactedRowCount = compactedLayout.rows ? compactedLayout.rows.length : 0;
-                emptyRowsRemoved = Math.max(0, originalRowCount - compactedRowCount);
-            }
-            catch (parseError) {
-                debugLogWithTag('LAYOUT_MODIFY', `Could not calculate compaction statistics: ${parseError}`);
-            }
-            const response = {
-                operation: "COMPACT_LAYOUT",
-                status: "SUCCESS",
-                pageUID,
-                emptyRowsRemoved,
-                message: emptyRowsRemoved > 0
-                    ? `Layout compacted successfully - removed ${emptyRowsRemoved} empty row${emptyRowsRemoved === 1 ? '' : 's'}`
-                    : "Layout was already compact - no empty rows found"
-            };
+            debugLogWithTag('EMBEDDED_LAYOUT_ADD', `Sending ADD request to ${endpoint}: ${JSON.stringify({ context, operationType, requestBodyKeys: Object.keys(requestBody) })}`);
+            const result = await client.makeApiRequest(endpoint, 'PATCH', undefined, requestBody);
+            debugLogWithTag('EMBEDDED_LAYOUT_ADD', `Successfully added widget to ${context.type} embedded layout: ${JSON.stringify({ context, widgetType, success: true })}`);
             return {
-                content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+                content: [{
+                        type: "text",
+                        text: normalizeEmbeddedResponse(result, "ADD")
+                    }]
             };
         }
         catch (error) {
-            debugLogWithTag('LAYOUT_MODIFY', `Error compacting layout: ${error instanceof Error ? error.message : String(error)}`);
-            const errorResponse = {
-                operation: "COMPACT_LAYOUT",
-                status: "ERROR",
-                pageUID,
-                error: error instanceof Error ? error.message : String(error),
-                message: "Failed to compact layout"
-            };
+            debugLogWithTag('EMBEDDED_LAYOUT_ADD', `Failed to add widget to ${context.type} embedded layout: ${JSON.stringify({ context, widgetType, error: error instanceof Error ? error.message : String(error) })}`);
             return {
-                content: [{ type: "text", text: JSON.stringify(errorResponse, null, 2) }],
+                content: [{
+                        type: "text",
+                        text: `Failed to add widget: ${error instanceof Error ? error.message : String(error)}`
+                    }],
                 isError: true
             };
         }
     });
-    server.registerTool("cplace_add_row_to_page_layout", {
-        description: "Create a new row with specific column layout in a page layout.\n\n⭐ ESSENTIAL FOR MULTI-COLUMN LAYOUTS ⭐\nThis is the ONLY way to create multi-column structures. Widget placement alone cannot create columns.\n\nCOMMON WORKFLOW:\n1. Use this tool to create desired column structure (e.g., [6,6] for side-by-side)\n2. Use cplace_add_widget_to_layout to place widgets in the columns\n3. Use cplace_compact_page_layout to remove any empty rows\n\nROW INSERTION BEHAVIOR:\n- rowIndex < existing rows: Inserts and shifts others down\n- rowIndex >= existing rows: Appends at end\n\nCOLUMN PROPORTIONS (must sum to 12):\n- [12]: Single full-width column\n- [6, 6]: Two equal columns (most common for side-by-side)\n- [4, 4, 4]: Three equal columns\n- [3, 9]: Sidebar + main content\n- [2, 8, 2]: Content with sidebars",
-        inputSchema: {
-            pageUID: z.string().describe("The unique identifier (UID) of the page to add the row to"),
-            rowIndex: z.number().min(0).describe("Row index where to insert the new row (0-based). If rowIndex >= current row count, adds at the end. Otherwise, inserts at position and shifts existing rows down."),
-            columnProportions: z.array(z.number().min(1)).min(1).describe("Array of column width proportions that must sum to 12 (Bootstrap grid system). Examples: [12] (single column), [6,6] (two equal columns), [4,4,4] (three equal columns), [3,9] (sidebar + main)")
-        },
-        annotations: { title: "Add Row to Page Layout" }
-    }, async ({ pageUID, rowIndex, columnProportions }) => {
-        debugLogWithTag('LAYOUT_MODIFY', `Starting add row operation: row ${rowIndex} with proportions ${JSON.stringify(columnProportions)} to page ${pageUID}`);
+    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);
+            const requestParams = buildEmbeddedRequestParams(context);
+            const operationType = "REMOVE";
             const requestBody = {
-                pageUID,
+                ...requestParams,
                 operation: {
-                    type: "ADD_ROW",
-                    rowIndex,
-                    columnProportions
-                }
-            };
-            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 row ${rowIndex} with ${columnProportions.length} columns to page ${pageUID}`);
-            const columnsCreated = columnProportions.length;
-            const columnSum = columnProportions.reduce((sum, prop) => sum + prop, 0);
-            let insertionType = "appended";
-            try {
-                const layoutString = result.result;
-                const layout = JSON.parse(layoutString);
-                if (layout.rows && layout.rows.length > rowIndex + 1) {
-                    insertionType = "inserted";
+                    type: operationType,
+                    widgetId
                 }
-            }
-            catch (parseError) {
-                debugLogWithTag('LAYOUT_MODIFY', `Could not determine insertion type: ${parseError}`);
-            }
-            const response = {
-                operation: "ADD_ROW",
-                status: "SUCCESS",
-                pageUID,
-                rowIndex,
-                columnProportions,
-                columnsCreated,
-                insertionType,
-                message: insertionType === "inserted"
-                    ? `Row added successfully at index ${rowIndex} with ${columnsCreated} column${columnsCreated === 1 ? '' : 's'} [${columnProportions.join(',')}]`
-                    : `Row added successfully at end with ${columnsCreated} column${columnsCreated === 1 ? '' : 's'} [${columnProportions.join(',')}]`
             };
+            debugLogWithTag('EMBEDDED_LAYOUT_REMOVE', `Sending REMOVE request to ${endpoint}: ${JSON.stringify({ context, operationType, widgetId })}`);
+            const result = await client.makeApiRequest(endpoint, 'PATCH', undefined, requestBody);
+            debugLogWithTag('EMBEDDED_LAYOUT_REMOVE', `Successfully removed widget from ${context.type} embedded layout: ${JSON.stringify({ context, widgetId, success: true })}`);
             return {
-                content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+                content: [{
+                        type: "text",
+                        text: normalizeEmbeddedResponse(result, "REMOVE")
+                    }]
             };
         }
         catch (error) {
-            debugLogWithTag('LAYOUT_MODIFY', `Error adding row: ${error instanceof Error ? error.message : String(error)}`);
-            const errorResponse = {
-                operation: "ADD_ROW",
-                status: "ERROR",
-                pageUID,
-                rowIndex,
-                columnProportions,
-                error: error instanceof Error ? error.message : String(error),
-                message: "Failed to add row"
-            };
+            debugLogWithTag('EMBEDDED_LAYOUT_REMOVE', `Failed to remove widget from ${context.type} embedded layout: ${JSON.stringify({ context, widgetId, error: error instanceof Error ? error.message : String(error) })}`);
             return {
-                content: [{ type: "text", text: JSON.stringify(errorResponse, null, 2) }],
+                content: [{
+                        type: "text",
+                        text: `Failed to remove widget: ${error instanceof Error ? error.message : String(error)}`
+                    }],
                 isError: true
             };
         }