@mcp-fe/mcp-worker 0.1.11 → 0.2.0

package/docs/index.md

@@ -11,6 +11,7 @@ Complete guide to all documentation and examples in the MCP Worker library.
 | **Learn step-by-step** | [Guide](./guide.md) |
 | **Complete API reference** | [API Reference](./api.md) |
 | **Multi-tab applications** | [Multi-Tab Guide](./multi-tab.md) |
+| **WebMCP integration** | [WebMCP](./native-webmcp.md) |
 | **Worker implementation** | [Worker Details](./worker-details.md) |
 | **Understand codebase structure** | [Project Structure](./project-structure.md) |
 | **Use with React** | [React Hooks Guide](../../react-event-tracker/REACT_MCP_TOOLS.md) |

package/docs/native-webmcp.md

@@ -0,0 +1,232 @@
+# WebMCP Integration
+
+## Overview
+
+The MCP Worker library includes a built-in adapter for the **WebMCP API** (`navigator.modelContext`), a browser-native mechanism for registering MCP tools directly with the user-agent. When the browser supports this API, tools registered via `WorkerClient` are **automatically** advertised through the native channel as well, enabling browser-level tool discovery by AI agents, browser's agents, and assistive technologies.
+
+**Enabled by default** — if the browser supports `navigator.modelContext`, it just works. No configuration needed. You can explicitly disable it if needed.
+
+Based on the [WebMCP specification](https://webmachinelearning.github.io/webmcp/) published by the W3C Web Machine Learning Community Group.
+
+## How It Works
+
+```
+┌──────────────────────────────────────────────────────────┐
+│                    WorkerClient                           │
+│                                                           │
+│  registerTool('my-tool', ...)                             │
+│       │                                                   │
+│       ├──→ ToolRegistry (local, immediate)                │
+│       │                                                   │
+│       ├──→ SharedWorker / ServiceWorker (transport)       │
+│       │        └──→ WebSocket → Backend MCP Server        │
+│       │                                                   │
+│       └──→ WebMcpAdapter (auto-enabled if supported)      │
+│                └──→ navigator.modelContext.registerTool()  │
+│                     (browser-native registration)         │
+└──────────────────────────────────────────────────────────┘
+```
+
+**Key principle**: The worker transport remains the **primary** channel. WebMCP registration is a **secondary, additive** channel for browser-level discovery. Both systems coexist.
+
+## WebMCP Spec API Surface
+
+The adapter maps to the following browser API (per spec §5):
+
+```webidl
+// §5.1 Navigator extension
+partial interface Navigator {
+  [SecureContext, SameObject] readonly attribute ModelContext modelContext;
+};
+
+// §5.2 ModelContext interface
+interface ModelContext {
+  undefined provideContext(optional ModelContextOptions options = {});
+  undefined clearContext();
+  undefined registerTool(ModelContextTool tool);
+  undefined unregisterTool(DOMString name);
+};
+
+// §5.2.2 ModelContextTool dictionary
+dictionary ModelContextTool {
+  required DOMString name;
+  required DOMString description;
+  object inputSchema;
+  required ToolExecuteCallback execute;
+  ToolAnnotations annotations;
+};
+
+dictionary ToolAnnotations {
+  boolean readOnlyHint;
+};
+
+callback ToolExecuteCallback = Promise<any> (object input, ModelContextClient client);
+
+// §5.2.3 ModelContextClient
+interface ModelContextClient {
+  Promise<any> requestUserInteraction(UserInteractionCallback callback);
+};
+```
+
+## Feature Detection
+
+```typescript
+import { WorkerClient, WebMcpAdapter } from '@anthropic/mcp-worker';
+
+// Static check: does the browser support navigator.modelContext?
+if (WorkerClient.isWebMcpSupported()) {
+  console.log('Browser supports WebMCP!');
+}
+
+// Or use the adapter directly:
+if (WebMcpAdapter.isSupported()) {
+  console.log('navigator.modelContext is available');
+}
+```
+
+## Configuration
+
+### Default behavior (auto-enabled)
+
+No configuration needed. If `navigator.modelContext` is available, tools are automatically registered via WebMCP:
+
+```typescript
+import { workerClient } from '@anthropic/mcp-worker';
+
+await workerClient.init({
+  sharedWorkerUrl: '/mcp-shared-worker.js',
+  backendWsUrl: 'ws://localhost:3001',
+  // enableWebMcp defaults to true — auto-detects browser support
+});
+```
+
+### Explicitly disable
+
+```typescript
+await workerClient.init({
+  sharedWorkerUrl: '/mcp-shared-worker.js',
+  backendWsUrl: 'ws://localhost:3001',
+  enableWebMcp: false,  // ← disable WebMCP registration
+});
+```
+
+### Toggle at runtime
+
+```typescript
+// Disable — calls navigator.modelContext.clearContext()
+workerClient.setWebMcpEnabled(false);
+
+// Re-enable — syncs all existing tools to navigator.modelContext
+workerClient.setWebMcpEnabled(true);
+```
+
+## Registering Tools
+
+No changes to tool registration are needed. When WebMCP is available, `registerTool()` automatically registers in both systems:
+
+```typescript
+await workerClient.registerTool(
+  'get-user-profile',
+  'Fetch the current user profile',
+  {
+    type: 'object',
+    properties: {
+      userId: { type: 'string', description: 'User ID' },
+    },
+    required: ['userId'],
+  },
+  async (args: unknown) => {
+    const { userId } = args as { userId: string };
+    const profile = await fetchProfile(userId);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(profile) }],
+    };
+  },
+  { annotations: { readOnlyHint: true } },
+);
+
+// Check where the tool is registered:
+workerClient.isToolRegistered('get-user-profile');            // true (local + worker)
+workerClient.isToolRegisteredViaWebMcp('get-user-profile');   // true (navigator.modelContext)
+```
+
+## Querying WebMCP Registrations
+
+```typescript
+// Check if a specific tool is registered via WebMCP
+workerClient.isToolRegisteredViaWebMcp('my-tool'); // boolean
+
+// Get all WebMCP-registered tool names
+workerClient.getWebMcpRegisteredTools(); // string[]
+
+// Check if WebMCP is currently enabled AND supported
+workerClient.isWebMcpAvailable(); // boolean
+```
+
+## Cleanup
+
+WebMCP registrations are cleaned up automatically:
+
+- **On `unregisterTool()`** — calls `navigator.modelContext.unregisterTool(name)`
+- **On page unload** (`beforeunload` / `pagehide`) — calls `navigator.modelContext.clearContext()`
+- **On `setWebMcpEnabled(false)`** — calls `navigator.modelContext.clearContext()`
+
+## Architecture
+
+### Files
+
+| File | Purpose |
+|------|---------|
+| `web-mcp-types.ts` | TypeScript types matching the WebMCP spec (`ModelContext`, `ModelContextTool`, `ModelContextClient`, etc.) |
+| `web-mcp-adapter.ts` | Adapter that bridges ToolRegistry ↔ `navigator.modelContext` |
+| `worker-client.ts` | Integration point (uses adapter internally) |
+
+### Type Augmentation
+
+The `web-mcp-types.ts` file extends the global `Navigator` interface:
+
+```typescript
+declare global {
+  interface Navigator {
+    readonly modelContext?: ModelContext;
+  }
+}
+```
+
+### WebMcpAdapter
+
+The adapter is a standalone class, enabled by default:
+
+- **`isSupported()`** — static, checks `navigator.modelContext` existence
+- **`isAvailable()`** — instance, respects enabled flag + browser support
+- **`registerTool()`** — builds `ModelContextTool` dict and calls `navigator.modelContext.registerTool(tool)` (synchronous)
+- **`unregisterTool()`** — calls `navigator.modelContext.unregisterTool(name)` (synchronous)
+- **`clearAll()`** — calls `navigator.modelContext.clearContext()` (per spec §5.2)
+- **`toModelContextTool()`** — static utility to convert internal `ToolDefinition` + handler
+
+### Handler Mapping
+
+The spec defines `ToolExecuteCallback` as:
+
+```typescript
+callback ToolExecuteCallback = Promise<any> (object input, ModelContextClient client);
+```
+
+The adapter wraps the internal `ToolHandler` (which takes `args: unknown` and returns `{ content: [...] }`) into this format. The `ModelContextClient` parameter gives access to `requestUserInteraction()` for user consent flows.
+
+## Error Handling
+
+All WebMCP operations are **best-effort**:
+
+- Registration failures are logged as warnings, never thrown
+- The worker-based system is unaffected by WebMCP errors
+- Per spec, `registerTool()` throws if a duplicate name exists — the adapter unregisters first
+- `clearAll()` falls back to individual `unregisterTool()` calls if `clearContext()` throws
+
+## Browser Support
+
+The WebMCP specification is a CG-DRAFT published by the W3C Web Machine Learning Community Group (February 2026). The adapter is forward-compatible:
+
+- When the API is unavailable, all WebMCP operations are silent no-ops
+- Zero runtime cost when browser doesn't support it (no feature detection on hot paths)
+- The type definitions follow the spec and can be updated as the standard evolves

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:`,
@@ -1003,6 +1222,13 @@ var WorkerClient = class _WorkerClient {
     }
     if (isNew) {
       await this.registerToolInWorker(name, description, inputSchema, options);
+      this.webMcpAdapter.registerTool(
+        name,
+        description,
+        inputSchema,
+        handler,
+        options
+      );
     }
   }
   /**
@@ -1060,6 +1286,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 +1323,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 +1522,7 @@ async function queryEvents(filters) {
   });
 }
 export {
+  WebMcpAdapter,
   WorkerClient,
   logger,
   queryEvents,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-fe/mcp-worker",
-  "version": "0.1.11",
+  "version": "0.2.0",
   "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"}

package/src/client/web-mcp-adapter.d.ts

@@ -0,0 +1,97 @@
+/**
+ * WebMcpAdapter — bridge between WorkerClient's tool system and the WebMCP API.
+ *
+ * Responsibilities:
+ * - Feature-detect `navigator.modelContext` availability
+ * - Map internal ToolDefinition + ToolHandler to the ModelContextTool format
+ * - Track which tools have been registered via WebMCP for cleanup
+ * - Provide register / unregister / cleanup that are safe no-ops when API is absent
+ *
+ * Design principles:
+ * - The adapter is ADDITIVE: the worker-based system remains the primary transport.
+ *   WebMCP registration is a secondary channel for browser-level tool discovery.
+ * - Enabled by default — auto-detects browser support. Can be explicitly disabled.
+ * - All public methods are safe to call even when the API is unavailable —
+ *   they silently return without throwing.
+ * - The WebMCP API (§5.2) is synchronous: registerTool() and unregisterTool()
+ *   return `undefined`. The adapter wraps them in try/catch for safety.
+ *
+ * @see https://webmachinelearning.github.io/webmcp/
+ */
+import type { ToolDefinition } from '../shared/types';
+import type { ToolHandler, ToolOptions } from './tool-registry';
+import type { ModelContextTool } from './web-mcp-types';
+export declare class WebMcpAdapter {
+    /** Tracks names of tools currently registered via WebMCP API */
+    private registeredTools;
+    /** Whether the adapter is enabled (enabled by default — auto-detects browser support) */
+    private enabled;
+    /**
+     * 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(): boolean;
+    /**
+     * Convenience: instance-level check that also respects the `enabled` flag.
+     */
+    isAvailable(): boolean;
+    /**
+     * Enable or disable the WebMCP adapter.
+     *
+     * When disabled, `registerTool` / `unregisterTool` become silent no-ops
+     * even if the browser supports the API.
+     */
+    setEnabled(value: boolean): void;
+    /**
+     * 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: string, description: string | undefined, inputSchema: Record<string, unknown>, handler: ToolHandler, options?: ToolOptions): void;
+    /**
+     * 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: string): boolean;
+    /**
+     * 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(): void;
+    /**
+     * Check if a tool is registered via WebMCP.
+     */
+    isRegistered(name: string): boolean;
+    /**
+     * Get names of all tools registered via WebMCP.
+     */
+    getRegisteredTools(): string[];
+    /**
+     * Map internal ToolAnnotations to WebMCP ToolAnnotations.
+     * The spec currently only defines `readOnlyHint`.
+     */
+    private mapAnnotations;
+    /**
+     * Convert internal ToolDefinition to ModelContextTool format (utility).
+     * Requires an execute callback to be provided separately.
+     */
+    static toModelContextTool(tool: ToolDefinition, handler: ToolHandler): ModelContextTool;
+}
+//# sourceMappingURL=web-mcp-adapter.d.ts.map

package/src/client/web-mcp-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-mcp-adapter.d.ts","sourceRoot":"","sources":["../../../../../libs/mcp-worker/src/client/web-mcp-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,KAAK,EAEV,gBAAgB,EAEjB,MAAM,iBAAiB,CAAC;AAEzB,qBAAa,aAAa;IACxB,gEAAgE;IAChE,OAAO,CAAC,eAAe,CAAqB;IAE5C,yFAAyF;IACzF,OAAO,CAAC,OAAO,CAAQ;IAMvB;;;;;;OAMG;WACW,WAAW,IAAI,OAAO;IAapC;;OAEG;IACI,WAAW,IAAI,OAAO;IAQ7B;;;;;OAKG;IACI,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IASvC;;;;;;;;;;;;OAYG;IACI,YAAY,CACjB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,OAAO,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,WAAW,GACpB,IAAI;IAuCP;;;;;;;OAOG;IACI,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAyB5C;;;;;OAKG;IACI,QAAQ,IAAI,IAAI;IAoCvB;;OAEG;IACI,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1C;;OAEG;IACI,kBAAkB,IAAI,MAAM,EAAE;IAQrC;;;OAGG;IACH,OAAO,CAAC,cAAc;IAUtB;;;OAGG;WACW,kBAAkB,CAC9B,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,WAAW,GACnB,gBAAgB;CAapB"}

package/src/client/web-mcp-types.d.ts

@@ -0,0 +1,122 @@
+/**
+ * WebMCP API type definitions
+ *
+ * These types model the browser API (`navigator.modelContext`)
+ * based on the WebMCP specification (webmachinelearning.github.io/webmcp).
+ *
+ * The API allows web pages to register MCP tools with the browser/user-agent,
+ * enabling AI agents, browser's agents, and assistive technologies to discover and
+ * invoke them without relying on custom worker transports.
+ *
+ * When the API is not available, the existing worker-based transport is used
+ * as the sole registration path. When the API IS available, tools are registered
+ * in BOTH systems (worker for backward compat + browser-level for discovery).
+ *
+ * @see https://webmachinelearning.github.io/webmcp/
+ */
+/**
+ * Callback invoked to perform user interaction (e.g., showing a confirmation dialog).
+ *
+ * @see https://webmachinelearning.github.io/webmcp/#callbackdef-userinteractioncallback
+ */
+export type UserInteractionCallback = () => Promise<unknown>;
+/**
+ * Represents an agent executing a tool provided by the site through the ModelContext API.
+ *
+ * @see https://webmachinelearning.github.io/webmcp/#modelcontextclient
+ */
+export interface ModelContextClient {
+    /**
+     * Asynchronously requests user input during the execution of a tool.
+     * The callback function is invoked to perform the user interaction,
+     * and the promise resolves with the result of the callback.
+     */
+    requestUserInteraction(callback: UserInteractionCallback): Promise<unknown>;
+}
+/**
+ * Callback invoked when an agent calls a tool.
+ * Receives the input parameters and a ModelContextClient object.
+ *
+ * @see https://webmachinelearning.github.io/webmcp/#callbackdef-toolexecutecallback
+ */
+export type ToolExecuteCallback = (input: object, client: ModelContextClient) => Promise<unknown>;
+/**
+ * Optional annotations providing additional metadata about a tool's behavior.
+ *
+ * @see https://webmachinelearning.github.io/webmcp/#dictdef-toolannotations
+ */
+export interface WebMcpToolAnnotations {
+    /**
+     * If true, indicates the tool does not modify any state and only reads data.
+     * This hint helps agents decide when it is safe to call the tool.
+     */
+    readOnlyHint?: boolean;
+}
+/**
+ * Describes a tool that can be invoked by agents.
+ *
+ * @see https://webmachinelearning.github.io/webmcp/#dictdef-modelcontexttool
+ */
+export interface ModelContextTool {
+    /** A unique identifier for the tool. Used by agents to reference the tool. */
+    name: string;
+    /** A natural language description of the tool's functionality. */
+    description: string;
+    /** A JSON Schema object describing the expected input parameters. */
+    inputSchema?: object;
+    /** Callback invoked when an agent calls the tool. */
+    execute: ToolExecuteCallback;
+    /** Optional annotations providing additional metadata about the tool's behavior. */
+    annotations?: WebMcpToolAnnotations;
+}
+/**
+ * Options for `provideContext()`.
+ *
+ * @see https://webmachinelearning.github.io/webmcp/#dictdef-modelcontextoptions
+ */
+export interface ModelContextOptions {
+    /** A list of tools to register with the browser. Each tool name must be unique. */
+    tools?: ModelContextTool[];
+}
+/**
+ * The `ModelContext` interface provides methods for web applications to register
+ * and manage tools that can be invoked by agents.
+ *
+ * Accessed via `navigator.modelContext`.
+ *
+ * @see https://webmachinelearning.github.io/webmcp/#model-context-container
+ */
+export interface ModelContext {
+    /**
+     * Registers the provided context (tools) with the browser.
+     * Clears any pre-existing tools and other context before registering the new ones.
+     */
+    provideContext(options?: ModelContextOptions): void;
+    /**
+     * Unregisters all context (tools) with the browser.
+     */
+    clearContext(): void;
+    /**
+     * Registers a single tool without clearing the existing set of tools.
+     * Throws an error if a tool with the same name already exists,
+     * or if the inputSchema is invalid.
+     */
+    registerTool(tool: ModelContextTool): void;
+    /**
+     * Removes the tool with the specified name from the registered set.
+     */
+    unregisterTool(name: string): void;
+}
+declare global {
+    interface Navigator {
+        /**
+         * WebMCP API — available when the browser supports the WebMCP specification.
+         * Use `WebMcpAdapter.isSupported()` for safe feature detection.
+         *
+         * @see https://webmachinelearning.github.io/webmcp/#navigator-extension
+         */
+        readonly modelContext?: ModelContext;
+    }
+}
+export {};
+//# sourceMappingURL=web-mcp-types.d.ts.map

package/src/client/web-mcp-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-mcp-types.d.ts","sourceRoot":"","sources":["../../../../../libs/mcp-worker/src/client/web-mcp-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAMH;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;AAE7D;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,sBAAsB,CAAC,QAAQ,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7E;AAMD;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAChC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,kBAAkB,KACvB,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,OAAO,EAAE,mBAAmB,CAAC;IAC7B,oFAAoF;IACpF,WAAW,CAAC,EAAE,qBAAqB,CAAC;CACrC;AAMD;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,mFAAmF;IACnF,KAAK,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAC5B;AAMD;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,cAAc,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAEpD;;OAEG;IACH,YAAY,IAAI,IAAI,CAAC;IAErB;;;;OAIG;IACH,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAE3C;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAMD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,SAAS;QACjB;;;;;WAKG;QACH,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC;KACtC;CACF;AAGD,OAAO,EAAE,CAAC"}

package/src/client/worker-client.d.ts

@@ -45,6 +45,14 @@ export type WorkerClientInitOptions = {
     serviceWorkerUrl?: string;
     /** Backend WebSocket URL to configure inside the worker (optional) */
     backendWsUrl?: string;
+    /**
+     * Enable WebMCP API registration via `navigator.modelContext`.
+     * When `true` (default) and the browser supports the WebMCP spec, tools will be
+     * registered both in the worker transport AND via the browser API.
+     * Set to `false` to explicitly disable WebMCP registration.
+     * Defaults to `true`.
+     */
+    enableWebMcp?: boolean;
 };
 export declare class WorkerClient {
     private sharedWorkerUrl;
@@ -60,6 +68,7 @@ export declare class WorkerClient {
     private isInitialized;
     private initResolvers;
     private toolRegistry;
+    private webMcpAdapter;
     private tabId;
     private static readonly TAB_ID_STORAGE_KEY;
     constructor();
@@ -226,6 +235,28 @@ export declare class WorkerClient {
      * Check if a tool is registered
      */
     isToolRegistered(toolName: string): boolean;
+    /**
+     * Check if the browser supports the WebMCP API (`navigator.modelContext`).
+     */
+    static isWebMcpSupported(): boolean;
+    /**
+     * Check if WebMCP is both enabled AND supported.
+     */
+    isWebMcpAvailable(): boolean;
+    /**
+     * 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: boolean): void;
+    /**
+     * Check if a specific tool is registered via the WebMCP API.
+     */
+    isToolRegisteredViaWebMcp(toolName: string): boolean;
+    /**
+     * Get names of tools registered via the WebMCP API.
+     */
+    getWebMcpRegisteredTools(): string[];
     /**
      * Handle tool call from worker - execute handler in main thread and return result
      * @private

package/src/client/worker-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker-client.d.ts","sourceRoot":"","sources":["../../../../../libs/mcp-worker/src/client/worker-client.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"worker-client.d.ts","sourceRoot":"","sources":["../../../../../libs/mcp-worker/src/client/worker-client.ts"],"names":[],"mappings":"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"}