@elementor/editor-mcp 4.1.0-788 → 4.1.0-790

package/dist/index.js

@@ -35,19 +35,23 @@ __export(index_exports, {
   McpServer: () => import_mcp2.McpServer,
   ResourceTemplate: () => import_mcp2.ResourceTemplate,
   SamplingMessageSchema: () => import_types2.SamplingMessageSchema,
-  activateMcpRegistration: () => activateMcpRegistration,
+  activateAdapters: () => activateAdapters,
   createSampler: () => createSampler,
+  getActiveChatInfo: () => getActiveChatInfo,
   getAngieIframe: () => import_angie_sdk2.getAngieIframe,
   getAngieSdk: () => getAngieSdk,
   getMCPByDomain: () => getMCPByDomain,
-  init: () => init,
+  getRegisteredMcpServers: () => getRegisteredMcpServers,
   installAngiePlugin: () => installAngiePlugin,
   isAngieAvailable: () => isAngieAvailable,
   isAngieSidebarOpen: () => isAngieSidebarOpen,
   redirectToAppAdmin: () => redirectToAppAdmin,
   redirectToInstallation: () => redirectToInstallation,
   registerMcp: () => registerMcp,
+  registerMcpAdapter: () => registerMcpAdapter,
   sendPromptToAngie: () => sendPromptToAngie,
+  signalMcpReady: () => signalMcpReady,
+  startMCPServer: () => startMCPServer,
   toMCPTitle: () => toMCPTitle,
   toolPrompts: () => toolPrompts
 });
@@ -72,12 +76,22 @@ var getSDK = () => {
 var import_mcp2 = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_types2 = require("@modelcontextprotocol/sdk/types.js");
 
-// src/init.ts
-var import_editor_v1_adapters = require("@elementor/editor-v1-adapters");
+// src/utils/is-angie-available.ts
+var import_angie_sdk3 = require("@elementor-external/angie-sdk");
+var isAngieAvailable = () => {
+  return !!(0, import_angie_sdk3.getAngieIframe)();
+};
+
+// src/utils/is-angie-sidebar-open.ts
+var import_angie_sdk4 = require("@elementor-external/angie-sdk");
+var isAngieSidebarOpen = () => {
+  return (0, import_angie_sdk4.getAngieSidebarSavedState)() === import_angie_sdk4.ANGIE_SIDEBAR_STATE_OPEN;
+};
 
 // src/mcp-registry.ts
 var import_schema = require("@elementor/schema");
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_uriTemplate = require("@modelcontextprotocol/sdk/shared/uriTemplate.js");
 
 // src/angie-annotations.ts
 var ANGIE_MODEL_PREFERENCES = "angie/modelPreferences";
@@ -113,9 +127,6 @@ var mockMcpRegistry = () => {
     },
     setMCPDescription: () => {
     },
-    getActiveChatInfo() {
-      return { sessionId: "mock-session-id", expiresAt: Date.now() + 36e5 };
-    },
     mcpServer: mock
   };
 };
