@mcp-fe/mcp-worker 0.1.10 → 0.2.0

package/index.js

@@ -26,6 +26,379 @@ var logger = {
   }
 };
 
+// libs/mcp-worker/src/client/tool-registry.ts
+var ToolRegistry = class {
+  // Map to store tool handlers in main thread
+  toolHandlers = /* @__PURE__ */ new Map();
+  // Tool registry for tracking registrations and reference counting
+  toolRegistry = /* @__PURE__ */ new Map();
+  // Subscribers for tool changes (for React hooks reactivity)
+  toolChangeListeners = /* @__PURE__ */ new Map();
+  /**
+   * Register a tool with handler (or increment ref count if already exists)
+   *
+   * @param name - Tool name
+   * @param description - Tool description
+   * @param inputSchema - JSON Schema for tool inputs
+   * @param handler - Async function that handles the tool execution
+   * @param options - Additional tool options
+   * @returns true if newly registered, false if ref count incremented
+   */
+  register(name, description, inputSchema, handler, options) {
+    const existing = this.toolRegistry.get(name);
+    if (existing) {
+      existing.refCount++;
+      logger.log(
+        `[ToolRegistry] Incremented ref count for '${name}': ${existing.refCount}`
+      );
+      this.toolHandlers.set(name, handler);
+      this.notifyToolChange(name);
+      return false;
+    }
+    this.toolHandlers.set(name, handler);
+    this.toolRegistry.set(name, {
+      name,
+      description,
+      inputSchema,
+      outputSchema: options?.outputSchema,
+      annotations: options?.annotations,
+      execution: options?.execution,
+      _meta: options?._meta,
+      icons: options?.icons,
+      title: options?.title,
+      refCount: 1,
+      isRegistered: true
+    });
+    logger.log(`[ToolRegistry] Registered tool '${name}'`);
+    this.notifyToolChange(name);
+    return true;
+  }
+  /**
+   * Unregister a tool (decrement ref count, remove if count reaches 0)
+   *
+   * @param name - Tool name to unregister
+   * @returns true if tool was removed (ref count reached 0), false if ref count decremented, null if not found
+   */
+  unregister(name) {
+    const existing = this.toolRegistry.get(name);
+    if (!existing) {
+      logger.warn(`[ToolRegistry] Cannot unregister '${name}': not found`);
+      return null;
+    }
+    existing.refCount--;
+    logger.log(
+      `[ToolRegistry] Decremented ref count for '${name}': ${existing.refCount}`
+    );
+    if (existing.refCount <= 0) {
+      this.toolHandlers.delete(name);
+      this.toolRegistry.delete(name);
+      logger.log(`[ToolRegistry] Removed tool '${name}' from registry`);
+      this.notifyToolChange(name);
+      return true;
+    }
+    this.notifyToolChange(name);
+    return false;
+  }
+  /**
+   * Get tool handler function
+   */
+  getHandler(name) {
+    return this.toolHandlers.get(name);
+  }
+  /**
+   * Get tool info (ref count and registration status)
+   */
+  getInfo(name) {
+    const info = this.toolRegistry.get(name);
+    if (!info)
+      return null;
+    return {
+      refCount: info.refCount,
+      isRegistered: info.isRegistered
+    };
+  }
+  /**
+   * Get complete tool details
+   */
+  getDetails(name) {
+    return this.toolRegistry.get(name) ?? null;
+  }
+  /**
+   * Get all registered tool names
+   */
+  getRegisteredTools() {
+    return Array.from(this.toolRegistry.keys()).filter(
+      (name) => this.toolRegistry.get(name)?.isRegistered
+    );
+  }
+  /**
+   * Check if a tool is registered
+   */
+  isRegistered(name) {
+    return this.toolRegistry.get(name)?.isRegistered ?? false;
+  }
+  /**
+   * Subscribe to tool changes for a specific tool
+   * Returns unsubscribe function
+   */
+  onToolChange(toolName, callback) {
+    if (!this.toolChangeListeners.has(toolName)) {
+      this.toolChangeListeners.set(toolName, /* @__PURE__ */ new Set());
+    }
+    const listeners = this.toolChangeListeners.get(toolName);
+    listeners.add(callback);
+    try {
+      const current = this.toolRegistry.get(toolName);
+      if (current) {
+        callback({
+          refCount: current.refCount,
+          isRegistered: current.isRegistered
+        });
+      } else {
+        callback(null);
+      }
+    } catch (error) {
+      logger.error(
+        "[ToolRegistry] Error in tool change listener (initial call):",
+        error
+      );
+    }
+    return () => {
+      listeners.delete(callback);
+      if (listeners.size === 0) {
+        this.toolChangeListeners.delete(toolName);
+      }
+    };
+  }
+  /**
+   * Notify all listeners about tool changes
+   * @private
+   */
+  notifyToolChange(toolName) {
+    const listeners = this.toolChangeListeners.get(toolName);
+    if (!listeners || listeners.size === 0)
+      return;
+    const info = this.toolRegistry.get(toolName);
+    const payload = info ? {
+      refCount: info.refCount,
+      isRegistered: info.isRegistered
+    } : null;
+    listeners.forEach((callback) => {
+      try {
+        callback(payload);
+      } catch (error) {
+        logger.error("[ToolRegistry] Error in tool change listener:", error);
+      }
+    });
+  }
+  /**
+   * Clear all tools (useful for cleanup/testing)
+   */
+  clear() {
+    this.toolHandlers.clear();
+    this.toolRegistry.clear();
+    this.toolChangeListeners.clear();
+    logger.log("[ToolRegistry] Cleared all tools");
+  }
+  /**
+   * Get all tool names (including those with refCount > 0)
+   */
+  getAllToolNames() {
+    return Array.from(this.toolRegistry.keys());
+  }
+};
+
+// 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)
@@ -45,14 +418,10 @@ var WorkerClient = class _WorkerClient {
   // Initialization state
   isInitialized = false;
   initResolvers = [];
-  // Queue for operations that need to wait for initialization
-  pendingRegistrations = [];
-  // Map to store tool handlers in main thread
-  toolHandlers = /* @__PURE__ */ new Map();
-  // Tool registry for tracking registrations and reference counting
-  toolRegistry = /* @__PURE__ */ new Map();
-  // Subscribers for tool changes (for React hooks reactivity)
-  toolChangeListeners = /* @__PURE__ */ new Map();
+  // 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";
@@ -156,26 +525,27 @@ var WorkerClient = class _WorkerClient {
    * @private
    */
   cleanupAllTools() {
-    const toolNames = Array.from(this.toolRegistry.keys());
+    const toolNames = this.toolRegistry.getAllToolNames();
     if (toolNames.length === 0) {
       return;
     }
     logger.log(
       `[WorkerClient] Page unloading, cleaning up ${toolNames.length} tool(s)`
     );
+    this.webMcpAdapter.clearAll();
     toolNames.forEach((toolName) => {
-      const existing = this.toolRegistry.get(toolName);
+      const existing = this.toolRegistry.getInfo(toolName);
       if (!existing)
         return;
-      existing.refCount = 1;
       try {
         this.post("UNREGISTER_TOOL", {
           name: toolName,
           tabId: this.tabId
         }).catch(() => {
         });
-        this.toolHandlers.delete(toolName);
-        this.toolRegistry.delete(toolName);
+        while (this.toolRegistry.isRegistered(toolName)) {
+          this.toolRegistry.unregister(toolName);
+        }
       } catch (error) {
         logger.warn(
           `[WorkerClient] Failed to unregister '${toolName}' during cleanup:`,
@@ -207,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 () => {
@@ -253,43 +631,74 @@ var WorkerClient = class _WorkerClient {
     return this.initPromise;
   }
   /**
-   * Mark worker as initialized and process pending registrations
+   * Mark worker as initialized and sync all registered tools to worker
    * @private
    */
   markAsInitialized() {
     this.isInitialized = true;
-    logger.log(
-      "[WorkerClient] Worker initialized, processing pending operations"
-    );
+    logger.log("[WorkerClient] Worker initialized, syncing tools to worker");
     this.registerTab();
     this.setActiveTab();
     this.initResolvers.forEach((resolve) => resolve());
     this.initResolvers = [];
-    const pending = [...this.pendingRegistrations];
-    this.pendingRegistrations = [];
-    pending.forEach(
-      async ({
-        name,
-        description,
-        inputSchema,
-        handler,
-        options,
-        resolve,
-        reject
-      }) => {
+    this.syncToolsToWorker().catch((error) => {
+      logger.error("[WorkerClient] Error syncing tools to worker:", error);
+    });
+  }
+  /**
+   * Synchronize all locally registered tools to worker
+   * @private
+   */
+  async syncToolsToWorker() {
+    const toolNames = this.toolRegistry.getRegisteredTools();
+    if (toolNames.length === 0) {
+      logger.log("[WorkerClient] No tools to sync");
+      return;
+    }
+    logger.log(`[WorkerClient] Syncing ${toolNames.length} tool(s) to worker`);
+    await Promise.all(
+      toolNames.map(async (toolName) => {
+        const details = this.toolRegistry.getDetails(toolName);
+        if (!details)
+          return;
+        const handler = this.toolRegistry.getHandler(toolName);
         try {
-          await this.registerToolInternal(
-            name,
-            description,
-            inputSchema,
-            handler,
-            options
+          await this.registerToolInWorker(
+            details.name,
+            details.description,
+            details.inputSchema,
+            {
+              outputSchema: details.outputSchema,
+              annotations: details.annotations,
+              execution: details.execution,
+              _meta: details._meta,
+              icons: details.icons,
+              title: details.title
+            }
           );
-          resolve();
+          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) {
-          reject(error instanceof Error ? error : new Error(String(error)));
+          logger.error(
+            `[WorkerClient] Failed to sync tool '${toolName}' to worker:`,
+            error
+          );
         }
-      }
+      })
     );
   }
   /**
@@ -798,29 +1207,29 @@ var WorkerClient = class _WorkerClient {
    * ```
    */
   async registerTool(name, description, inputSchema, handler, options) {
-    if (!this.isInitialized) {
-      logger.log(
-        `[WorkerClient] Queueing tool registration '${name}' (worker not initialized yet)`
-      );
-      return new Promise((resolve, reject) => {
-        this.pendingRegistrations.push({
-          name,
-          description,
-          inputSchema,
-          handler,
-          options,
-          resolve,
-          reject
-        });
-      });
-    }
-    return this.registerToolInternal(
+    const isNew = this.toolRegistry.register(
       name,
       description,
       inputSchema,
       handler,
       options
     );
+    if (!this.isInitialized) {
+      logger.log(
+        `[WorkerClient] Registered '${name}' locally (will sync to worker after init)`
+      );
+      return;
+    }
+    if (isNew) {
+      await this.registerToolInWorker(name, description, inputSchema, options);
+      this.webMcpAdapter.registerTool(
+        name,
+        description,
+        inputSchema,
+        handler,
+        options
+      );
+    }
   }
   /**
    * Enhance tool input schema with optional tabId parameter for multi-tab support
@@ -838,21 +1247,10 @@ var WorkerClient = class _WorkerClient {
     return enhanced;
   }
   /**
-   * Internal method to register tool (assumes worker is initialized)
+   * Register tool in worker only (assumes already registered in ToolRegistry)
    * @private
    */
-  async registerToolInternal(name, description, inputSchema, handler, options) {
-    const existing = this.toolRegistry.get(name);
-    if (existing) {
-      existing.refCount++;
-      logger.log(
-        `[WorkerClient] Incremented ref count for '${name}': ${existing.refCount}`
-      );
-      this.toolHandlers.set(name, handler);
-      this.notifyToolChange(name);
-      return;
-    }
-    this.toolHandlers.set(name, handler);
+  async registerToolInWorker(name, description, inputSchema, options) {
     const enhancedSchema = this.enhanceSchemaWithTabId(inputSchema);
     await this.request("REGISTER_TOOL", {
       name,
@@ -869,23 +1267,9 @@ var WorkerClient = class _WorkerClient {
       tabId: this.tabId
       // Tell worker which tab registered this
     });
-    this.toolRegistry.set(name, {
-      name,
-      description,
-      inputSchema: enhancedSchema,
-      outputSchema: options?.outputSchema,
-      annotations: options?.annotations,
-      execution: options?.execution,
-      _meta: options?._meta,
-      icons: options?.icons,
-      title: options?.title,
-      refCount: 1,
-      isRegistered: true
-    });
     logger.log(
       `[WorkerClient] Registered tool '${name}' with main-thread handler`
     );
-    this.notifyToolChange(name);
   }
   /**
    * Unregister a previously registered MCP tool
@@ -893,27 +1277,19 @@ var WorkerClient = class _WorkerClient {
    * @returns Promise that resolves to true if tool was found and removed
    */
   async unregisterTool(name) {
-    const existing = this.toolRegistry.get(name);
-    if (!existing) {
-      logger.warn(`[WorkerClient] Cannot unregister '${name}': not found`);
+    const result = this.toolRegistry.unregister(name);
+    if (result === null) {
       return false;
     }
-    existing.refCount--;
-    logger.log(
-      `[WorkerClient] Decremented ref count for '${name}': ${existing.refCount}`
-    );
-    if (existing.refCount <= 0) {
-      this.toolHandlers.delete(name);
-      const result = await this.request(
+    if (result) {
+      const workerResult = await this.request(
         "UNREGISTER_TOOL",
         { name, tabId: this.tabId }
       );
-      this.toolRegistry.delete(name);
+      this.webMcpAdapter.unregisterTool(name);
       logger.log(`[WorkerClient] Unregistered tool '${name}'`);
-      this.notifyToolChange(name);
-      return result?.success ?? false;
+      return workerResult?.success ?? false;
     }
-    this.notifyToolChange(name);
     return true;
   }
   /**
@@ -921,82 +1297,91 @@ var WorkerClient = class _WorkerClient {
    * Returns unsubscribe function
    */
   onToolChange(toolName, callback) {
-    if (!this.toolChangeListeners.has(toolName)) {
-      this.toolChangeListeners.set(toolName, /* @__PURE__ */ new Set());
-    }
-    const listeners = this.toolChangeListeners.get(toolName);
-    listeners.add(callback);
-    const current = this.toolRegistry.get(toolName);
-    if (current) {
-      callback({
-        refCount: current.refCount,
-        isRegistered: current.isRegistered
-      });
-    } else {
-      callback(null);
-    }
-    return () => {
-      listeners.delete(callback);
-      if (listeners.size === 0) {
-        this.toolChangeListeners.delete(toolName);
-      }
-    };
-  }
-  /**
-   * Notify all listeners about tool changes
-   * @private
-   */
-  notifyToolChange(toolName) {
-    const listeners = this.toolChangeListeners.get(toolName);
-    if (!listeners || listeners.size === 0)
-      return;
-    const info = this.toolRegistry.get(toolName);
-    const payload = info ? {
-      refCount: info.refCount,
-      isRegistered: info.isRegistered
-    } : null;
-    listeners.forEach((callback) => {
-      try {
-        callback(payload);
-      } catch (error) {
-        logger.error("[WorkerClient] Error in tool change listener:", error);
-      }
-    });
+    return this.toolRegistry.onToolChange(toolName, callback);
   }
   /**
    * Get tool info from registry
    */
   getToolInfo(toolName) {
-    const info = this.toolRegistry.get(toolName);
-    if (!info)
-      return null;
-    return {
-      refCount: info.refCount,
-      isRegistered: info.isRegistered
-    };
+    return this.toolRegistry.getInfo(toolName);
   }
   /**
    * Get complete tool details from registry
    */
   getToolDetails(toolName) {
-    const info = this.toolRegistry.get(toolName);
-    if (!info)
-      return null;
-    return info;
+    return this.toolRegistry.getDetails(toolName);
   }
   /**
    * Get all registered tool names
    */
   getRegisteredTools() {
-    return Array.from(this.toolRegistry.keys()).filter(
-      (name) => this.toolRegistry.get(name)?.isRegistered
-    );
+    return this.toolRegistry.getRegisteredTools();
   }
   /**
    * Check if a tool is registered
    */
   isToolRegistered(toolName) {
-    return this.toolRegistry.get(toolName)?.isRegistered ?? false;
+    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
@@ -1008,7 +1393,7 @@ var WorkerClient = class _WorkerClient {
       args
     });
     try {
-      const handler = this.toolHandlers.get(toolName);
+      const handler = this.toolRegistry.getHandler(toolName);
       if (!handler) {
         throw new Error(`Tool handler not found: ${toolName}`);
       }
@@ -1137,6 +1522,7 @@ async function queryEvents(filters) {
   });
 }
 export {
+  WebMcpAdapter,
   WorkerClient,
   logger,
   queryEvents,