@elementor/editor-canvas 4.3.0-991 → 4.3.0-993

package/dist/index.mjs

@@ -2,178 +2,37 @@
 import { v1ReadyEvent } from "@elementor/editor-v1-adapters";
 
 // src/mcp/resources/widgets-schema-resource.ts
-import { getWidgetsCache as getWidgetsCache2 } from "@elementor/editor-elements";
 import { ResourceTemplate } from "@elementor/editor-mcp";
-import {
-  Schema
-} from "@elementor/editor-props";
-
-// src/mcp/utils/element-data-util.ts
-import { getWidgetsCache } from "@elementor/editor-elements";
-function hasV3Controls(controls) {
-  return typeof controls === "object" && controls !== null && Object.keys(controls).length > 0;
-}
-function isWidgetAvailableForLLM(config) {
-  if (!config) {
-    return false;
-  }
-  if (config.meta?.llm_support === false) {
-    return false;
-  }
-  if (config.title === "Component") {
-    return false;
-  }
-  if (config.atomic_props_schema) {
-    return true;
-  }
-  return hasV3Controls(config.controls);
-}
-function getWidgetVersion(config) {
-  return config?.atomic_props_schema ? "v4" : "v3";
-}
-function getAvailableWidgets() {
-  const cache = getWidgetsCache() ?? {};
-  return Object.keys(cache).filter((widgetType) => isWidgetAvailableForLLM(cache[widgetType])).sort().map((widgetType) => {
-    const config = cache[widgetType];
-    const description = typeof config?.meta?.description === "string" ? config.meta.description : void 0;
-    return {
-      type: widgetType,
-      version: getWidgetVersion(config),
-      ...description && { description }
-    };
-  });
-}
-
-// src/composition-builder/utils/required-default-child-tags.ts
-function getRequiredDefaultChildTemplates(elementConfig) {
-  const defaultChildren = elementConfig?.default_children;
-  if (!Array.isArray(defaultChildren)) {
-    return [];
-  }
-  return defaultChildren.filter((child) => child?.meta?.required ?? false);
-}
-function getRequiredDefaultChildTypes(elementConfig) {
-  return getRequiredDefaultChildTemplates(elementConfig).map((child) => child.widgetType ?? child.elType ?? "").filter((type) => Boolean(type));
-}
-
-// src/mcp/resources/build-llm-guidance.ts
-var DEFAULT_STYLES_INSTRUCTION = "These are the default styles applied to the widget. Override only when necessary.";
-var DEFAULT_SETTINGS_INSTRUCTION = "These are the default settings applied to the widget. Omit them from elementConfig unless the user explicitly asks to change them.";
-var BASE_SETTING_PROP_HINT = "Has a widget default \u2014 omit unless user explicitly requests a change. See llm_guidance.default_settings.";
-function mergeInstructions(existing, additional) {
-  if (typeof existing === "string" && existing.length > 0) {
-    return `${existing} ${additional}`;
-  }
-  return additional;
-}
-function enrichPropertiesWithBaseSettingsHints(properties, baseSettingsKeys) {
-  if (!baseSettingsKeys.length) {
-    return properties;
-  }
-  const enriched = { ...properties };
-  for (const key of baseSettingsKeys) {
-    const propSchema = enriched[key];
-    if (!propSchema) {
-      continue;
-    }
-    enriched[key] = {
-      ...propSchema,
-      description: propSchema.description ? `${propSchema.description} ${BASE_SETTING_PROP_HINT}` : BASE_SETTING_PROP_HINT
-    };
-  }
-  return enriched;
-}
-function buildLlmGuidance(widgetData, widgetType, allWidgets) {
-  const defaultStyles = {};
-  const baseStyleSchema = widgetData?.base_styles;
-  if (baseStyleSchema) {
-    Object.values(baseStyleSchema).forEach((stylePropType) => {
-      stylePropType.variants.forEach((variant) => {
-        Object.assign(defaultStyles, variant.props);
-      });
-    });
-  }
-  const baseSettings = widgetData?.base_settings ?? {};
-  const hasDefaultStyles = Object.keys(defaultStyles).length > 0;
-  const hasDefaultSettings = Object.keys(baseSettings).length > 0;
-  const llmGuidance = {
-    can_have_children: !!widgetData?.meta?.is_container
-  };
-  if (hasDefaultStyles) {
-    llmGuidance.instructions = DEFAULT_STYLES_INSTRUCTION;
-    llmGuidance.default_styles = defaultStyles;
-  }
-  if (hasDefaultSettings) {
-    llmGuidance.instructions = mergeInstructions(llmGuidance.instructions, DEFAULT_SETTINGS_INSTRUCTION);
-    llmGuidance.default_settings = baseSettings;
-  }
-  const allowedChildTypes = widgetData.allowed_child_types;
-  const allowedParents = Object.entries(allWidgets).filter(([, parentConfig]) => parentConfig.allowed_child_types?.includes(widgetType)).map(([parentType]) => parentType);
-  if (allowedChildTypes?.length || allowedParents.length) {
-    llmGuidance.nesting = {
-      ...allowedChildTypes?.length ? { allowed_child_types: allowedChildTypes } : {},
-      ...allowedParents.length ? { allowed_parents: allowedParents } : {}
-    };
-  }
-  const requiredDirectChildTags = getRequiredDefaultChildTypes(widgetData);
-  if (requiredDirectChildTags.length) {
-    llmGuidance.required_direct_children = requiredDirectChildTags;
-  }
-  return llmGuidance;
-}
-
-// src/mcp/resources/widgets-schema-resource.ts
-var V3_LAYOUT_CONTROL_TYPES = /* @__PURE__ */ new Set(["section", "tab", "tabs"]);
-function extractV3ControlsMetadata(controls) {
-  if (!hasV3Controls(controls)) {
-    return {};
-  }
-  const result = {};
-  for (const [controlKey, raw] of Object.entries(controls)) {
-    if (!raw || typeof raw !== "object") {
-      continue;
-    }
-    const control = raw;
-    const controlType = typeof control.type === "string" ? control.type : void 0;
-    if (controlType && V3_LAYOUT_CONTROL_TYPES.has(controlType)) {
-      continue;
-    }
-    const entry = {};
-    if (Object.prototype.hasOwnProperty.call(control, "default")) {
-      entry.default = control.default;
-    }
-    if (controlType) {
-      entry.type = controlType;
-    }
-    if (Object.prototype.hasOwnProperty.call(control, "options") && control.options !== void 0) {
-      const options = control.options;
-      if (options && typeof options === "object" && !Array.isArray(options)) {
-        entry.options = Object.keys(options);
-      } else {
-        entry.options = options;
-      }
-    }
-    result[controlKey] = entry;
-  }
-  return result;
-}
+import { httpService } from "@elementor/http-client";
 var CANVAS_SERVER_NAME = "editor-canvas";
 var WIDGET_SCHEMA_URI = "elementor://widgets/schema/{widgetType}";
 var WIDGET_SCHEMA_FULL_URI = `${CANVAS_SERVER_NAME}_${WIDGET_SCHEMA_URI}`;
 var BEST_PRACTICES_URI = "elementor://style/best-practices";
 var BEST_PRACTICES_FULL_URI = `${CANVAS_SERVER_NAME}_${BEST_PRACTICES_URI}`;