@@ -124,37 +135,45 @@ var mockMcpRegistry = () => {
 var mcpRegistry = {};
 var mcpDescriptions = {};
 var isMcpRegistrationActivated = typeof globalThis.jest !== "undefined";
-var registerMcp = (mcp, name) => {
-  const mcpName = isAlphabet(name);
-  mcpRegistry[mcpName] = mcp;
-};
-async function activateMcpRegistration(sdk2, entries = Object.entries(mcpRegistry), retry = 3) {
-  if (retry === 0) {
-    console.error("Failed to register MCP after 3 retries. failed entries: ", entries);
-    return;
-  }
-  if (entries.length === 0) {
-    return;
+var registrationAdapters = [];
+var bufferedTools = [];
+var bufferedResources = [];
+var resolveReady;
+var readyPromise = new Promise((resolve) => {
+  resolveReady = resolve;
+});
+var registerMcpAdapter = (adapter) => {
+  registrationAdapters.push(adapter);
+  for (const tool of bufferedTools) {
+    try {
+      adapter.onToolRegistered(tool[0], tool[1]);
+    } catch {
+    }
   }
-  const failed = [];
-  for await (const entry of entries) {
-    const [key, mcpServer] = entry;
+  for (const resource of bufferedResources) {
     try {
-      await sdk2.registerLocalServer({
-        title: toMCPTitle(key),
-        name: `editor-${key}`,
-        server: mcpServer,
-        version: "1.0.0",
-        description: mcpDescriptions[key] || key
-      });
+      adapter.onResourceRegistered(...resource);
     } catch {
-      failed.push(entry);
     }
   }
-  if (failed.length > 0) {
-    return activateMcpRegistration(sdk2, failed, retry - 1);
+};
+var signalMcpReady = () => resolveReady();
+var activateAdapters = () => callAdapters((adapter) => adapter.activate());
+function callAdapters(fn) {
+  for (const adapter of registrationAdapters) {
+    try {
+      fn(adapter);
+    } catch {
+    }
   }
 }
+var registerMcp = (mcp, name) => {
+  const mcpName = isAlphabet(name);
+  mcpRegistry[mcpName] = mcp;
+};
+var getRegisteredMcpServers = () => {
+  return Object.entries(mcpRegistry).map(([key, server]) => [key, server, mcpDescriptions[key] || key]);
+};
 var isAlphabet = (str) => {
   const passes = !!str && /^[a-z_]+$/.test(str);
   if (!passes) {
@@ -180,49 +199,56 @@ var getMCPByDomain = (namespace, options) => {
         version: "1.0.0"
       },
       {
-        instructions: options?.instructions
+        instructions: options?.instructions,
+        capabilities: { resources: { subscribe: true } }
       }
     );
+    if (!!options?.instructions) {
+      callAdapters(
+        (adapter) => adapter.onResourceRegistered(
+          `${mcpName}`,
+          { uriTemplate: new import_uriTemplate.UriTemplate(mcpName) },
+          () => Promise.resolve({ contents: [{ text: options.instructions ?? "" }] })
+        )
+      );
+    }
   }
   const mcpServer = mcpRegistry[namespace];
-  const { addTool } = createToolRegistry(mcpServer);
+  const { addTool } = createToolRegistry(mcpServer, mcpName);
   return {
-    waitForReady: () => getSDK().waitForReady(),
+    waitForReady: () => readyPromise,
     // @ts-expect-error: TS is unable to infer the type here
     resource: async (...args) => {
-      await getSDK().waitForReady();
+      const [name, uriOrTemplate, ...rest] = args;
+      const handler = rest[rest.length - 1];
+      const resourceArgs = [
+        name,
+        uriOrTemplate,
+        handler
+      ];
+      bufferedResources.push(resourceArgs);
+      callAdapters((adapter) => adapter.onResourceRegistered(...resourceArgs));
       return mcpServer.registerResource(...args);
     },
     sendResourceUpdated: (...args) => {
-      return getSDK().waitForReady().then(() => mcpServer.server.sendResourceUpdated(...args)).catch((error) => {
+      callAdapters((adapter) => adapter.sendResourceUpdated({ uri: args[0].uri }));
+      return Promise.resolve(mcpServer.server.sendResourceUpdated(...args)).catch((error) => {
         if (error?.message?.includes("Not connected")) {
           return;
         }
+        if (error?.message?.includes("does not support notifying about resources")) {
+          return;
+        }
         throw error;
       });
     },
-    mcpServer,
     addTool,
     setMCPDescription: (description) => {
       mcpDescriptions[namespace] = description;
-    },
-    getActiveChatInfo: () => {
-      const info = localStorage.getItem("angie_active_chat_id");
-      if (!info) {
-        return {
-          expiresAt: 0,
-          sessionId: ""
-        };
-      }
-      const rawData = JSON.parse(info);
-      return {
-        expiresAt: rawData.expiresAt,
-        sessionId: rawData.sessionId
-      };
     }
   };
 };
-function createToolRegistry(server) {
+function createToolRegistry(server, serverName) {
   function addTool(opts) {
     const outputSchema = opts.outputSchema;
     if (outputSchema) {
@@ -283,6 +309,24 @@ function createToolRegistry(server) {
       },
       toolCallback
     );
+    const toolDescriptor = {
+      name: opts.name,
+      description: opts.description,
+      inputSchema,
+      execute: (params) => Promise.resolve(
+        toolCallback(
+          params,
+          /* WebMCP: no protocol session — handlers must not rely on `extra` here */
+          {}
+        )
+      )
+    };
+    const extraData = {
+      resources: [`Server resource name: ${serverName}, Required to fetch!`],
+      requiredResources: opts.requiredResources?.map((resource) => resource.uri) ?? []
+    };
+    bufferedTools.push([toolDescriptor, extraData]);
+    callAdapters((adapter) => adapter.onToolRegistered(toolDescriptor, extraData));
     if (isMcpRegistrationActivated) {
       server.sendToolListChanged();
     }
@@ -292,42 +336,6 @@ function createToolRegistry(server) {
   };
 }
 
-// src/utils/is-angie-available.ts
-var import_angie_sdk3 = require("@elementor-external/angie-sdk");
-var isAngieAvailable = () => {
-  return !!(0, import_angie_sdk3.getAngieIframe)();
-};
-
-// src/init.ts
-function init() {
-  if ((0, import_editor_v1_adapters.isExperimentActive)("editor_mcp") && isAngieAvailable()) {
-    return getSDK().waitForReady();
-  }
-  return Promise.resolve();
-}
-function startMCPServer() {
-  if ((0, import_editor_v1_adapters.isExperimentActive)("editor_mcp") && isAngieAvailable()) {
-    const sdk2 = getSDK();
-    sdk2.waitForReady().then(() => activateMcpRegistration(sdk2));
-  }
-  return Promise.resolve();
-}
-document.addEventListener(
-  "DOMContentLoaded",
-  () => {
-    startMCPServer();
-  },
-  {
-    once: true
-  }
-);
-
-// src/utils/is-angie-sidebar-open.ts
-var import_angie_sdk4 = require("@elementor-external/angie-sdk");
-var isAngieSidebarOpen = () => {
-  return (0, import_angie_sdk4.getAngieSidebarSavedState)() === import_angie_sdk4.ANGIE_SIDEBAR_STATE_OPEN;
-};
-
 // src/sampler.ts
 var import_types = require("@modelcontextprotocol/sdk/types.js");
 var DEFAULT_OPTS = {
@@ -431,6 +439,22 @@ var toolPrompts = (name) => {
   return new ToolPrompts(name);
 };
 
+// src/utils/get-active-chat-info.ts
+var getActiveChatInfo = () => {
+  const info = localStorage.getItem("angie_active_chat_id");
+  if (!info) {
+    return {
+      expiresAt: 0,
+      sessionId: ""
+    };
+  }
+  const rawData = JSON.parse(info);
+  return {
+    expiresAt: rawData.expiresAt,
+    sessionId: rawData.sessionId
+  };
+};
+
 // src/utils/send-prompt-to-angie.ts
 var import_angie_sdk5 = require("@elementor-external/angie-sdk");
 var sendPromptToAngie = (prompt) => {
@@ -509,6 +533,189 @@ var installAngiePlugin = async () => {
   }
 };
 
+// src/adapters/angie-adapter.ts
+var MAX_RETRIES = 3;
+var AngieMcpAdapter = class {
+  constructor(sdk2) {
+    this.sdk = sdk2;
+  }
+  async activate() {
+    await this.sdk.waitForReady();
+    await this.registerEntries(getRegisteredMcpServers(), MAX_RETRIES);
+  }
+  async registerEntries(entries, retry) {
+    if (retry === 0) {
+      console.error(
+        "Failed to register MCP after 3 retries. failed entries: ",
+        entries.map(([key]) => key)
+      );
+      return;
+    }
+    const failed = [];
+    for (const [key, mcpServer, description] of entries) {
+      try {
+        await this.sdk.registerLocalServer({
+          title: toMCPTitle(key),
+          name: `editor-${key}`,
+          server: mcpServer,
+          version: "1.0.0",
+          description
+        });
+      } catch {
+        failed.push([key, mcpServer, description]);
+      }
+    }
+    if (failed.length > 0) {
+      return this.registerEntries(failed, retry - 1);
+    }
+  }
+  onToolRegistered() {
+  }
+  onResourceRegistered() {
+  }
+  sendResourceUpdated() {
+  }
+};
+
+// src/adapters/web-mcp-adapter.ts
+var import_zod_to_json_schema = require("zod-to-json-schema");
+var import_schema2 = require("@elementor/schema");
+var WebMCPAdapter = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  registeredToolNames = /* @__PURE__ */ new Set();
+  resourceEntries = [];
+  activated = false;
+  activate() {
+    if (this.activated) {
+      return;
+    }
+    this.activated = true;
+    this.ctx.registerTool({
+      name: "editor-resource-getter",
+      description: "Get an editor resource by URI, or search for available resources by partial URI. Pass a full URI to retrieve content, or a partial string to discover matching patterns.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          uri: {
+            type: "string",
+            description: "A full resource URI (e.g. elementor://styles/best-practices) or a partial string to search across available resource patterns."
+          }
+        },
+        required: ["uri"]
+      },
+      execute: async (params) => {
+        const query = params.uri;
+        const entries = this.resourceEntries;
+        if (entries.length === 0) {
+          return "No resources are registered yet.";
+        }
+        for (const entry of entries) {
+          const variables = entry.match(query);
+          if (variables !== null) {
+            let resourceUrl;
+            try {
+              resourceUrl = new URL(query);
+            } catch {
+              return `Invalid URI '${query}'. Provide a valid resource URI or a partial string to search patterns.`;
+            }
+            const result = await entry.handler(resourceUrl, variables);
+            return result.contents?.[0]?.text ?? JSON.stringify(result);
+          }
+        }
+        const matches = entries.map((e) => e.pattern).filter((pattern) => pattern.includes(query));
+        if (matches.length > 0) {
+          return `Found ${matches.length} matching resource pattern(s):
+${matches.join(
+            "\n"
+          )}
+
+Provide a full URI to retrieve the resource content.`;
+        }
+        const available = entries.map((e) => e.pattern).join("\n");
+        throw new Error(`No resource matched '${query}'.
+
+Available patterns:
+${available}`);
+      }
+    });
+  }
+  onToolRegistered(tool, extraData) {
+    let jsonSchema;
+    try {
+      jsonSchema = (0, import_zod_to_json_schema.zodToJsonSchema)(import_schema2.z.object(tool.inputSchema));
+    } catch {
+      jsonSchema = tool.inputSchema;
+    }
+    if (this.registeredToolNames.has(tool.name)) {
+      this.ctx.unregisterTool(tool.name);
+    }
+    let resourcesDescription = "";
+    if (extraData) {
+      if (extraData.resources?.length > 0) {
+        resourcesDescription += `#Resources:
+${extraData.resources?.join("\n")}
+
+`;
+      }
+      if (extraData.requiredResources?.length > 0) {
+        resourcesDescription += `#Required Resources:
+${extraData.requiredResources?.join("\n")}
+
+`;
+      }
+      resourcesDescription += `To read resources, use editor-resource-getter tool.
+
+`;
+    }
+    this.ctx.registerTool({
+      name: tool.name,
+      description: `${resourcesDescription}${tool.description}`,
+      inputSchema: jsonSchema,
+      execute: tool.execute
+    });
+    this.registeredToolNames.add(tool.name);
+  }
+  onResourceRegistered(_name, uriOrTemplate, handler) {
+    if (typeof uriOrTemplate === "string") {
+      this.resourceEntries.push({
+        pattern: uriOrTemplate,
+        match: (uri) => uri === uriOrTemplate ? {} : null,
+        handler
+      });
+    } else {
+      const template = uriOrTemplate.uriTemplate;
+      this.resourceEntries.push({
+        pattern: template.toString(),
+        match: (uri) => template.match(uri),
+        handler
+      });
+    }
+  }
+  sendResourceUpdated() {
+  }
+};
+
+// src/init.ts
+function startMCPServer() {
+  if (typeof navigator !== "undefined" && "modelContext" in navigator) {
+    registerMcpAdapter(
+      new WebMCPAdapter(navigator.modelContext)
+    );
+  }
+  if (isAngieAvailable()) {
+    registerMcpAdapter(new AngieMcpAdapter(getSDK()));
+  }
+  activateAdapters();
+  signalMcpReady();
+}
+if (typeof document !== "undefined") {
+  document.addEventListener("DOMContentLoaded", () => startMCPServer(), { once: true });
+} else {
+  startMCPServer();
+}
+
 // src/index.ts
 var getAngieSdk = () => getSDK();
 // Annotate the CommonJS export names for ESM import in node:
@@ -518,19 +725,23 @@ var getAngieSdk = () => getSDK();
   McpServer,
   ResourceTemplate,
   SamplingMessageSchema,
-  activateMcpRegistration,
+  activateAdapters,
   createSampler,
+  getActiveChatInfo,
   getAngieIframe,
   getAngieSdk,
   getMCPByDomain,
-  init,
+  getRegisteredMcpServers,
   installAngiePlugin,
   isAngieAvailable,
   isAngieSidebarOpen,
   redirectToAppAdmin,
   redirectToInstallation,
   registerMcp,
+  registerMcpAdapter,
   sendPromptToAngie,
+  signalMcpReady,
+  startMCPServer,
   toMCPTitle,
   toolPrompts
 });