@mcp-fe/mcp-worker 0.1.11 → 0.2.2

package/index.js

@@ -208,6 +208,197 @@ var ToolRegistry = class {
   }
 };
 
+// libs/mcp-worker/src/client/web-mcp-adapter.ts
+var WebMcpAdapter = class _WebMcpAdapter {
+  /** Tracks names of tools currently registered via WebMCP API */
+  registeredTools = /* @__PURE__ */ new Set();
+  /** Whether the adapter is enabled (enabled by default — auto-detects browser support) */
+  enabled = true;
+  // --------------------------------------------------------------------------
+  // Feature detection
+  // --------------------------------------------------------------------------
+  /**
+   * Check if the browser exposes the WebMCP API (`navigator.modelContext`).
+   *
+   * Safe to call in any environment (SSR, workers, older browsers).
+   *
+   * @see https://webmachinelearning.github.io/webmcp/#navigator-extension
+   */
+  static isSupported() {
+    try {
+      return typeof navigator !== "undefined" && "modelContext" in navigator && navigator.modelContext != null && typeof navigator.modelContext.registerTool === "function";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Convenience: instance-level check that also respects the `enabled` flag.
+   */
+  isAvailable() {
+    return this.enabled && _WebMcpAdapter.isSupported();
+  }
+  // --------------------------------------------------------------------------
+  // Configuration
+  // --------------------------------------------------------------------------
+  /**
+   * Enable or disable the WebMCP adapter.
+   *
+   * When disabled, `registerTool` / `unregisterTool` become silent no-ops
+   * even if the browser supports the API.
+   */
+  setEnabled(value) {
+    this.enabled = value;
+    logger.log(`[WebMcpAdapter] Enabled: ${value}`);
+  }
+  // --------------------------------------------------------------------------
+  // Registration
+  // --------------------------------------------------------------------------
+  /**
+   * Register a tool with the WebMCP API (`navigator.modelContext.registerTool()`).
+   *
+   * Silently returns if the API is unavailable or the adapter is disabled.
+   * Per spec, `registerTool()` throws if a tool with the same name already exists,
+   * so we unregister first if needed (idempotent update).
+   *
+   * @param name         - Tool name
+   * @param description  - Human-readable description (required by spec)
+   * @param inputSchema  - JSON Schema for tool inputs
+   * @param handler      - Async handler executed in the main thread
+   * @param options      - Additional MCP tool options (annotations, …)
+   */
+  registerTool(name, description, inputSchema, handler, options) {
+    if (!this.isAvailable()) {
+      return;
+    }
+    if (this.registeredTools.has(name)) {
+      this.unregisterTool(name);
+    }
+    try {
+      const modelContext = navigator.modelContext;
+      const tool = {
+        name,
+        description: description ?? name,
+        inputSchema,
+        execute: async (input) => {
+          return handler(input);
+        },
+        annotations: this.mapAnnotations(options?.annotations)
+      };
+      modelContext.registerTool(tool);
+      this.registeredTools.add(name);
+      logger.log(
+        `[WebMcpAdapter] Registered tool '${name}' via navigator.modelContext`
+      );
+    } catch (error) {
+      logger.warn(`[WebMcpAdapter] Failed to register '${name}':`, error);
+    }
+  }
+  /**
+   * Unregister a tool from the WebMCP API (`navigator.modelContext.unregisterTool()`).
+   *
+   * Safe to call even if the tool was never registered via WebMCP.
+   *
+   * @param name - Tool name to unregister
+   * @returns `true` if the tool was found and unregistered, `false` otherwise
+   */
+  unregisterTool(name) {
+    if (!this.registeredTools.has(name)) {
+      return false;
+    }
+    try {
+      if (_WebMcpAdapter.isSupported()) {
+        const modelContext = navigator.modelContext;
+        modelContext.unregisterTool(name);
+      }
+      this.registeredTools.delete(name);
+      logger.log(
+        `[WebMcpAdapter] Unregistered tool '${name}' from navigator.modelContext`
+      );
+      return true;
+    } catch (error) {
+      logger.warn(`[WebMcpAdapter] Failed to unregister '${name}':`, error);
+      this.registeredTools.delete(name);
+      return false;
+    }
+  }
+  /**
+   * Unregister ALL tools registered via WebMCP.
+   *
+   * Uses `navigator.modelContext.clearContext()` when available (per spec, clears
+   * all tools at once), otherwise falls back to individual unregisterTool calls.
+   */
+  clearAll() {
+    if (this.registeredTools.size === 0)
+      return;
+    logger.log(`[WebMcpAdapter] Clearing ${this.registeredTools.size} tool(s)`);
+    try {
+      if (_WebMcpAdapter.isSupported()) {
+        const modelContext = navigator.modelContext;
+        modelContext.clearContext();
+      }
+    } catch (error) {
+      logger.warn(
+        "[WebMcpAdapter] clearContext() failed, falling back to individual unregister:",
+        error
+      );
+      const names = Array.from(this.registeredTools);
+      names.forEach((name) => {
+        try {
+          if (_WebMcpAdapter.isSupported()) {
+            navigator.modelContext.unregisterTool(name);
+          }
+        } catch {
+        }
+      });
+    }
+    this.registeredTools.clear();
+  }
+  // --------------------------------------------------------------------------
+  // Query
+  // --------------------------------------------------------------------------
+  /**
+   * Check if a tool is registered via WebMCP.
+   */
+  isRegistered(name) {
+    return this.registeredTools.has(name);
+  }
+  /**
+   * Get names of all tools registered via WebMCP.
+   */
+  getRegisteredTools() {
+    return Array.from(this.registeredTools);
+  }
+  // --------------------------------------------------------------------------
+  // Mapping helpers
+  // --------------------------------------------------------------------------
+  /**
+   * Map internal ToolAnnotations to WebMCP ToolAnnotations.
+   * The spec currently only defines `readOnlyHint`.
+   */
+  mapAnnotations(annotations) {
+    if (!annotations)
+      return void 0;
+    return {
+      readOnlyHint: annotations.readOnlyHint
+    };
+  }
+  /**
+   * Convert internal ToolDefinition to ModelContextTool format (utility).
+   * Requires an execute callback to be provided separately.
+   */
+  static toModelContextTool(tool, handler) {
+    return {
+      name: tool.name,
+      description: tool.description ?? tool.name,
+      inputSchema: tool.inputSchema,
+      execute: async (input) => {
+        return handler(input);
+      },
+      annotations: tool.annotations ? { readOnlyHint: tool.annotations.readOnlyHint } : void 0
+    };
+  }
+};
+
 // libs/mcp-worker/src/client/worker-client.ts
 var WorkerClient = class _WorkerClient {
   // Configurable worker script URLs (defaults kept for backward compatibility)
@@ -229,6 +420,8 @@ var WorkerClient = class _WorkerClient {
   initResolvers = [];
   // Tool registry for managing tool lifecycle
   toolRegistry = new ToolRegistry();
+  // WebMCP adapter for browser-level tool registration via navigator.modelContext
+  webMcpAdapter = new WebMcpAdapter();
   // Tab tracking for multi-tab support
   tabId;
   static TAB_ID_STORAGE_KEY = "mcp_fe_tab_id";
@@ -339,6 +532,7 @@ var WorkerClient = class _WorkerClient {
     logger.log(
       `[WorkerClient] Page unloading, cleaning up ${toolNames.length} tool(s)`
     );
+    this.webMcpAdapter.clearAll();
     toolNames.forEach((toolName) => {
       const existing = this.toolRegistry.getInfo(toolName);
       if (!existing)
@@ -383,6 +577,14 @@ var WorkerClient = class _WorkerClient {
         this.serviceWorkerUrl = opts.serviceWorkerUrl;
       if (opts.backendWsUrl)
         this.backendWsUrl = opts.backendWsUrl;
+      if (opts.enableWebMcp !== void 0) {
+        this.webMcpAdapter.setEnabled(opts.enableWebMcp);
+      }
+    }
+    if (this.webMcpAdapter.isAvailable()) {
+      logger.log(
+        "[WorkerClient] WebMCP: auto-enabled (navigator.modelContext detected)"
+      );
     }
     if (this.initPromise) {
       return this.initPromise.then(async () => {
@@ -459,6 +661,7 @@ var WorkerClient = class _WorkerClient {
         const details = this.toolRegistry.getDetails(toolName);
         if (!details)
           return;
+        const handler = this.toolRegistry.getHandler(toolName);
         try {
           await this.registerToolInWorker(
             details.name,
@@ -473,6 +676,22 @@ var WorkerClient = class _WorkerClient {
               title: details.title
             }
           );
+          if (handler) {
+            this.webMcpAdapter.registerTool(
+              details.name,
+              details.description,
+              details.inputSchema,
+              handler,
+              {
+                outputSchema: details.outputSchema,
+                annotations: details.annotations,
+                execution: details.execution,
+                _meta: details._meta,
+                icons: details.icons,
+                title: details.title
+              }
+            );
+          }
         } catch (error) {
           logger.error(
             `[WorkerClient] Failed to sync tool '${toolName}' to worker:`,
@@ -604,78 +823,87 @@ var WorkerClient = class _WorkerClient {
     }
   }
   async initServiceWorkerFallback() {
-    if ("serviceWorker" in navigator) {
-      try {
-        const existingRegistration = await navigator.serviceWorker.getRegistration();
-        if (existingRegistration) {
-          this.serviceWorkerRegistration = existingRegistration;
-          this.workerType = "service";
-          logger.info(
-            "[WorkerClient] Using existing ServiceWorker registration"
-          );
-          return;
-        }
+    if (!("serviceWorker" in navigator)) {
+      throw new Error("Neither SharedWorker nor ServiceWorker is supported");
+    }
+    try {
+      const existingRegistration = await navigator.serviceWorker.getRegistration();
+      if (existingRegistration) {
+        this.serviceWorkerRegistration = existingRegistration;
+        this.workerType = "service";
+        logger.info("[WorkerClient] Using existing ServiceWorker registration");
+      } else {
         this.serviceWorkerRegistration = await navigator.serviceWorker.register(
           this.serviceWorkerUrl
         );
         this.workerType = "service";
-        if ("serviceWorker" in navigator) {
-          navigator.serviceWorker.addEventListener(
-            "message",
-            (ev) => {
-              try {
-                const data = ev.data;
-                if (data && data.type === "CALL_TOOL") {
-                  const targetTabId = data.targetTabId;
-                  if (targetTabId && targetTabId !== this.tabId) {
-                    logger.log(
-                      `[WorkerClient] Ignoring CALL_TOOL (not for this tab): ${data.toolName}`,
-                      { targetTabId, myTabId: this.tabId }
-                    );
-                    return;
-                  }
-                  this.handleToolCall(
-                    data.toolName,
-                    data.args,
-                    data.callId
-                  ).catch((error) => {
-                    logger.error(
-                      "[WorkerClient] Failed to handle tool call:",
-                      error
-                    );
-                  });
+        logger.info("[WorkerClient] Using MCP ServiceWorker (fallback)");
+      }
+      navigator.serviceWorker.addEventListener(
+        "message",
+        (ev) => {
+          try {
+            const data = ev.data;
+            if (data && data.type === "CONNECTION_STATUS") {
+              const connected = !!data.connected;
+              this.connectionStatusCallbacks.forEach((cb) => {
+                try {
+                  cb(connected);
+                } catch {
                 }
-              } catch (error) {
+              });
+            } else if (data && data.type === "CALL_TOOL") {
+              const targetTabId = data.targetTabId;
+              if (targetTabId && targetTabId !== this.tabId) {
+                logger.log(
+                  `[WorkerClient] Ignoring CALL_TOOL (not for this tab): ${data.toolName}`,
+                  { targetTabId, myTabId: this.tabId }
+                );
+                return;
+              }
+              this.handleToolCall(
+                data.toolName,
+                data.args,
+                data.callId
+              ).catch((error) => {
                 logger.error(
-                  "[WorkerClient] Error processing ServiceWorker message:",
+                  "[WorkerClient] Failed to handle tool call:",
                   error
                 );
-              }
+              });
             }
-          );
-        }
-        logger.info("[WorkerClient] Using MCP ServiceWorker (fallback)");
-        try {
-          const initMsg = {
-            type: "INIT",
-            backendUrl: this.backendWsUrl
-          };
-          if (this.pendingAuthToken)
-            initMsg["token"] = this.pendingAuthToken;
-          if (this.serviceWorkerRegistration.active) {
-            this.serviceWorkerRegistration.active.postMessage(initMsg);
-          } else if ("serviceWorker" in navigator && navigator.serviceWorker.controller) {
-            navigator.serviceWorker.controller.postMessage(initMsg);
+          } catch (error) {
+            logger.error(
+              "[WorkerClient] Error processing ServiceWorker message:",
+              error
+            );
           }
+        }
+      );
+      try {
+        const initMsg = {
+          type: "INIT",
+          backendUrl: this.backendWsUrl
+        };
+        if (this.pendingAuthToken)
+          initMsg["token"] = this.pendingAuthToken;
+        const sendInit = (worker) => {
+          worker.postMessage(initMsg);
           this.pendingAuthToken = null;
-        } catch {
+        };
+        if (this.serviceWorkerRegistration.active) {
+          sendInit(this.serviceWorkerRegistration.active);
+        } else {
+          navigator.serviceWorker.ready.then((reg) => {
+            if (reg.active)
+              sendInit(reg.active);
+          });
         }
-      } catch (error) {
-        logger.error("[WorkerClient] Failed to register ServiceWorker:", error);
-        throw error;
+      } catch {
       }
-    } else {
-      throw new Error("Neither SharedWorker nor ServiceWorker is supported");
+    } catch (error) {
+      logger.error("[WorkerClient] Failed to register ServiceWorker:", error);
+      throw error;
     }
   }
   // Low-level request that expects a reply via MessageChannel
@@ -1003,6 +1231,13 @@ var WorkerClient = class _WorkerClient {
     }
     if (isNew) {
       await this.registerToolInWorker(name, description, inputSchema, options);
+      this.webMcpAdapter.registerTool(
+        name,
+        description,
+        inputSchema,
+        handler,
+        options
+      );
     }
   }
   /**
@@ -1060,6 +1295,7 @@ var WorkerClient = class _WorkerClient {
         "UNREGISTER_TOOL",
         { name, tabId: this.tabId }
       );
+      this.webMcpAdapter.unregisterTool(name);
       logger.log(`[WorkerClient] Unregistered tool '${name}'`);
       return workerResult?.success ?? false;
     }
@@ -1096,6 +1332,66 @@ var WorkerClient = class _WorkerClient {
   isToolRegistered(toolName) {
     return this.toolRegistry.isRegistered(toolName);
   }
+  // --------------------------------------------------------------------------
+  // WebMCP API
+  // --------------------------------------------------------------------------
+  /**
+   * Check if the browser supports the WebMCP API (`navigator.modelContext`).
+   */
+  static isWebMcpSupported() {
+    return WebMcpAdapter.isSupported();
+  }
+  /**
+   * Check if WebMCP is both enabled AND supported.
+   */
+  isWebMcpAvailable() {
+    return this.webMcpAdapter.isAvailable();
+  }
+  /**
+   * Enable or disable WebMCP registration at runtime.
+   * When enabled and the browser supports it, newly registered tools will also
+   * be advertised via `navigator.modelContext`. Existing tools are synced immediately.
+   */
+  setWebMcpEnabled(enabled) {
+    this.webMcpAdapter.setEnabled(enabled);
+    if (enabled && WebMcpAdapter.isSupported() && this.isInitialized) {
+      const toolNames = this.toolRegistry.getRegisteredTools();
+      toolNames.forEach((toolName) => {
+        const details = this.toolRegistry.getDetails(toolName);
+        const handler = this.toolRegistry.getHandler(toolName);
+        if (!details || !handler)
+          return;
+        this.webMcpAdapter.registerTool(
+          details.name,
+          details.description,
+          details.inputSchema,
+          handler,
+          {
+            outputSchema: details.outputSchema,
+            annotations: details.annotations,
+            execution: details.execution,
+            _meta: details._meta,
+            icons: details.icons,
+            title: details.title
+          }
+        );
+      });
+    } else if (!enabled) {
+      this.webMcpAdapter.clearAll();
+    }
+  }
+  /**
+   * Check if a specific tool is registered via the WebMCP API.
+   */
+  isToolRegisteredViaWebMcp(toolName) {
+    return this.webMcpAdapter.isRegistered(toolName);
+  }
+  /**
+   * Get names of tools registered via the WebMCP API.
+   */
+  getWebMcpRegisteredTools() {
+    return this.webMcpAdapter.getRegisteredTools();
+  }
   /**
    * Handle tool call from worker - execute handler in main thread and return result
    * @private
@@ -1235,6 +1531,7 @@ async function queryEvents(filters) {
   });
 }
 export {
+  WebMcpAdapter,
   WorkerClient,
   logger,
   queryEvents,

package/mcp-service-worker.js

@@ -21357,14 +21357,24 @@ var MCPController = class _MCPController {
       this.socket = null;
     }
     return new Promise((resolve) => {
-      const url2 = this.authToken ? `${this.backendUrl}?token=${this.authToken}` : this.backendUrl;
-      this.socket = new WebSocket(url2);
+      this.socket = new WebSocket(this.backendUrl);
       this.socket.onopen = async () => {
         logger.log("[MCPController] Connected to backend MCP server");
         this.reconnectAttempts = 0;
         this.isReconnectingForToken = false;
         try {
           if (this.socket) {
+            if (this.authToken) {
+              try {
+                await this.performAuthHandshake(this.socket, this.authToken);
+              } catch (error2) {
+                logger.error("[MCPController] Auth handshake failed:", error2);
+                this.broadcastFn({ type: "CONNECTION_STATUS", connected: false });
+                this.socket.close(4001, "Authentication failed");
+                resolve();
+                return;
+              }
+            }
             this.transport = new WebSocketTransport(this.socket);
             if (typeof this.transport.start === "function") {
               try {
@@ -21667,6 +21677,37 @@ var MCPController = class _MCPController {
     }
     return true;
   }
+  /**
+   * Sends AUTH message and waits for AUTH_OK before MCP transport is started.
+   * Token is never sent in the URL — only in this initial payload message.
+   */
+  performAuthHandshake(socket, token) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        socket.removeEventListener("message", handleMessage);
+        reject(new Error("Authentication timeout"));
+      }, 1e4);
+      const handleMessage = (event) => {
+        let msg;
+        try {
+          msg = JSON.parse(event.data);
+        } catch {
+          return;
+        }
+        if (msg.type === "AUTH_OK") {
+          clearTimeout(timeout);
+          socket.removeEventListener("message", handleMessage);
+          resolve();
+        } else if (msg.type === "AUTH_ERROR") {
+          clearTimeout(timeout);
+          socket.removeEventListener("message", handleMessage);
+          reject(new Error(msg.message || "Authentication rejected by server"));
+        }
+      };
+      socket.addEventListener("message", handleMessage);
+      socket.send(JSON.stringify({ type: "AUTH", token }));
+    });
+  }
   getConnectionStatus() {
     return this.socket?.readyState === WebSocket.OPEN;
   }

package/mcp-shared-worker.js

@@ -21357,14 +21357,24 @@ var MCPController = class _MCPController {
       this.socket = null;
     }
     return new Promise((resolve) => {
-      const url2 = this.authToken ? `${this.backendUrl}?token=${this.authToken}` : this.backendUrl;
-      this.socket = new WebSocket(url2);
+      this.socket = new WebSocket(this.backendUrl);
       this.socket.onopen = async () => {
         logger.log("[MCPController] Connected to backend MCP server");
         this.reconnectAttempts = 0;
         this.isReconnectingForToken = false;
         try {
           if (this.socket) {
+            if (this.authToken) {
+              try {
+                await this.performAuthHandshake(this.socket, this.authToken);
+              } catch (error2) {
+                logger.error("[MCPController] Auth handshake failed:", error2);
+                this.broadcastFn({ type: "CONNECTION_STATUS", connected: false });
+                this.socket.close(4001, "Authentication failed");
+                resolve();
+                return;
+              }
+            }
             this.transport = new WebSocketTransport(this.socket);
             if (typeof this.transport.start === "function") {
               try {
@@ -21667,6 +21677,37 @@ var MCPController = class _MCPController {
     }
     return true;
   }
+  /**
+   * Sends AUTH message and waits for AUTH_OK before MCP transport is started.
+   * Token is never sent in the URL — only in this initial payload message.
+   */
+  performAuthHandshake(socket, token) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        socket.removeEventListener("message", handleMessage);
+        reject(new Error("Authentication timeout"));
+      }, 1e4);
+      const handleMessage = (event) => {
+        let msg;
+        try {
+          msg = JSON.parse(event.data);
+        } catch {
+          return;
+        }
+        if (msg.type === "AUTH_OK") {
+          clearTimeout(timeout);
+          socket.removeEventListener("message", handleMessage);
+          resolve();
+        } else if (msg.type === "AUTH_ERROR") {
+          clearTimeout(timeout);
+          socket.removeEventListener("message", handleMessage);
+          reject(new Error(msg.message || "Authentication rejected by server"));
+        }
+      };
+      socket.addEventListener("message", handleMessage);
+      socket.send(JSON.stringify({ type: "AUTH", token }));
+    });
+  }
   getConnectionStatus() {
     return this.socket?.readyState === WebSocket.OPEN;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-fe/mcp-worker",
-  "version": "0.1.11",
+  "version": "0.2.2",
   "license": "Apache-2.0",
   "homepage": "https://mcp-fe.ai",
   "repository": {

package/src/client/index.d.ts

@@ -3,6 +3,8 @@
  * Use this in your application code
  */
 export { WorkerClient, type WorkerClientInitOptions } from './worker-client';
+export { WebMcpAdapter } from './web-mcp-adapter';
+export type { ModelContext, ModelContextTool, ModelContextOptions, ModelContextClient, ToolExecuteCallback, UserInteractionCallback, WebMcpToolAnnotations, } from './web-mcp-types';
 export type { ToolHandler, ToolDefinition, Icon, ToolAnnotations, ToolExecution, UserEvent, EventFilters, TabInfo, } from '../shared/types';
 export { logger } from '../shared/logger';
 import { WorkerClient } from './worker-client';

package/src/client/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../libs/mcp-worker/src/client/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,KAAK,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAG7E,YAAY,EACV,WAAW,EACX,cAAc,EACd,IAAI,EACJ,eAAe,EACf,aAAa,EACb,SAAS,EACT,YAAY,EACZ,OAAO,GACR,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAG1C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,eAAO,MAAM,YAAY,cAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../libs/mcp-worker/src/client/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,KAAK,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAG7E,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,iBAAiB,CAAC;AAGzB,YAAY,EACV,WAAW,EACX,cAAc,EACd,IAAI,EACJ,eAAe,EACf,aAAa,EACb,SAAS,EACT,YAAY,EACZ,OAAO,GACR,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAG1C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,eAAO,MAAM,YAAY,cAAqB,CAAC"}