@elementor/editor-canvas 4.3.0-999 → 4.3.0-beta1

package/src/mcp/mcp-description.ts

@@ -3,7 +3,7 @@ import { WIDGET_SCHEMA_URI } from './resources/widgets-schema-resource';
 const ELEMENT_SCHEMA_URI = WIDGET_SCHEMA_URI.replace( '{widgetType}', 'element-schema' );
 
 export const mcpDescription = `Elementor Canvas MCP
-This MCP enables creation, configuration, and styling of elements on the Elementor canvas using the build_composition tool.
+This MCP enables configuration and styling of existing V4 elements on the Elementor canvas using the configure-element tool.
 
 # Core Concepts
 
@@ -22,66 +22,54 @@ The \`$$type\` defines how Elementor interprets the value. Providing the correct
 - **Global Classes**: Reusable style sets that can be applied to elements (\`elementor://global-classes\`)
 - **Widget Schemas**: Configuration options for each widget type (\`${ WIDGET_SCHEMA_URI }\`)
 
-# Building Compositions with build_composition
+# Configuring Elements with configure-element
 
-The \`build_composition\` tool is the primary way to create elements. It accepts structure (XML), configuration, and styling in a single operation.
+The \`configure-element\` tool updates settings and styles on existing V4 elements. Read the configure-element guide resource before use.
 
 ## Complete Workflow
 
 ### 1. Parse User Requirements
-Understand what needs to be built: structure, content, and styling.
+Understand what needs to change: content, settings, or styling on existing elements.
 
 ### 2. Check Global Resources FIRST
-Always check existing resources before building:
+Always check existing resources before styling:
 - List \`elementor://global-variables\` for available variables (colors, sizes, fonts)
 - List \`elementor://global-classes\` for available style sets
 - **Always prefer using existing global resources over creating inline styles**
 
 ### 3. Retrieve Widget Schemas
-For each widget you'll use:
+For each element you will configure:
 - List \`${ WIDGET_SCHEMA_URI }\` to see available widgets
 - Retrieve configuration schema from \`${ ELEMENT_SCHEMA_URI }\` for each widget
-- Check the \`llm_guidance\` property for container nesting, \`default_styles\`, and \`default_settings\` (omit default_settings from elementConfig unless the user asks to change them)
+- Check the \`llm_guidance\` property for container nesting, \`default_styles\`, and \`default_settings\`
 
-### 4. Build XML Structure
-Create valid XML with configuration-ids:
-- Each element must have a unique \`configuration-id\` attribute
-- No text nodes, classes, or IDs in XML - structure only
-- Example:
-\`\`\`xml
-<e-container configuration-id="container-1">
-  <e-heading configuration-id="heading-1" />
-  <e-text configuration-id="text-1" />
-</e-container>
-\`\`\`
+### 4. Get Current Element State
+Use page structure and element configuration resources to find element IDs and current values.
 
-### 5. Create elementConfig
-Map each configuration-id to its widget properties using PropValues:
+### 5. Create propertiesToChange
+Map property names to PropValues using the widget schema:
 - Use correct \`$$type\` matching the widget's schema
 - Use global variables in PropValues where applicable
 - Example:
 \`\`\`json
 {
-  "heading-1": {
-    "text": { "$$type": "string", "value": "Welcome" },
-    "tag": { "$$type": "string", "value": "h1" }
-  }
+  "text": { "$$type": "string", "value": "Welcome" },
+  "tag": { "$$type": "string", "value": "h1" }
 }
 \`\`\`
 
 ### 6. Create style
-Map each configuration-id to raw CSS declarations (property → value strings). The server converts them to native styles and stores any unconvertible declarations as the element custom CSS.
+Provide raw CSS declarations (property → value strings). The server converts them to native styles and stores any unconvertible declarations as the element custom CSS.
 - Example:
 \`\`\`json
 {
-  "heading-1": "color: #1a1a1a; font-size: 2rem;"
-  }
+  "color": "#1a1a1a",
+  "font-size": "2rem"
 }
 \`\`\`
 
-### 7. Execute build_composition
-Call the tool with your XML structure, elementConfig, and style. The response will contain the created element IDs.
-At the response you will also find llm_instructions for you to do afterwards, read and follow them!
+### 7. Execute configure-element
+Call the tool with elementId, elementType, propertiesToChange, and style as needed.
 
 ## Key Points
 

package/src/mcp/resources/__tests__/available-widgets-resource.test.ts

@@ -28,14 +28,16 @@ describe( 'available-widgets-resource', () => {
 		jest.clearAllMocks();
 	} );
 
-	it( 'fetches all widgets via list-widgets without a version filter', async () => {
+	it( 'fetches all widgets via list-widget-schemas with summary=true', async () => {
 		// Arrange
 		const post = jest.fn().mockResolvedValue( {
 			data: {
-				data: [
-					{ type: 'e-heading', version: 'v4' },
-					{ type: 'legacy-icon', version: 'v3' },
-				],
+				data: {
+					widgets: [
+						{ type: 'e-heading', description: 'A heading widget' },
+						{ type: 'e-button', description: 'A button widget' },
+					],
+				},
 			},
 		} );
 		mockedHttpService.mockReturnValue( { post } as never );
@@ -45,16 +47,21 @@ describe( 'available-widgets-resource', () => {
 		const result = await allHandler();
 
 		// Assert
-		expect( post ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', { tool: 'list-widgets', input: {} } );
+		expect( post ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', {
+			tool: 'list-widget-schemas',
+			input: { summary: true },
+		} );
 		expect( JSON.parse( result.contents[ 0 ].text ) ).toEqual( [
-			{ type: 'e-heading', version: 'v4' },
-			{ type: 'legacy-icon', version: 'v3' },
+			{ type: 'e-heading', description: 'A heading widget' },
+			{ type: 'e-button', description: 'A button widget' },
 		] );
 	} );
 
-	it( 'fetches only v4 widgets via list-widgets with a version filter', async () => {
+	it( 'fetches v4 widgets via list-widget-schemas with summary=true', async () => {
 		// Arrange
-		const post = jest.fn().mockResolvedValue( { data: { data: [ { type: 'e-heading', version: 'v4' } ] } } );
+		const post = jest.fn().mockResolvedValue( {
+			data: { data: { widgets: [ { type: 'e-heading', description: 'A heading widget' } ] } },
+		} );
 		mockedHttpService.mockReturnValue( { post } as never );
 		const { v4Handler } = captureHandlers();
 
@@ -63,10 +70,12 @@ describe( 'available-widgets-resource', () => {
 
 		// Assert
 		expect( post ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', {
-			tool: 'list-widgets',
-			input: { version: 'v4' },
+			tool: 'list-widget-schemas',
+			input: { summary: true },
 		} );
-		expect( JSON.parse( result.contents[ 0 ].text ) ).toEqual( [ { type: 'e-heading', version: 'v4' } ] );
+		expect( JSON.parse( result.contents[ 0 ].text ) ).toEqual( [
+			{ type: 'e-heading', description: 'A heading widget' },
+		] );
 	} );
 
 	it( 'exposes the expected resource URIs', () => {

package/src/mcp/resources/__tests__/dynamic-tags-resource.test.ts

@@ -19,7 +19,7 @@ const captureHandler = (): ResourceHandler => {
 const readCatalog = async () => {
 	const handler = captureHandler();
 	const result = await handler( new URL( DYNAMIC_TAGS_URI ) );
-	return JSON.parse( result.contents[ 0 ].text );
+	return result.contents[ 0 ].text;
 };
 
 describe( 'dynamic-tags-resource', () => {
@@ -27,31 +27,9 @@ describe( 'dynamic-tags-resource', () => {
 		jest.clearAllMocks();
 	} );
 
-	it( 'returns the flat tag list fetched from the server', async () => {
+	it( 'returns the json string fetched from the server', async () => {
 		// Arrange
-		const post = jest.fn().mockResolvedValue( {
-			data: {
-				data: [
-					{
-						name: 'post-custom-field',
-						label: 'Post Custom Field',
-						categories: [ 'text', 'url' ],
-						settings: { key: { mocked: true }, before: { mocked: true } },
-					},
-				],
-			},
-		} );
-		mockedHttpService.mockReturnValue( { post } as never );
-
-		// Act
-		const catalog = await readCatalog();
-
-		// Assert
-		expect( post ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', {
-			tool: 'list-dynamic-tags',
-			input: {},
-		} );
-		expect( catalog ).toEqual( [
+		const serverJson = JSON.stringify( [
 			{
 				name: 'post-custom-field',
 				label: 'Post Custom Field',
@@ -59,17 +37,31 @@ describe( 'dynamic-tags-resource', () => {
 				settings: { key: { mocked: true }, before: { mocked: true } },
 			},
 		] );
+
+		const get = jest.fn().mockResolvedValue( {
+			data: { data: serverJson },
+		} );
+		mockedHttpService.mockReturnValue( { get } as never );
+
+		// Act
+		const text = await readCatalog();
+
+		// Assert
+		expect( get ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', {
+			params: { uri: DYNAMIC_TAGS_URI },
+		} );
+		expect( text ).toBe( serverJson );
 	} );
 
-	it( 'returns an empty list when the server returns no data', async () => {
+	it( 'returns an empty json array string when the server returns no data', async () => {
 		// Arrange
-		const post = jest.fn().mockResolvedValue( { data: {} } );
-		mockedHttpService.mockReturnValue( { post } as never );
+		const get = jest.fn().mockResolvedValue( { data: {} } );
+		mockedHttpService.mockReturnValue( { get } as never );
 
 		// Act
-		const catalog = await readCatalog();
+		const text = await readCatalog();
 
 		// Assert
-		expect( catalog ).toEqual( [] );
+		expect( text ).toBe( '[]' );
 	} );
 } );

package/src/mcp/resources/__tests__/widgets-schema-resource.test.ts

@@ -40,14 +40,16 @@ describe( 'widgets-schema-resource', () => {
 		jest.clearAllMocks();
 	} );
 
-	it( 'lists widget types fetched from the server via the list-widgets tool', async () => {
+	it( 'lists widget types fetched from the server via list-widget-schemas with summary=true', async () => {
 		// Arrange
 		const post = jest.fn().mockResolvedValue( {
 			data: {
-				data: [
-					{ type: 'e-heading', version: 'v4' },
-					{ type: 'e-button', version: 'v4' },
-				],
+				data: {
+					widgets: [
+						{ type: 'e-heading', description: 'A heading widget' },
+						{ type: 'e-button', description: 'A button widget' },
+					],
+				},
 			},
 		} );
 		mockedHttpService.mockReturnValue( { post } as never );
@@ -57,7 +59,10 @@ describe( 'widgets-schema-resource', () => {
 		const result = await list();
 
 		// Assert
-		expect( post ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', { tool: 'list-widgets', input: {} } );
+		expect( post ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', {
+			tool: 'list-widget-schemas',
+			input: { summary: true },
+		} );
 		expect( result.resources ).toEqual( [
 			{ uri: 'elementor://widgets/schema/e-heading', name: 'Widget schema for e-heading' },
 			{ uri: 'elementor://widgets/schema/e-button', name: 'Widget schema for e-button' },

package/src/mcp/resources/available-widgets-resource.ts

@@ -8,21 +8,24 @@ export const AVAILABLE_WIDGETS_URI_V4 = 'elementor://context/available-widgets/v
 
 type WidgetSummary = {
 	type: string;
-	version: 'v3' | 'v4';
 	description?: string;
 };
 
-const fetchWidgets = async ( version?: WidgetSummary[ 'version' ] ): Promise< WidgetSummary[] > => {
-	const { data } = await httpService().post< HttpResponse< WidgetSummary[] > >( MCP_PROXY_URL, {
-		tool: 'list-widgets',
-		input: version ? { version } : {},
+type WidgetSummaryResponse = {
+	widgets: WidgetSummary[];
+};
+
+const fetchWidgets = async (): Promise< WidgetSummary[] > => {
+	const { data } = await httpService().post< HttpResponse< WidgetSummaryResponse > >( MCP_PROXY_URL, {
+		tool: 'list-widget-schemas',
+		input: { summary: true },
 	} );
 
-	return data.data ?? [];
+	return data.data?.widgets ?? [];
 };
 
-const buildContents = async ( uri: string, version?: WidgetSummary[ 'version' ] ) => {
-	const widgets = await fetchWidgets( version );
+const buildContents = async ( uri: string ) => {
+	const widgets = await fetchWidgets();
 
 	return {
 		contents: [
@@ -44,14 +47,14 @@ export const initAvailableWidgetsResource = ( reg: MCPRegistryEntry ) => {
 		{
 			description: 'All registered v4 version widgets',
 		},
-		async () => buildContents( AVAILABLE_WIDGETS_URI_V4, 'v4' )
+		async () => buildContents( AVAILABLE_WIDGETS_URI_V4 )
 	);
 
 	resource(
 		'available-widgets',
 		AVAILABLE_WIDGETS_URI,
 		{
-			description: 'All registered widget types with v3/v4 version metadata and description.',
+			description: 'All registered v4 widget types with description.',
 		},
 		async () => buildContents( AVAILABLE_WIDGETS_URI )
 	);

package/src/mcp/resources/dynamic-tags-resource.ts

@@ -5,20 +5,13 @@ export const DYNAMIC_TAGS_URI = 'elementor://dynamic-tags';
 
 const MCP_PROXY_URL = 'elementor/v1/mcp-proxy';
 
-type DynamicTagEntry = {
-	name: string;
-	label: string;
-	categories: string[];
-	settings: Record< string, unknown >;
-};
-
-const fetchDynamicTags = async (): Promise< DynamicTagEntry[] > => {
-	const { data } = await httpService().post< HttpResponse< DynamicTagEntry[] > >( MCP_PROXY_URL, {
-		tool: 'list-dynamic-tags',
-		input: {},
+// NOTE: JSON-encoded array of dynamic tag entries; shape defined by List_Dynamic_Tags_Ability::execute() in modules/mcp/abilities/list-dynamic-tags-ability.php
+const fetchDynamicTags = async (): Promise< string > => {
+	const { data } = await httpService().get< HttpResponse< string > >( MCP_PROXY_URL, {
+		params: { uri: DYNAMIC_TAGS_URI },
 	} );
 
-	return data.data ?? [];
+	return data.data ?? '[]';
 };
 
 export const initDynamicTagsResource = ( reg: MCPRegistryEntry ) => {
@@ -35,14 +28,12 @@ export const initDynamicTagsResource = ( reg: MCPRegistryEntry ) => {
 			mimeType: 'application/json',
 		},
 		async ( uri: URL ) => {
-			const tags = await fetchDynamicTags();
-
 			return {
 				contents: [
 					{
 						uri: uri.href,
 						mimeType: 'application/json',
-						text: JSON.stringify( tags ),
+						text: await fetchDynamicTags(),
 					},
 				],
 			};

package/src/mcp/resources/widgets-schema-resource.ts

@@ -13,17 +13,20 @@ const MCP_PROXY_URL = 'elementor/v1/mcp-proxy';
 
 type WidgetSummary = {
 	type: string;
-	version: 'v3' | 'v4';
 	description?: string;
 };
 
+type WidgetSummaryResponse = {
+	widgets: WidgetSummary[];
+};
+
 const listWidgetTypes = async (): Promise< string[] > => {
-	const { data } = await httpService().post< HttpResponse< WidgetSummary[] > >( MCP_PROXY_URL, {
-		tool: 'list-widgets',
-		input: {},
+	const { data } = await httpService().post< HttpResponse< WidgetSummaryResponse > >( MCP_PROXY_URL, {
+		tool: 'list-widget-schemas',
+		input: { summary: true },
 	} );
 
-	return ( data.data ?? [] ).map( ( widget ) => widget.type );
+	return ( data.data?.widgets ?? [] ).map( ( widget ) => widget.type );
 };
 
 const fetchWidgetSchema = async ( widgetType: string ): Promise< Record< string, unknown > > => {

package/src/mcp/tools/configure-element/__tests__/tool.test.ts

@@ -0,0 +1,130 @@
+import { getContainer, getWidgetsCache } from '@elementor/editor-elements';
+
+import { doUpdateElementProperty, UnsupportedPropertyError } from '../../../utils/do-update-element-property';
+import { initConfigureElementTool } from '../tool';
+
+jest.mock( '@elementor/editor-elements', () => ( {
+	getContainer: jest.fn(),
+	getWidgetsCache: jest.fn(),
+} ) );
+
+jest.mock( '@elementor/editor-mcp', () => ( {
+	dispatchMcpStylesAppliedEvent: jest.fn(),
+} ) );
+
+jest.mock( '@elementor/editor-props', () => ( {
+	Schema: { isPropKeyConfigurable: () => true },
+} ) );
+
+jest.mock( '../prompt', () => ( {
+	CONFIGURE_ELEMENT_GUIDE_URI: 'configure-element-guide-uri',
+	generatePrompt: () => '',
+} ) );
+
+jest.mock( '../../../resources/widgets-schema-resource', () => ( {
+	WIDGET_SCHEMA_URI: 'elementor://widgets/schema/{widgetType}',
+} ) );
+
+jest.mock( '../../../resources/dynamic-tags-resource', () => ( {
+	DYNAMIC_TAGS_URI: 'elementor://dynamic-tags',
+} ) );
+
+jest.mock( '../../../utils/resolve-canonical-prop-name', () => ( {
+	resolveCanonicalPropKeys: ( _elementType: string, props: Record< string, unknown > ) => props,
+} ) );
+
+jest.mock( '../../../utils/convert-css-to-atomic', () => ( {
+	convertCssToAtomic: jest.fn().mockResolvedValue( { props: {}, customCss: '' } ),
+} ) );
+
+jest.mock( '../../../utils/do-update-element-property', () => ( {
+	...jest.requireActual( '../../../utils/do-update-element-property' ),
+	doUpdateElementProperty: jest.fn(),
+} ) );
+
+const ELEMENT_ID = 'el-1';
+const ELEMENT_TYPE = 'e-youtube';
+
+type Handler = ( params: {
+	elementId: string;
+	elementType: string;
+	propertiesToChange: Record< string, unknown >;
+	style: Record< string, string | null >;
+} ) => Promise< { success: boolean; warnings?: string } >;
+
+const getHandler = (): Handler => {
+	const addTool = jest.fn();
+	initConfigureElementTool( { addTool, resource: jest.fn() } as never );
+	return addTool.mock.calls[ 0 ][ 0 ].handler;
+};
+
+describe( 'configure-element handler unsupported props', () => {
+	beforeEach( () => {
+		jest.mocked( getWidgetsCache ).mockReturnValue( {
+			[ ELEMENT_TYPE ]: { atomic_props_schema: { title: { key: 'title' } } },
+		} as never );
+		jest.mocked( getContainer ).mockReturnValue( {
+			settings: { get: () => ELEMENT_TYPE },
+		} as never );
+		jest.mocked( doUpdateElementProperty ).mockReset();
+	} );
+
+	it( 'skips an unsupported prop, reports it in warnings, and still applies supported props', async () => {
+		// Arrange
+		jest.mocked( doUpdateElementProperty ).mockImplementation( ( { propertyName } ) => {
+			if ( 'link' === propertyName ) {
+				throw new UnsupportedPropertyError( ELEMENT_TYPE, 'link', [ 'title' ] );
+			}
+		} );
+		const handler = getHandler();
+
+		// Act
+		const result = await handler( {
+			elementId: ELEMENT_ID,
+			elementType: ELEMENT_TYPE,
+			propertiesToChange: { title: { $$type: 'string', value: 'Hi' }, link: { $$type: 'link', value: {} } },
+			style: {},
+		} );
+
+		// Assert
+		expect( result.success ).toBe( true );
+		expect( result.warnings ).toContain( 'link' );
+		expect( doUpdateElementProperty ).toHaveBeenCalledTimes( 2 );
+	} );
+
+	it( 'returns no warnings when every prop is supported', async () => {
+		// Arrange
+		jest.mocked( doUpdateElementProperty ).mockImplementation( () => undefined );
+		const handler = getHandler();
+
+		// Act
+		const result = await handler( {
+			elementId: ELEMENT_ID,
+			elementType: ELEMENT_TYPE,
+			propertiesToChange: { title: { $$type: 'string', value: 'Hi' } },
+			style: {},
+		} );
+
+		// Assert
+		expect( result.success ).toBe( true );
+		expect( result.warnings ).toBeUndefined();
+	} );
+
+	it( 'rethrows non-UnsupportedPropertyError failures', async () => {
+		// Arrange
+		jest.mocked( doUpdateElementProperty ).mockImplementation( () => {
+			throw new Error( 'Invalid PropValue' );
+		} );
+		const handler = getHandler();
+
+		// Act & Assert
+		await expect(
+			handler( {
+				elementId: ELEMENT_ID,
+				elementType: ELEMENT_TYPE,
+				propertiesToChange: { title: { $$type: 'string', value: 'Hi' } },
+				style: {},
+			} )
+		).rejects.toThrow( /Invalid PropValue/ );
+	} );
+} );

package/src/mcp/tools/configure-element/prompt.ts

@@ -50,8 +50,6 @@ For all non-primitive entries in \`propertiesToChange\`, provide the schema \`ke
 
 Use the EXACT PropType schema given, and ALWAYS include the \`key\` from the schema for every property you are changing in \`propertiesToChange\`.
 
-Check \`llm_guidance.default_settings\` in the widget schema — include a key in \`propertiesToChange\` only when the user explicitly asks to change it.
-
 # Dynamic tags
 A value can be made dynamic wherever its schema exposes a variant with "$$type": "dynamic". This may be the property root OR a NESTED field: for example an image is made dynamic on its "src" (the root stays "image"), NOT on the whole "image" value.
 Put the dynamic object EXACTLY at the node whose schema offers the "dynamic" variant, in place of the static variant. The variant's "name" enumerates the tags allowed at that node.
@@ -82,7 +80,7 @@ Do NOT send "group" (it is resolved automatically). Use { "settings": {} } only
 
 	configureElementToolPrompt.parameter(
 		'style',
-		'A flat map of raw CSS declarations (property → value), e.g. { "line-height": "1.25rem", "color": "var(--primary-text, #000)" }. Set a value to null to reset that property to its default. OPTIONAL.'
+		'A flat map of raw CSS declarations (property → value), e.g. { "line-height": "1.25rem", "color": "var(--primary-text, #000)" }. font-family must be a single Google Font name or a var(--label) — no fallback stacks. Set a value to null to reset that property to its default. OPTIONAL.'
 	);
 
 	configureElementToolPrompt.example( `
