npm - @mcp-b/webmcp-ts-sdk - Versions diffs - 4.1.0-beta.20260702224704 → 5.0.1 - Mend

@mcp-b/webmcp-ts-sdk 4.1.0-beta.20260702224704 → 5.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/README.md CHANGED Viewed

@@ -1,261 +1,108 @@
 # @mcp-b/webmcp-ts-sdk
-> Browser-adapted MCP TypeScript SDK - Dynamic tool registration for AI agents like Claude, ChatGPT, and Gemini
+A thin WebMCP adapter over the official MCP TypeScript SDK v2.
 [![npm version](https://img.shields.io/npm/v/@mcp-b/webmcp-ts-sdk?style=flat-square)](https://www.npmjs.com/package/@mcp-b/webmcp-ts-sdk)
 [![npm downloads](https://img.shields.io/npm/dm/@mcp-b/webmcp-ts-sdk?style=flat-square)](https://www.npmjs.com/package/@mcp-b/webmcp-ts-sdk)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue?style=flat-square)](https://www.typescriptlang.org/)
-**[Reference](https://docs.mcp-b.ai/packages/webmcp-ts-sdk/reference)** | **[First Tool Tutorial](https://docs.mcp-b.ai/tutorials/first-tool)**
-**@mcp-b/webmcp-ts-sdk** adapts the official MCP TypeScript SDK for browser environments, enabling dynamic tool registration required by the WebMCP API. This allows AI agents like Claude, ChatGPT, Gemini, Cursor, and Copilot to interact with browser-based applications.
-## Why Use @mcp-b/webmcp-ts-sdk?
-| Feature                       | Benefit                                                               |
-| ----------------------------- | --------------------------------------------------------------------- |
-| **Dynamic Tool Registration** | Register tools after transport connection - required for browser apps |
-| **Full SDK Compatibility**    | Re-exports all types, classes, and utilities from official SDK        |
-| **Type-Safe**                 | No prototype hacks - clean TypeScript extension                       |
-| **Auto-Updates**              | Types and protocol follow official SDK automatically                  |
-## Overview
-This package adapts the official [@modelcontextprotocol/sdk](https://www.npmjs.com/package/@modelcontextprotocol/sdk) for browser environments with modifications to support dynamic tool registration required by the [WebMCP API](https://webmachinelearning.github.io/webmcp/) (`document.modelContext`).
-## Why This Package Exists
-The official MCP TypeScript SDK has a restriction that prevents registering server capabilities (like tools) after a transport connection is established. This is enforced by this check in the `Server` class:
-```typescript
-public registerCapabilities(capabilities: ServerCapabilities): void {
-    if (this.transport) {
-        throw new Error('Cannot register capabilities after connecting to transport');
-    }
-    ...
-}
-```
-For WebMCP, this restriction is incompatible because:
-1. **Tools arrive dynamically** - Web pages call `document.modelContext.registerTool(...)` at any time
-2. **Transport must be ready immediately** - The MCP server/transport needs to be connected when the page loads
-3. **Asynchronous registration** - Tools are registered as the page's JavaScript executes, potentially long after initialization
-This package solves the problem by **pre-registering tool capabilities** before the transport connects, allowing dynamic tool registration to work seamlessly.
-Compatibility note:
-- `BrowserMcpServer.registerTool(tool, options?)` accepts the WebMCP April 23, 2026 draft signature, including `options.signal` (`AbortSignal`) for unregistration. When the signal aborts, both the server-side registration and the mirrored native registration are removed.
-- The same call resolves `undefined`, matching current Chromium and the WebMCP spec.
-- `unregisterTool(name)` was removed from the WebMCP draft on April 23, 2026 in favor of the `AbortSignal` flow. It is kept on `BrowserMcpServer` with a one-time deprecation warning for older MCP-B integrations. It will be removed in the next major version.
-- `provideContext()` and `clearContext()` were removed from the WebMCP draft on March 5, 2026 and are not exposed by `BrowserMcpServer`.
-## Modifications from Official SDK
-### BrowserMcpServer Class
-The `BrowserMcpServer` extends `McpServer` with these changes:
-```typescript
-export class BrowserMcpServer extends BaseMcpServer {
-  constructor(serverInfo, options?) {
-    // Pre-register tool capabilities in constructor
-    const enhancedOptions = {
-      ...options,
-      capabilities: mergeCapabilities(options?.capabilities || {}, {
-        tools: { listChanged: true },
-      }),
-    };
-    super(serverInfo, enhancedOptions);
-  }
-  async connect(transport: Transport) {
-    // Ensure capabilities are set before connecting
-    // This bypasses the "cannot register after connect" restriction
-    return super.connect(transport);
-  }
-}
-```
-**Key Difference**: Capabilities are registered **before** connecting, allowing tools to be added dynamically afterward.
-## What's Re-Exported
-This package re-exports almost everything from the official SDK:
-### Types
-- All MCP protocol types (`Tool`, `Resource`, `Prompt`, etc.)
-- Request/response schemas
-- Client and server capabilities
-- Error codes and constants
-### Classes
-- `Server` - Base server class (unchanged)
-- `McpServer` - Aliased to `BrowserMcpServer` with our modifications
-### Utilities
-- `Transport` interface
-- `mergeCapabilities` helper
-- Protocol version constants
+[`BrowserMcpServer`](https://docs.mcp-b.ai/packages/webmcp-ts-sdk/reference) composes and exposes the official v2 `McpServer`. Use this package when you need direct control over the browser adapter. Most applications should use [`@mcp-b/global`](https://docs.mcp-b.ai/packages/global/overview).
 ## Installation
 ```bash
-npm install @mcp-b/webmcp-ts-sdk
-# or
-pnpm add @mcp-b/webmcp-ts-sdk
+pnpm add @mcp-b/webmcp-ts-sdk @mcp-b/transports
 ```
-## Usage
-Use it exactly like the official SDK:
+## Example
-```typescript
-import { McpServer } from '@mcp-b/webmcp-ts-sdk';
+```ts
 import { TabServerTransport } from '@mcp-b/transports';
+import { BrowserMcpServer } from '@mcp-b/webmcp-ts-sdk';
-const server = new McpServer({
-  name: 'my-web-app',
+const server = new BrowserMcpServer({
+  name: 'catalog-app',
   version: '1.0.0',
 });
-// Connect transport first
-const transport = new TabServerTransport({ allowedOrigins: ['*'] });
-await server.connect(transport);
-// Now you can register tools dynamically (this would fail with official SDK)
-server.registerTool(
-  'my-tool',
-  {
-    description: 'A dynamically registered tool',
-    inputSchema: { message: z.string() },
-    // outputSchema is MCP-B metadata for structured, type-safe responses
-    outputSchema: { result: z.string() },
-  },
-  async ({ message }) => {
-    return {
-      content: [{ type: 'text', text: `Echo: ${message}` }],
-      // structuredContent should match the outputSchema for MCP-B adapters
-      structuredContent: { result: `Echo: ${message}` },
-    };
-  }
+await server.connect(
+  new TabServerTransport({
+    allowedOrigins: ['https://shop.example'],
+  })
 );
-// Example with complex output schema
-server.registerTool(
-  'analyze-data',
+const controller = new AbortController();
+await server.registerTool(
   {
-    description: 'Analyze data and return structured results',
+    name: 'echo',
+    description: 'Echo a message',
     inputSchema: {
-      data: z.array(z.number()),
-      operation: z.enum(['sum', 'average', 'stats']),
+      type: 'object',
+      properties: { message: { type: 'string' } },
+      required: ['message'],
     },
-    outputSchema: {
-      result: z.number(),
-      operation: z.string(),
-      metadata: z.object({
-        count: z.number(),
-        min: z.number().optional(),
-        max: z.number().optional(),
-      }),
+    async execute({ message }) {
+      return { content: [{ type: 'text', text: `Echo: ${String(message)}` }] };
     },
   },
-  async ({ data, operation }) => {
-    const stats = calculateStats(data, operation);
-    return {
-      content: [{ type: 'text', text: `Result: ${stats.result}` }],
-      structuredContent: stats,
-    };
-  }
+  { signal: controller.signal }
 );
-```
-## Architecture
+controller.abort();
 ```
-┌─────────────────────────────────┐
-│  @mcp-b/webmcp-ts-sdk           │
-│                                 │
-│  ┌───────────────────────────┐  │
-│  │ BrowserMcpServer          │  │
-│  │ (Modified behavior)        │  │
-│  └───────────┬───────────────┘  │
-│              │ extends          │
-│              ▼                  │
-│  ┌───────────────────────────┐  │
-│  │ @modelcontextprotocol/sdk │  │
-│  │ (Official SDK)             │  │
-│  │ - Types                    │  │
-│  │ - Protocol                 │  │
-│  │ - Validation               │  │
-│  └───────────────────────────┘  │
-└─────────────────────────────────┘
-```
-## Maintenance Strategy
-This package is designed for **minimal maintenance**:
+An `AbortSignal` owns each WebMCP tool registration. Aborting it removes the local MCP registration and its native mirror.
-- **Automatic updates** for types, protocol, validation via official SDK dependency
-- **Small modification surface** - capability registration and browser runtime adaptation
-- **Type-safe** - no prototype hacks or unsafe casts
+## What the adapter owns
-### Syncing with Upstream
+- WebMCP `registerTool()`, `getTools()`, `ontoolchange`, and descriptor-based `executeTool()`
+- Native `document.modelContext` registration mirroring and tool reconciliation
+- MCP-B `registerPrompt()`, `registerResource()`, and `listTools()` extensions
+- MCP transport lifecycle through `connect()` and `close()`
-When the official SDK updates:
+The official `McpServer` owns MCP registration, validation, and protocol behavior. Access it through `server.mcpServer` for official SDK APIs. Register multi-round tools directly on `server.mcpServer`; WebMCP descriptor callbacks are single-round when exposed over MCP.
-1. Update the catalog version in `pnpm-workspace.yaml`
-2. Run `pnpm install` to get latest SDK
-3. Test that capability registration still works
-4. Update this README if SDK behavior changes
+Prompt and resource discovery also belongs to MCP. Use a connected MCP client instead of adapter-side list, read, or get methods.
-The modification surface is intentionally small and should be checked whenever
-the upstream SDK changes capability registration behavior.
+## Native integration
-## Frequently Asked Questions
+Pass an existing context as `native`, then reconcile its current tools:
-### Why can't I use the official SDK directly?
-The official SDK throws an error if you try to register tools after connecting a transport. Browsers need dynamic registration because tools arrive asynchronously as the page loads.
+```ts
+const server = new BrowserMcpServer(
+  { name: 'catalog-app', version: '1.0.0' },
+  { native: document.modelContext }
+);
-### Is this a fork of the official SDK?
+await server.syncNativeTools();
+```
-No. It is an adapter that extends the official SDK. Core protocol handling and most SDK types come from the upstream package.
+`syncNativeTools()` resolves after reconciliation. Later native `toolchange` events trigger another reconciliation. Backfill requires Chrome's optional descriptor-based `executeTool()` extension.
-### Will this break when the official SDK updates?
+## Schema boundary
-Unlikely. The modification surface is isolated. When upstream updates, update the dependency and run the conformance tests.
+The browser-facing API accepts JSON Schema and Standard Schema inputs. The adapter converts them to the MCP SDK v2 contract. Direct upstream registrations can use Zod 4.2 or newer or the official `fromJsonSchema` helper; Zod 3 is unsupported.
-### When should I use this vs `@mcp-b/global`?
+MCP requires an object-root tool input schema. An array-root WebMCP tool remains available through WebMCP but is omitted from MCP discovery.
-Use `@mcp-b/global` for the standard `document.modelContext` API. Use this package directly only if you need low-level control over the MCP server.
+## Exports
-## Related Packages
+- `BrowserMcpServer`
+- `BrowserMcpServerOptions`
+- `isBrowserMcpServer`
+- `PromptDescriptor`
+- `ResourceDescriptor`
-- [`@mcp-b/global`](https://docs.mcp-b.ai/packages/global/reference) - Full MCP-B browser runtime (uses this package internally)
-- [`@mcp-b/transports`](https://docs.mcp-b.ai/packages/transports/reference) - Browser-specific MCP transports
-- [`@mcp-b/react-webmcp`](https://docs.mcp-b.ai/packages/react-webmcp/reference) - React hooks for MCP
-- [`chrome-devtools-mcp`](https://github.com/ChromeDevTools/chrome-devtools-mcp) - Upstream Chrome DevTools MCP server
-- [`@modelcontextprotocol/sdk`](https://www.npmjs.com/package/@modelcontextprotocol/sdk) - Official MCP SDK
+Import MCP clients, servers, schemas, transports, and validators from the official `@modelcontextprotocol/*` packages.
-## Resources
+## Related documentation
-- [WebMCP Documentation](https://docs.mcp-b.ai)
+- [Package reference](https://docs.mcp-b.ai/packages/webmcp-ts-sdk/reference)
+- [MCP TypeScript SDK v2](https://ts.sdk.modelcontextprotocol.io/v2/)
 - [WebMCP specification](https://webmachinelearning.github.io/webmcp/)
-- [Model Context Protocol Spec](https://modelcontextprotocol.io/)
-- [Official MCP TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk)
-- [MCP GitHub Repository](https://github.com/modelcontextprotocol)
+- [Chrome Model Context Tool Inspector](https://chromewebstore.google.com/detail/model-context-tool-inspec/gbpdfapgefenggkahomfgkhfehlcenpd)
 ## License
-MIT - see [LICENSE](../../LICENSE) for details
-## Support
-- [GitHub Issues](https://github.com/WebMCP-org/npm-packages/issues)
-- [Documentation](https://docs.mcp-b.ai)
-- [Discord Community](https://discord.gg/a9fBR6Bw)
+MIT. See [LICENSE](../../LICENSE).

package/dist/index.d.ts CHANGED Viewed

@@ -1,249 +1,89 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { RequestOptions, RequestOptions as RequestOptions$1, mergeCapabilities } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
-import { CallToolRequest, CallToolRequestSchema, CallToolResult, CallToolResultSchema, ClientCapabilities, ClientNotification, ClientRequest, ClientResult, CreateMessageRequest, CreateMessageRequest as CreateMessageRequest$1, CreateMessageRequestSchema, CreateMessageResult, CreateMessageResult as CreateMessageResult$1, CreateMessageResultSchema, ElicitRequest, ElicitRequest as ElicitRequest$1, ElicitRequestSchema, ElicitResult, ElicitResult as ElicitResult$1, ElicitResultSchema, ErrorCode, GetPromptRequest, GetPromptRequestSchema, GetPromptResult, GetPromptResultSchema, Implementation, Implementation as Implementation$1, InitializeRequest, InitializeRequestSchema, InitializeResult, InitializeResultSchema, JSONRPCMessage, JSONRPCMessageSchema, LATEST_PROTOCOL_VERSION, ListPromptsRequest, ListPromptsRequestSchema, ListPromptsResult, ListPromptsResultSchema, ListResourcesRequest, ListResourcesRequestSchema, ListResourcesResult, ListResourcesResultSchema, ListToolsRequest, ListToolsRequestSchema, ListToolsResult, ListToolsResultSchema, LoggingLevel, LoggingLevelSchema, LoggingMessageNotification, McpError, Notification, Prompt, PromptMessage, PromptMessage as PromptMessage$1, ReadResourceRequest, ReadResourceRequestSchema, ReadResourceResult, ReadResourceResultSchema, Request, Resource, ResourceContents, ResourceListChangedNotificationSchema, ResourceTemplate, Result, SUPPORTED_PROTOCOL_VERSIONS, ServerCapabilities, ServerNotification, ServerRequest, ServerResult, Tool, ToolAnnotations, ToolListChangedNotificationSchema } from "@modelcontextprotocol/sdk/types.js";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { CfWorkerJsonSchemaValidator, CfWorkerJsonSchemaValidator as PolyfillJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/cfworker";
-import { Transport, Transport as Transport$1, TransportSendOptions } from "@modelcontextprotocol/sdk/shared/transport.js";
-import { InputSchema, InputSchema as InputSchema$1, InputSchemaProperty, JsonObject, JsonValue, ModelContextClient, ModelContextCore, ModelContextRegisterToolOptions, ModelContextTestingExecuteToolOptions, ModelContextToolInfo, ModelContextToolReference, ResourceContents as ResourceContents$1, ToolDescriptor, ToolDescriptor as ToolDescriptor$1, ToolExecuteResult, ToolListItem, ToolListItem as ToolListItem$1, ToolResponse, ToolResponse as ToolResponse$1 } from "@mcp-b/webmcp-types";
-import { ServerOptions } from "@modelcontextprotocol/sdk/server/index.js";
-import { JsonSchemaValidatorResult, jsonSchemaValidator } from "@modelcontextprotocol/sdk/validation";
+import { GetPromptResult, Implementation, McpServer, ReadResourceResult, ServerOptions, Transport, Variables } from "@modelcontextprotocol/server";
+import { ChromeModelContextExecuteToolOptions, InputSchema, ModelContext, ModelContextGetToolOptions, ModelContextWithExtensions, RegisteredTool, RegistrationHandle, ToolListItem } from "@mcp-b/webmcp-types";
 //#region src/browser-server.d.ts
 declare const SERVER_MARKER_PROPERTY: "__isBrowserMcpServer";
+declare function isBrowserMcpServer(context: unknown): context is BrowserMcpServer;
 interface BrowserMcpServerOptions extends ServerOptions {
-  native?: ModelContextCore;
+  native?: ModelContext;
 }
 /**
- * Browser-optimized MCP Server that speaks WebMCP natively.
+ * Thin WebMCP-to-MCP v2 adapter.
  *
- * Implements `registerTool(tool, options?)` while retaining MCP capabilities
- * (resources, prompts, elicitation, sampling) via BaseMcpServer.
- *
- * Deprecated compatibility (kept for Chrome Beta 147 and existing wrappers,
- * removed in the next major): `unregisterTool(name)`.
- *
- * When `native` is provided, tool operations are mirrored so that
- * navigator.modelContextTesting stays in sync.
+ * The official v2 `McpServer` owns MCP registration, validation, and transport
+ * behavior. This class only adds the document-facing WebMCP contract and native
+ * Chrome mirroring.
  */
-declare class BrowserMcpServer extends McpServer {
+declare class BrowserMcpServer extends EventTarget implements ModelContextWithExtensions {
   readonly [SERVER_MARKER_PROPERTY]: true;
-  private native;
-  private _promptSchemas;
-  private _jsonValidator;
-  private _publicMethodsBound;
-  private _unregisterToolDeprecationWarned;
-  private _nativeToolCleanups;
-  private _tools;
-  private _producerEventTarget;
-  private _ontoolchange;
-  private _producerToolsChangedQueued;
-  constructor(serverInfo: Implementation$1, options?: BrowserMcpServerOptions);
-  /**
-   * navigator.modelContext consumers may destructure methods (e.g. const { registerTool } = ...).
-   * Bind methods once so they remain callable outside instance-method invocation syntax.
-   */
-  private bindPublicApiMethods;
-  private get _parentResources();
-  private get _parentPrompts();
-  private toJsonSchema;
-  private toInputTransportSchema;
-  private toOutputTransportSchema;
-  private isZodSchema;
-  private getNativeLegacyToolsApi;
+  readonly mcpServer: McpServer;
+  private readonly native;
+  private readonly ownerDocument;
+  private readonly tools;
+  private peerOrigin;
+  private readonly registrations;
+  private readonly nativeToolAbortControllers;
+  private readonly nativeBackfilledTools;
+  private readonly pendingTools;
+  private readonly removingNativeTools;
+  private nativeSyncQueue;
+  private nativeToolChangeQueue;
+  private nativeToolChangeListener;
+  private closed;
+  private closePromise;
+  private ontoolchangeHandler;
+  private readonly ontoolchangeListener;
+  constructor(serverInfo: Implementation, options?: BrowserMcpServerOptions);
+  get ontoolchange(): ((this: ModelContext, event: Event) => unknown) | null;
+  set ontoolchange(handler: ((this: ModelContext, event: Event) => unknown) | null);
+  private notifyProducerToolsChanged;
   private getNativeStandardToolsApi;
-  private getNativeUnregisterTool;
-  private createNativeToolCleanup;
   private registerNativeToolMirror;
-  private unregisterNativeToolMirror;
-  private installToolRequestHandlers;
-  private registerToolInServer;
-  get ontoolchange(): ((this: ModelContextCore, ev: Event) => unknown) | null;
-  set ontoolchange(handler: ((this: ModelContextCore, ev: Event) => unknown) | null);
-  addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
-  removeEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
-  dispatchEvent(event: Event): boolean;
-  private notifyProducerToolsChanged;
-  backfillTools(tools: readonly ToolListItem$1[], execute: (name: string, args: Record<string, unknown>) => Promise<ToolResponse$1>): number;
-  registerTool(tool: ToolDescriptor$1, options?: ModelContextRegisterToolOptions): Promise<void>;
-  /**
-   * Backfill tools that were already registered on the native/polyfill context
-   * before this BrowserMcpServer wrapper was installed.
-   */
-  syncNativeTools(): number;
+  private abortNativeToolMirror;
+  private validateToolDescriptor;
+  private registerToolInMcp;
+  readonly registerTool: ModelContextWithExtensions['registerTool'];
+  private removeTool;
+  syncNativeTools(): Promise<void>;
   private backfillNativeStandardTools;
-  unregisterTool(nameOrTool: string | ModelContextToolReference): void;
-  registerResource(descriptor: {
-    uri: string;
-    name: string;
-    description?: string;
-    mimeType?: string;
-    read: (uri: URL, params?: Record<string, string>) => Promise<{
-      contents: ResourceContents$1[];
-    }>;
-  }): {
-    unregister: () => void;
-  };
-  registerPrompt(descriptor: {
-    name: string;
-    description?: string;
-    argsSchema?: InputSchema$1;
-    get: (args: Record<string, unknown>) => Promise<{
-      messages: PromptMessage$1[];
-    }>;
-  }): {
-    unregister: () => void;
-  };
-  private resolveToolNameForUnregister;
-  private warnUnregisterToolDeprecationOnce;
-  listResources(): Array<{
-    uri: string;
-    name: string;
-    description?: string;
-    mimeType?: string;
-  }>;
-  readResource(uri: string): Promise<{
-    contents: ResourceContents$1[];
-  }>;
-  listPrompts(): Array<{
-    name: string;
-    description?: string;
-    arguments?: Array<{
-      name: string;
-      description?: string;
-      required?: boolean;
-    }>;
-  }>;
-  getPrompt(name: string, args?: Record<string, unknown>): Promise<{
-    messages: PromptMessage$1[];
-  }>;
-  listTools(): ToolListItem$1[];
-  private listToolsForMcpTransport;
-  private toMcpCallToolResult;
-  getTools(): Promise<ModelContextToolInfo[]>;
-  /**
-   * Override SDK's validateToolInput to handle both Zod schemas and plain JSON Schema.
-   * Zod schemas use the SDK's safeParseAsync; plain JSON Schema uses the configured SDK validator.
-   */
-  validateToolInput(tool: {
-    inputSchema?: unknown;
-  }, args: Record<string, unknown> | undefined, toolName: string): Promise<Record<string, unknown> | undefined>;
+  registerResource(descriptor: ResourceDescriptor): RegistrationHandle;
+  registerPrompt(descriptor: PromptDescriptor): RegistrationHandle;
+  listTools(): ToolListItem[];
+  getTools(options?: ModelContextGetToolOptions): Promise<RegisteredTool[]>;
+  executeTool(tool: RegisteredTool, inputArgsJson: string, options?: ChromeModelContextExecuteToolOptions): Promise<string | null>;
   /**
-   * Override SDK's validateToolOutput to handle both Zod schemas and plain JSON Schema.
-   */
-  validateToolOutput(tool: {
-    outputSchema?: unknown;
-  }, result: unknown, toolName: string): Promise<void>;
-  /**
-   * Executes a registered tool by name.
+   * Re-evaluate which registered tools may appear on the wire.
    *
-   * @deprecated Prefer the WebMCP standard producer path: get a descriptor from
-   * `getTools()` and pass it to `executeTool(tool, inputArgsJson)`. This method
-   * remains as an MCP-B compatibility convenience and MCP transport bridge.
+   * `exposedTo` narrows a tool to named embedder origins. The peer origin is only known
+   * once a transport that reports one has heard from its peer, so a restricted tool stays
+   * disabled until then — and stays disabled forever on transports that cannot name a peer
+   * at all. Failing closed keeps a tool that asked for a narrow audience from reaching a
+   * wider one; unrestricted tools are untouched and behave exactly as before.
    */
-  callTool(params: {
-    name: string;
-    arguments?: Record<string, unknown>;
-  }): Promise<ToolResponse$1>;
+  private applyToolExposure;
   /**
-   * Executes a tool descriptor returned from getTools().
-   */
-  executeTool(tool: ModelContextToolInfo, inputArgsJson: string, options?: ModelContextTestingExecuteToolOptions): Promise<string | null>;
-  /**
-   * Executes a registered tool by name.
-   *
-   * @deprecated Prefer the WebMCP standard producer path: get a descriptor from
-   * `getTools()` and pass it to `executeTool(tool, inputArgsJson)`.
+   * Follow the peer origin of transports that report one, so `exposedTo` can be scoped to
+   * the embedder actually connected. Duck-typed rather than imported: the SDK must not take
+   * a build dependency on `@mcp-b/transports`, and transports that never name a peer simply
+   * leave every restricted tool disabled.
    */
-  executeTool(name: string, args?: Record<string, unknown>): Promise<ToolResponse$1>;
-  /**
-   * Override connect to initialize request handlers BEFORE the transport connection.
-   * This prevents "Cannot register capabilities after connecting to transport" errors
-   * when tools are registered dynamically after connection.
-   *
-   * Tool handlers are installed with the public low-level Server API in the constructor.
-   * Prompt/resource handlers still come from the parent, then prompt handlers are replaced
-   * where the parent expects Zod shapes instead of plain JSON Schema.
-   */
-  connect(transport: Transport$1): Promise<void>;
-  createMessage(params: CreateMessageRequest$1['params'], options?: RequestOptions$1): Promise<CreateMessageResult$1>;
-  elicitInput(params: ElicitRequest$1['params'], options?: RequestOptions$1): Promise<ElicitResult$1>;
+  private observePeerOrigin;
+  connect(transport: Transport): Promise<void>;
+  close(): Promise<void>;
 }
 interface ResourceDescriptor {
   uri: string;
   name: string;
   description?: string;
   mimeType?: string;
-  read: (uri: URL, params?: Record<string, string>) => Promise<{
-    contents: ResourceContents$1[];
-  }>;
+  read: (uri: URL, params?: Variables) => Promise<ReadResourceResult>;
 }
 interface PromptDescriptor {
   name: string;
   description?: string;
-  argsSchema?: InputSchema$1;
-  get: (args: Record<string, unknown>) => Promise<{
-    messages: PromptMessage$1[];
-  }>;
+  argsSchema?: InputSchema;
+  get: (args: Record<string, string>) => Promise<GetPromptResult>;
 }
 //#endregion
-//#region src/no-op-validator.d.ts
-/**
- * No-op JSON Schema validator for browser environments.
- *
- * This validator bypasses the MCP SDK's internal ajv-based validation which causes
- * "Error compiling schema" errors in browser extensions due to ajv's use of
- * eval/Function constructor.
- *
- * Validation is handled externally by Zod in @mcp-b/global, making the SDK's
- * internal validation redundant. This no-op validator allows the SDK to function
- * without the ajv dependency issues.
- */
-/**
- * A no-op JSON Schema validator that always returns valid.
- *
- * Use this in browser environments where:
- * - ajv causes "Error compiling schema" errors
- * - Validation is already handled elsewhere (e.g., by Zod)
- * - You need to avoid eval/Function constructor restrictions
- *
- * @example
- * ```typescript
- * import { BrowserMcpServer } from '@mcp-b/webmcp-ts-sdk';
- * import { NoOpJsonSchemaValidator } from '@mcp-b/webmcp-ts-sdk/no-op-validator';
- *
- * const server = new BrowserMcpServer(
- *   { name: 'my-server', version: '1.0.0' },
- *   { jsonSchemaValidator: new NoOpJsonSchemaValidator() }
- * );
- * ```
- */
-declare class NoOpJsonSchemaValidator implements jsonSchemaValidator {
-  /**
-   * Returns a validator function that always passes.
-   * The input data is passed through unchanged.
-   *
-   * @param _schema - The JSON Schema (ignored)
-   * @returns A validator function that always returns valid
-   */
-  getValidator<T>(_schema: unknown): (input: unknown) => JsonSchemaValidatorResult<T>;
-}
-//#endregion
-//#region src/schema.d.ts
-declare const DEFAULT_INPUT_SCHEMA: InputSchema$1;
-interface ToWebMcpJsonSchemaOptions {
-  requireObjectType?: boolean;
-}
-/**
- * Converts Zod schemas, Zod raw shapes, or plain JSON Schema objects to the
- * JSON Schema shape expected by WebMCP tool descriptors.
- */
-declare function toWebMcpJsonSchema(schema: unknown, options?: ToWebMcpJsonSchemaOptions): InputSchema$1;
-declare function toWebMcpInputSchema(schema: unknown): InputSchema$1;
-//#endregion
-//#region src/index.d.ts
-type SamplingRequestParams = CreateMessageRequest$1['params'];
-type SamplingResult = CreateMessageResult$1;
-//#endregion
-export { BrowserMcpServer, BrowserMcpServer as McpServer, type BrowserMcpServerOptions, type CallToolRequest, CallToolRequestSchema, type CallToolResult, CallToolResultSchema, CfWorkerJsonSchemaValidator, Client, type ClientCapabilities, type ClientNotification, type ClientRequest, type ClientResult, type CreateMessageRequest, CreateMessageRequestSchema, type CreateMessageResult, CreateMessageResultSchema, DEFAULT_INPUT_SCHEMA, type ElicitRequest, ElicitRequestSchema, type ElicitResult, ElicitResultSchema, ErrorCode, type GetPromptRequest, GetPromptRequestSchema, type GetPromptResult, GetPromptResultSchema, type Implementation, type InitializeRequest, InitializeRequestSchema, type InitializeResult, InitializeResultSchema, type InputSchema, type InputSchemaProperty, type JSONRPCMessage, JSONRPCMessageSchema, type JsonObject, type JsonValue, LATEST_PROTOCOL_VERSION, type ListPromptsRequest, ListPromptsRequestSchema, type ListPromptsResult, ListPromptsResultSchema, type ListResourcesRequest, ListResourcesRequestSchema, type ListResourcesResult, ListResourcesResultSchema, type ListToolsRequest, ListToolsRequestSchema, type ListToolsResult, ListToolsResultSchema, type LoggingLevel, LoggingLevelSchema, type LoggingMessageNotification, type McpError, type ModelContextClient, NoOpJsonSchemaValidator, type Notification, PolyfillJsonSchemaValidator, type Prompt, type PromptDescriptor, type PromptMessage, ReadBuffer, type ReadResourceRequest, ReadResourceRequestSchema, type ReadResourceResult, ReadResourceResultSchema, type Request, type RequestOptions, type Resource, type ResourceContents, type ResourceDescriptor, ResourceListChangedNotificationSchema, type ResourceTemplate, type Result, SERVER_MARKER_PROPERTY, SUPPORTED_PROTOCOL_VERSIONS, SamplingRequestParams, SamplingResult, type ServerCapabilities, type ServerNotification, type ServerRequest, type ServerResult, type ToWebMcpJsonSchemaOptions, type Tool, type ToolAnnotations, type ToolDescriptor, type ToolExecuteResult, ToolListChangedNotificationSchema, type ToolListItem, type ToolResponse, type Transport, type TransportSendOptions, mergeCapabilities, serializeMessage, toWebMcpInputSchema, toWebMcpJsonSchema };
+export { BrowserMcpServer, type BrowserMcpServerOptions, type PromptDescriptor, type ResourceDescriptor, isBrowserMcpServer };
 //# sourceMappingURL=index.d.ts.map