+var MCP_PROXY_URL = "elementor/v1/mcp-proxy";
+var listWidgetTypes = async () => {
+  const { data } = await httpService().post(MCP_PROXY_URL, {
+    tool: "list-widgets",
+    input: {}
+  });
+  return (data.data ?? []).map((widget) => widget.type);
+};
+var fetchWidgetSchema = async (widgetType) => {
+  const { data } = await httpService().post(MCP_PROXY_URL, {
+    tool: "get-widget-schema",
+    input: { widget_type: widgetType }
+  });
+  return data.data ?? {};
+};
 var initWidgetsSchemaResource = (reg) => {
   const { resource } = reg;
   resource(
     "widget-schema-by-type",
     new ResourceTemplate(WIDGET_SCHEMA_URI, {
-      list: () => {
-        const cache = getWidgetsCache2() || {};
-        const availableWidgets = Object.keys(cache).filter(
-          (widgetType) => isWidgetAvailableForLLM(cache[widgetType])
-        );
+      list: async () => {
+        const widgetTypes = await listWidgetTypes();
         return {
-          resources: availableWidgets.map((widgetType) => ({
+          resources: widgetTypes.map((widgetType) => ({
             uri: `elementor://widgets/schema/${widgetType}`,
             name: "Widget schema for " + widgetType
           }))
@@ -185,52 +44,16 @@ var initWidgetsSchemaResource = (reg) => {
     },
     async (uri, variables) => {
       const widgetType = typeof variables.widgetType === "string" ? variables.widgetType : variables.widgetType?.[0];
-      const widgetData = getWidgetsCache2()?.[widgetType];
-      if (!widgetData) {
-        throw new Error(`No prop schema found for element type: ${widgetType}`);
+      if (!widgetType) {
+        throw new Error("No widget type provided.");
       }
-      const propSchema = widgetData.atomic_props_schema;
-      if (!propSchema) {
-        if (!hasV3Controls(widgetData.controls)) {
-          throw new Error(`No prop schema found for element type: ${widgetType}`);
-        }
-        const controlMetadata = extractV3ControlsMetadata(widgetData.controls);
-        return {
-          contents: [
-            {
-              uri: uri.toString(),
-              mimeType: "application/json",
-              text: JSON.stringify({
-                widget_version: "v3",
-                message: "This widget exists in the editor but has no atomic props schema (V4). Use control_metadata as non-authoritative hints from legacy controls.",
-                fields_note: "All settings are optional; there is no JSON schema for this widget type.",
-                properties: controlMetadata
-              })
-            }
-          ]
-        };
-      }
-      const baseSettingsKeys = Object.keys(widgetData?.base_settings ?? {});
-      const asJson = enrichPropertiesWithBaseSettingsHints(
-        Object.fromEntries(
-          Object.entries(propSchema).filter(([key, propType]) => Schema.isPropKeyConfigurable(key, propType)).map(([key, propType]) => [key, Schema.propTypeToJsonSchema(propType)])
-        ),
-        baseSettingsKeys
-      );
-      const description = typeof widgetData?.meta?.description === "string" ? widgetData.meta.description : void 0;
-      const allWidgets = getWidgetsCache2() || {};
-      const llmGuidance = buildLlmGuidance(widgetData, widgetType, allWidgets);
+      const schema2 = await fetchWidgetSchema(widgetType);
       return {
         contents: [
           {
             uri: uri.toString(),
             mimeType: "application/json",
-            text: JSON.stringify({
-              type: "object",
-              properties: asJson,
-              description,
-              llm_guidance: llmGuidance
-            })
+            text: JSON.stringify(schema2)
           }
         ]
       };
@@ -285,11 +108,11 @@ var initBreakpointsResource = (reg) => {
 };
 
 // src/mcp/utils/convert-css-to-atomic.ts
-import { httpService } from "@elementor/http-client";
+import { httpService as httpService2 } from "@elementor/http-client";
 var CSS_TO_ATOMIC_URL = "elementor/v1/css-to-atomic";
 var SINGLE_BLOCK_KEY = "default";
 var convertBlocks = async (blocks) => {
-  const { data } = await httpService().post(
+  const { data } = await httpService2().post(
     CSS_TO_ATOMIC_URL,
     { blocks }
   );
@@ -2732,7 +2555,7 @@ function initStyleTransformers() {
 }
 
 // src/legacy/init-legacy-views.ts
-import { getWidgetsCache as getWidgetsCache3 } from "@elementor/editor-elements";
+import { getWidgetsCache } from "@elementor/editor-elements";
 import { __privateIsReady as isV1Ready, __privateListenTo, v1ReadyEvent as v1ReadyEvent2 } from "@elementor/editor-v1-adapters";
 
 // src/renderers/create-dom-renderer.ts
@@ -4048,7 +3871,7 @@ function registerElementType(type, elementTypeGenerator) {
 }
 function initLegacyViews() {
   __privateListenTo(v1ReadyEvent2(), () => {
-    const widgetsCache = getWidgetsCache3() ?? {};
+    const widgetsCache = getWidgetsCache() ?? {};
     const renderer = createDomRenderer();
     registerProPromotionTypes(widgetsCache);
     Object.keys(widgetsCache).forEach((type) => {
@@ -4057,7 +3880,7 @@ function initLegacyViews() {
   });
 }
 function registerElementInLegacyManager(type, renderer) {
-  const element = (getWidgetsCache3() ?? {})[type];
+  const element = (getWidgetsCache() ?? {})[type];
   if (!element?.atomic) {
     return;
   }
@@ -4139,43 +3962,41 @@ function initTabsModelExtensions() {
 }
 
 // src/mcp/canvas-mcp.ts
-import { Schema as Schema5 } from "@elementor/editor-props";
+import { Schema as Schema4 } from "@elementor/editor-props";
 
 // src/mcp/resources/available-widgets-resource.ts
-import { v1ReadyEvent as v1ReadyEvent3 } from "@elementor/editor-v1-adapters";
+import { httpService as httpService3 } from "@elementor/http-client";
+var MCP_PROXY_URL2 = "elementor/v1/mcp-proxy";
 var AVAILABLE_WIDGETS_URI = "elementor://context/available-widgets";
 var AVAILABLE_WIDGETS_URI_V4 = "elementor://context/available-widgets/v4";
-var initAvailableWidgetsResource = (reg) => {
-  const { resource, sendResourceUpdated } = reg;
-  const buildContents = (uri, filterFunction = () => true) => {
-    const widgets = getAvailableWidgets().filter(filterFunction);
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: JSON.stringify(widgets, null, 2)
-        }
-      ]
-    };
-  };
-  const notifyResourcesUpdated = () => {
-    sendResourceUpdated({
-      uri: AVAILABLE_WIDGETS_URI,
-      ...buildContents(AVAILABLE_WIDGETS_URI)
-    });
-    sendResourceUpdated({
-      uri: AVAILABLE_WIDGETS_URI_V4,
-      ...buildContents(AVAILABLE_WIDGETS_URI_V4, (w) => w.version === "v4")
-    });
+var fetchWidgets = async (version) => {
+  const { data } = await httpService3().post(MCP_PROXY_URL2, {
+    tool: "list-widgets",
+    input: version ? { version } : {}
+  });
+  return data.data ?? [];
+};
+var buildContents = async (uri, version) => {
+  const widgets = await fetchWidgets(version);
+  return {
+    contents: [
+      {
+        uri,
+        mimeType: "application/json",
+        text: JSON.stringify(widgets, null, 2)
+      }
+    ]
   };
+};
+var initAvailableWidgetsResource = (reg) => {
+  const { resource } = reg;
   resource(
     "available-widgets-v4",
     AVAILABLE_WIDGETS_URI_V4,
     {
       description: "All registered v4 version widgets"
     },
-    async () => buildContents(AVAILABLE_WIDGETS_URI_V4, (w) => w.version === "v4")
+    async () => buildContents(AVAILABLE_WIDGETS_URI_V4, "v4")
   );
   resource(
     "available-widgets",
@@ -4185,22 +4006,11 @@ var initAvailableWidgetsResource = (reg) => {
     },
     async () => buildContents(AVAILABLE_WIDGETS_URI)
   );
-  const eventName = v1ReadyEvent3().name;
-  const onV1Ready = () => {
-    const widgets = getAvailableWidgets();
-    if (widgets.length === 0) {
-      return;
-    }
-    window.removeEventListener(eventName, onV1Ready);
-    notifyResourcesUpdated();
-  };
-  window.addEventListener(eventName, onV1Ready);
-  onV1Ready();
 };
 
 // src/mcp/resources/best-practices-resource.ts
-import { httpService as httpService2 } from "@elementor/http-client";
-var MCP_PROXY_URL = "elementor/v1/mcp-proxy";
+import { httpService as httpService4 } from "@elementor/http-client";
+var MCP_PROXY_URL3 = "elementor/v1/mcp-proxy";
 var BEST_PRACTICES_URI2 = "elementor://style/best-practices";
 var initBestPracticesResource = (reg) => {
   const { resource } = reg;
@@ -4212,7 +4022,7 @@ var initBestPracticesResource = (reg) => {
       mimeType: "text/markdown"
     },
     async (uri) => {
-      const { data } = await httpService2().get(MCP_PROXY_URL, {
+      const { data } = await httpService4().get(MCP_PROXY_URL3, {
         params: { uri: uri.href }
       });
       return {
@@ -4230,7 +4040,7 @@ var initBestPracticesResource = (reg) => {
 
 // src/mcp/resources/document-structure-resource.ts
 import {
-  getWidgetsCache as getWidgetsCache4
+  getWidgetsCache as getWidgetsCache2
 } from "@elementor/editor-elements";
 import { __privateListenTo as listenTo, commandEndEvent as commandEndEvent4 } from "@elementor/editor-v1-adapters";
 var DOCUMENT_STRUCTURE_URI = "elementor://document/structure";
@@ -4296,7 +4106,7 @@ function resolveElementVersion(element) {
     return "v4";
   }
   const widgetType = element.model?.attributes?.widgetType;
-  if (widgetType && getWidgetsCache4()?.[widgetType]?.atomic_props_schema) {
+  if (widgetType && getWidgetsCache2()?.[widgetType]?.atomic_props_schema) {
     return "v4";
   }
   return "v3";
@@ -4323,11 +4133,11 @@ function extractElementData(element) {
 }
 
 // src/mcp/resources/dynamic-tags-resource.ts
-import { httpService as httpService3 } from "@elementor/http-client";
+import { httpService as httpService5 } from "@elementor/http-client";
 var DYNAMIC_TAGS_URI = "elementor://dynamic-tags";
-var MCP_PROXY_URL2 = "elementor/v1/mcp-proxy";
+var MCP_PROXY_URL4 = "elementor/v1/mcp-proxy";
 var fetchDynamicTags = async () => {
-  const { data } = await httpService3().post(MCP_PROXY_URL2, {
+  const { data } = await httpService5().post(MCP_PROXY_URL4, {
     tool: "list-dynamic-tags",
     input: {}
   });
@@ -4527,7 +4337,7 @@ var initGeneralContextResource = (reg) => {
 };
 
 // src/mcp/resources/selected-element-resource.ts
-import { getContainer as getContainer3, getSelectedElements, getWidgetsCache as getWidgetsCache5 } from "@elementor/editor-elements";
+import { getContainer as getContainer3, getSelectedElements, getWidgetsCache as getWidgetsCache3 } from "@elementor/editor-elements";
 import {
   __privateListenTo as listenTo4,
   commandEndEvent as commandEndEvent7
@@ -4628,7 +4438,7 @@ function resolveElementVersion2(container, widgetType) {
   if (container.model?.config?.atomic) {
     return "v4";
   }
-  if (widgetType && getWidgetsCache5()?.[widgetType]?.atomic_props_schema) {
+  if (widgetType && getWidgetsCache3()?.[widgetType]?.atomic_props_schema) {
     return "v4";
   }
   return "v3";
@@ -4638,7 +4448,7 @@ function getElementProperties(container, widgetType) {
   if (!settings || typeof settings !== "object") {
     return null;
   }
-  const widgetConfig = widgetType ? getWidgetsCache5()?.[widgetType] : null;
+  const widgetConfig = widgetType ? getWidgetsCache3()?.[widgetType] : null;
   const controls = widgetConfig?.controls;
   const filtered = {};
   for (const [key, value] of Object.entries(settings)) {
@@ -4681,7 +4491,7 @@ import {
   createElement as createElement13,
   deleteElement as deleteElement2,
   getContainer as getContainer5,
-  getWidgetsCache as getWidgetsCache9
+  getWidgetsCache as getWidgetsCache8
 } from "@elementor/editor-elements";
 import { dispatchMcpStylesAppliedEvent } from "@elementor/editor-mcp";
 
@@ -4691,18 +4501,18 @@ import {
   deleteElement,
   generateElementId as generateElementId2,
   getContainer as getContainer4,
-  getWidgetsCache as getWidgetsCache8
+  getWidgetsCache as getWidgetsCache6
 } from "@elementor/editor-elements";
 
 // src/mcp/utils/do-update-element-property.ts
 import {
   createElementStyle,
   getElementStyles,
-  getWidgetsCache as getWidgetsCache7,
+  getWidgetsCache as getWidgetsCache5,
   updateElementSettings,
   updateElementStyle
 } from "@elementor/editor-elements";
-import { getPropSchemaFromCache as getPropSchemaFromCache2, Schema as Schema2 } from "@elementor/editor-props";
+import { getPropSchemaFromCache as getPropSchemaFromCache2, Schema } from "@elementor/editor-props";
 import { getStylesSchema as getStylesSchema2, getVariantByMeta } from "@elementor/editor-styles";
 import { __privateRunCommandSync as runCommandSync2 } from "@elementor/editor-v1-adapters";
 
@@ -4721,7 +4531,7 @@ var readStoredCustomCssText = (raw) => {
 };
 
 // src/mcp/utils/resolve-canonical-prop-name.ts
-import { getWidgetsCache as getWidgetsCache6 } from "@elementor/editor-elements";
+import { getWidgetsCache as getWidgetsCache4 } from "@elementor/editor-elements";
 function buildAliasToCanonicalMap(schema2) {
   const aliasToCanonical = {};
   for (const [canonical, propType] of Object.entries(schema2)) {
@@ -4738,14 +4548,14 @@ function buildAliasToCanonicalMap(schema2) {
   return aliasToCanonical;
 }
 function resolveCanonicalPropName(elementType, propertyName) {
-  const schema2 = getWidgetsCache6()?.[elementType]?.atomic_props_schema;
+  const schema2 = getWidgetsCache4()?.[elementType]?.atomic_props_schema;
   if (!schema2 || schema2[propertyName]) {
     return propertyName;
   }
   return buildAliasToCanonicalMap(schema2)[propertyName] ?? propertyName;
 }
 function resolveCanonicalPropKeys(elementType, props) {
-  const schema2 = getWidgetsCache6()?.[elementType]?.atomic_props_schema;
+  const schema2 = getWidgetsCache4()?.[elementType]?.atomic_props_schema;
   if (!schema2) {
     return { ...props };
   }
@@ -4841,7 +4651,7 @@ var LOCAL_STYLE_META = {
 };
 function resolvePropValue(value, forceKey) {
   const Utils = window.elementorV2.editorVariables.Utils;
-  return Schema2.adjustLlmPropValueSchema(value, {
+  return Schema.adjustLlmPropValueSchema(value, {
     forceKey,
     transformers: {
       ...Utils.globalVariablesLLMResolvers,
@@ -4939,7 +4749,7 @@ var doUpdateElementProperty = (params) => {
     }
     return;
   }
-  const elementPropSchema = getWidgetsCache7()?.[elementType]?.atomic_props_schema;
+  const elementPropSchema = getWidgetsCache5()?.[elementType]?.atomic_props_schema;
   if (!elementPropSchema) {
     throw new Error(`No prop schema found for element type: ${elementType}`);
   }
@@ -4953,7 +4763,7 @@ var doUpdateElementProperty = (params) => {
   }
   const propKey = elementPropSchema[propertyName].key;
   const value = resolvePropValue(propertyValue, propKey);
-  const { valid, jsonSchema } = Schema2.validatePropValue(elementPropSchema[propertyName], propertyValue);
+  const { valid, jsonSchema } = Schema.validatePropValue(elementPropSchema[propertyName], propertyValue);
   if (!valid) {
     throw new Error(
       `Invalid PropValue for elementId: ${elementId}. PropKey: ${propKey}, PropValue: ${JSON.stringify(
@@ -4972,6 +4782,15 @@ Expected Schema: ${jsonSchema}`
   runCommandSync2("document/save/set-is-modified", { status: true }, { internal: true });
 };
 
+// src/composition-builder/utils/required-default-child-tags.ts
+function getRequiredDefaultChildTemplates(elementConfig) {
+  const defaultChildren = elementConfig?.default_children;
+  if (!Array.isArray(defaultChildren)) {
+    return [];
+  }
+  return defaultChildren.filter((child) => child?.meta?.required ?? false);
+}
+
 // src/composition-builder/utils/required-children-enforcer.ts
 var REQUIRED_CHILD_SCHEMA_HINT = "Use the widget schema resource; under llm_guidance.required_direct_children for V4 widgets.";
 var RequiredChildrenEnforcer = class {
@@ -5022,7 +4841,7 @@ var CompositionBuilder = class _CompositionBuilder {
   api = {
     createElement: createElement12,
     deleteElement,
-    getWidgetsCache: getWidgetsCache8,
+    getWidgetsCache: getWidgetsCache6,
     generateElementId: generateElementId2,
     getContainer: getContainer4,
     doUpdateElementProperty
@@ -5275,6 +5094,27 @@ var trackCanvasEvent = (data) => {
   trackEvent(data);
 };
 
+// src/mcp/utils/element-data-util.ts
+import { getWidgetsCache as getWidgetsCache7 } from "@elementor/editor-elements";
+function hasV3Controls(controls) {
+  return typeof controls === "object" && controls !== null && Object.keys(controls).length > 0;
+}
+function isWidgetAvailableForLLM(config) {
+  if (!config) {
+    return false;
+  }
+  if (config.meta?.llm_support === false) {
+    return false;
+  }
+  if (config.title === "Component") {
+    return false;
+  }
+  if (config.atomic_props_schema) {
+    return true;
+  }
+  return hasV3Controls(config.controls);
+}
+
 // src/mcp/utils/get-composition-target-container.ts
 import { COMPONENT_DOCUMENT_TYPE } from "@elementor/editor-documents";
 function getCompositionTargetContainer(documentContainer, documentType) {
@@ -5557,7 +5397,7 @@ var initBuildCompositionsTool = (reg) => {
       const { xmlStructure, elementConfig, stylesConfig } = adaptLeafRootParams({
         ...rawParams,
         stylesConfig: convertedStyles,
-        widgetsCache: getWidgetsCache9() ?? {}
+        widgetsCache: getWidgetsCache8() ?? {}
       });
       let generatedXML = "";
       const errors = [];
@@ -5569,7 +5409,7 @@ var initBuildCompositionsTool = (reg) => {
         const compositionBuilder = CompositionBuilder.fromXMLString(xmlStructure, {
           createElement: createElement13,
           deleteElement: deleteElement2,
-          getWidgetsCache: getWidgetsCache9
+          getWidgetsCache: getWidgetsCache8
         });
         compositionBuilder.setElementConfig(elementConfig);
         compositionBuilder.setStylesConfig(stylesConfig);
@@ -5670,7 +5510,7 @@ function assertCompositionXmlUsesV4WidgetsOnly(xmlStructure) {
   if (doc.querySelector("parsererror")) {
     throw new Error("Failed to parse XML string: " + doc);
   }
-  const widgetsCache = getWidgetsCache9() ?? {};
+  const widgetsCache = getWidgetsCache8() ?? {};
   for (const node of doc.querySelectorAll("*")) {
     const type = node.tagName;
     const widgetData = widgetsCache[type];
@@ -5709,9 +5549,9 @@ function onElementAdded(element) {
 }
 
 // src/mcp/tools/configure-element/tool.ts
-import { getContainer as getContainer6, getWidgetsCache as getWidgetsCache10 } from "@elementor/editor-elements";
+import { getContainer as getContainer6, getWidgetsCache as getWidgetsCache9 } from "@elementor/editor-elements";
 import { dispatchMcpStylesAppliedEvent as dispatchMcpStylesAppliedEvent2 } from "@elementor/editor-mcp";
-import { Schema as Schema3 } from "@elementor/editor-props";
+import { Schema as Schema2 } from "@elementor/editor-props";
 
 // src/mcp/tools/configure-element/prompt.ts
 import { toolPrompts as toolPrompts2 } from "@elementor/editor-mcp";
@@ -5878,7 +5718,7 @@ var initConfigureElementTool = (reg) => {
       { description: "Dynamic tags catalog", uri: DYNAMIC_TAGS_URI }
     ],
     handler: async ({ elementId, propertiesToChange, elementType, style }) => {
-      const widgetData = getWidgetsCache10()?.[elementType];
+      const widgetData = getWidgetsCache9()?.[elementType];
       if (!widgetData) {
         throw new Error(
           `Unknown element type: ${elementType}. Check the available-widgets resource for valid types.`
@@ -5900,7 +5740,7 @@ var initConfigureElementTool = (reg) => {
       const propertiesToUpdate = resolveCanonicalPropKeys(elementType, propertiesToChange);
       const toUpdate = Object.entries(propertiesToUpdate);
       for (const [propertyName, propertyValue] of toUpdate) {
-        if (!Schema3.isPropKeyConfigurable(propertyName)) {
+        if (!Schema2.isPropKeyConfigurable(propertyName)) {
           throw new Error(`Not allowed to update ${propertyName}`);
         }
         try {
@@ -5977,9 +5817,9 @@ Provide styling as raw CSS via the "style" parameter (a flat map of CSS property
 
 // src/mcp/tools/create-element/tool.ts
 import { getCurrentDocument as getCurrentDocument2 } from "@elementor/editor-documents";
-import { httpService as httpService4 } from "@elementor/http-client";
+import { httpService as httpService6 } from "@elementor/http-client";
 import { z as z3 } from "@elementor/schema";
-var MCP_PROXY_URL3 = "elementor/v1/mcp-proxy";
+var MCP_PROXY_URL5 = "elementor/v1/mcp-proxy";
 var initCreateElementTool = (reg) => {
   const { addTool } = reg;
   addTool({
@@ -5999,7 +5839,7 @@ var initCreateElementTool = (reg) => {
       if (!document2?.id) {
         throw new Error("No active document found.");
       }
-      const { data } = await httpService4().post(MCP_PROXY_URL3, {
+      const { data } = await httpService6().post(MCP_PROXY_URL5, {
         tool: "create-element",
         input: {
           parent_id: parentId ?? "document",
@@ -6017,8 +5857,8 @@ var initCreateElementTool = (reg) => {
 };
 
 // src/mcp/tools/get-element-config/tool.ts
-import { getContainer as getContainer7, getElementStyles as getElementStyles2, getWidgetsCache as getWidgetsCache11 } from "@elementor/editor-elements";
-import { Schema as Schema4 } from "@elementor/editor-props";
+import { getContainer as getContainer7, getElementStyles as getElementStyles2, getWidgetsCache as getWidgetsCache10 } from "@elementor/editor-elements";
+import { Schema as Schema3 } from "@elementor/editor-props";
 import { z as z4 } from "@elementor/schema";
 var schema = {
   elementId: z4.string()
@@ -6057,7 +5897,7 @@ var initGetElementConfigTool = (reg) => {
         throw new Error(`Element with ID ${elementId} not found.`);
       }
       const elementType = element.model.get("widgetType") || element.model.get("elType") || "";
-      const widgetData = getWidgetsCache11()?.[elementType];
+      const widgetData = getWidgetsCache10()?.[elementType];
       if (!widgetData) {
         throw new Error(
           `Unknown element type: ${elementType}. Check the available-widgets resource for valid types.`
@@ -6069,13 +5909,13 @@ var initGetElementConfigTool = (reg) => {
         );
       }
       const elementRawSettings = element.settings;
-      const propSchema = getWidgetsCache11()?.[elementType]?.atomic_props_schema;
+      const propSchema = getWidgetsCache10()?.[elementType]?.atomic_props_schema;
       if (!elementRawSettings || !propSchema) {
         throw new Error(`No settings or prop schema found for element ID: ${elementId}`);
       }
       const propValues = {};
       const stylePropValues = {};
-      Schema4.configurableKeys(propSchema).forEach((key) => {
+      Schema3.configurableKeys(propSchema).forEach((key) => {
         propValues[key] = structuredClone(elementRawSettings.get(key));
       });
       const elementStyles = getElementStyles2(elementId) || {};
@@ -6111,7 +5951,7 @@ var initGetElementConfigTool = (reg) => {
 
 // src/mcp/canvas-mcp.ts
 var initCanvasMcp = (reg) => {
-  Schema5.setDynamicTagNamesResolver(getDynamicTagNamesByCategories);
+  Schema4.setDynamicTagNamesResolver(getDynamicTagNamesByCategories);
   initWidgetsSchemaResource(reg);
   initAvailableWidgetsResource(reg);
   initDocumentStructureResource(reg);
@@ -6332,7 +6172,7 @@ import {
 } from "@elementor/editor-v1-adapters";
 
 // src/utils/command-utils.ts
-import { getElementLabel as getElementLabel2, getWidgetsCache as getWidgetsCache12 } from "@elementor/editor-elements";
+import { getElementLabel as getElementLabel2, getWidgetsCache as getWidgetsCache11 } from "@elementor/editor-elements";
 import { CLASSES_PROP_KEY } from "@elementor/editor-props";
 import { __ as __5 } from "@wordpress/i18n";
 function hasAtomicWidgets(args) {
@@ -6357,7 +6197,7 @@ function getClassesProp(container) {
 }
 function getContainerSchema(container) {
   const type = container?.model.get("widgetType") || container?.model.get("elType");
-  const widgetsCache = getWidgetsCache12();
+  const widgetsCache = getWidgetsCache11();
   const elementType = widgetsCache?.[type];
   return elementType?.atomic_props_schema ?? null;
 }