@@ -117,11 +115,10 @@ Do NOT send "group" (it is resolved automatically). Use { "settings": {} } only
 V4 only: If MCP fails, give manual steps using V4 UI.
 
 V4 Editor structure:
-Panel tabs: General (→ Settings section: ID, Tag, Link), Style, Interactions.
+Panel tabs: General (→ Settings section: ID, Tag, and Link where the widget supports it), Style, Interactions.
 NO Advanced tab. Never mention Advanced tab.
+Note: \`link\` is valid only when the element's PropType schema (which you must already have) includes a \`link\` property. Sending \`link\` to a widget whose schema lacks it is skipped and reported in the response \`warnings\` (other changes still apply) and the link is lost.
 ` );
 
 	return configureElementToolPrompt.prompt();
 };
-
-export const CONFIGURE_ELEMENT_GUIDE_TEXT = generatePrompt();

package/src/mcp/tools/configure-element/schema.ts

@@ -36,4 +36,10 @@ export const outputSchema = {
 		.describe(
 			'Whether the configuration change was successful, only if propertyName and propertyValue are provided'
 		),
+	warnings: z
+		.string()
+		.describe(
+			'Non-fatal notices. Present when some props were skipped because they are not in the element schema (e.g. a "link" on a widget with no link prop). Other changes were still applied.'
+		)
+		.optional(),
 };

package/src/mcp/tools/configure-element/tool.ts

@@ -6,7 +6,7 @@ import { type PropValue, Schema } from '@elementor/editor-props';
 import { DYNAMIC_TAGS_URI } from '../../resources/dynamic-tags-resource';
 import { WIDGET_SCHEMA_URI } from '../../resources/widgets-schema-resource';
 import { convertCssToAtomic } from '../../utils/convert-css-to-atomic';
-import { doUpdateElementProperty } from '../../utils/do-update-element-property';
+import { doUpdateElementProperty, UnsupportedPropertyError } from '../../utils/do-update-element-property';
 import { resolveCanonicalPropKeys } from '../../utils/resolve-canonical-prop-name';
 import { CONFIGURE_ELEMENT_GUIDE_URI, generatePrompt } from './prompt';
 import { inputSchema as schema, outputSchema } from './schema';
@@ -61,6 +61,7 @@ export const initConfigureElementTool = ( reg: MCPRegistryEntry ) => {
 			}
 			const propertiesToUpdate = resolveCanonicalPropKeys( elementType, propertiesToChange );
 			const toUpdate = Object.entries( propertiesToUpdate );
+			const skippedProps: string[] = [];
 			for ( const [ propertyName, propertyValue ] of toUpdate as [ string, PropValue ][] ) {
 				if ( ! Schema.isPropKeyConfigurable( propertyName ) ) {
 					throw new Error( `Not allowed to update ${ propertyName }` );
@@ -73,6 +74,10 @@ export const initConfigureElementTool = ( reg: MCPRegistryEntry ) => {
 						propertyValue,
 					} );
 				} catch ( error ) {
+					if ( error instanceof UnsupportedPropertyError ) {
+						skippedProps.push( error.propertyName );
+						continue;
+					}
 					const errorMessage = createUpdateErrorMessage( {
 						propertyName,
 						elementId,
@@ -86,6 +91,11 @@ export const initConfigureElementTool = ( reg: MCPRegistryEntry ) => {
 			await applyStyleFromCss( { elementId, elementType, style } );
 			return {
 				success: true,
+				warnings: skippedProps.length
+					? `Skipped unsupported props (not in the "${ elementType }" schema; other changes were applied): ${ skippedProps.join(
+							', '
+					  ) }.`
+					: undefined,
 			};
 		},
 	} );