@mcp-b/webmcp-ts-sdk 0.0.0-beta-20260216200013

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 mcp-b contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,246 @@
+# @mcp-b/webmcp-ts-sdk
+
+> Browser-adapted MCP TypeScript SDK - Dynamic tool registration for AI agents like Claude, ChatGPT, and Gemini
+
+[![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/)
+[![Minimal Code](https://img.shields.io/badge/Custom_Code-~50_lines-green?style=flat-square)](https://github.com/WebMCP-org/npm-packages)
+
+**[Full Documentation](https://docs.mcp-b.ai/packages/webmcp-ts-sdk)** | **[Quick Start](https://docs.mcp-b.ai/quickstart)**
+
+**@mcp-b/webmcp-ts-sdk** adapts the official MCP TypeScript SDK for browser environments, enabling dynamic tool registration required by the W3C Web Model Context 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 |
+| **Minimal Overhead** | Only ~50 lines of custom code on top of official SDK |
+| **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 [W3C Web Model Context API](https://github.com/nicolo-ribaudo/model-context-protocol-api) (`window.navigator.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 the Web Model Context API, this restriction is incompatible because:
+
+1. **Tools arrive dynamically** - Web pages call `window.navigator.modelContext.provideContext({ tools: [...] })` 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.
+
+## 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
+
+## Installation
+
+```bash
+npm install @mcp-b/webmcp-ts-sdk
+# or
+pnpm add @mcp-b/webmcp-ts-sdk
+```
+
+## Usage
+
+Use it exactly like the official SDK:
+
+```typescript
+import { McpServer } from '@mcp-b/webmcp-ts-sdk';
+import { TabServerTransport } from '@mcp-b/transports';
+
+const server = new McpServer({
+  name: 'my-web-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() },
+  // Output schemas enable structured, type-safe AI responses
+  outputSchema: { result: z.string() }
+}, async ({ message }) => {
+  return {
+    content: [{ type: 'text', text: `Echo: ${message}` }],
+    // structuredContent must match the outputSchema
+    structuredContent: { result: `Echo: ${message}` }
+  };
+});
+
+// Example with complex output schema
+server.registerTool('analyze-data', {
+  description: 'Analyze data and return structured results',
+  inputSchema: {
+    data: z.array(z.number()),
+    operation: z.enum(['sum', 'average', 'stats'])
+  },
+  outputSchema: {
+    result: z.number(),
+    operation: z.string(),
+    metadata: z.object({
+      count: z.number(),
+      min: z.number().optional(),
+      max: z.number().optional()
+    })
+  }
+}, async ({ data, operation }) => {
+  const stats = calculateStats(data, operation);
+  return {
+    content: [{ type: 'text', text: `Result: ${stats.result}` }],
+    structuredContent: stats
+  };
+});
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────┐
+│  @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**:
+
+- **~50 lines** of custom code
+- **Automatic updates** for types, protocol, validation via official SDK dependency
+- **Single modification point** - only capability registration behavior
+- **Type-safe** - no prototype hacks or unsafe casts
+
+### Syncing with Upstream
+
+When the official SDK updates:
+
+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
+
+The modification is minimal and unlikely to conflict with upstream changes.
+
+## Frequently Asked Questions
+
+### 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.
+
+### Is this a fork of the official SDK?
+
+No - it's a thin adapter (~50 lines) that extends the official SDK. All types, protocol handling, and validation come from the upstream package.
+
+### Will this break when the official SDK updates?
+
+Unlikely. The modification is minimal and isolated. When upstream updates, just update your dependencies - the wrapper adapts automatically.
+
+### When should I use this vs `@mcp-b/global`?
+
+Use `@mcp-b/global` for the standard `navigator.modelContext` API. Use this package directly only if you need low-level control over the MCP server.
+
+## Related Packages
+
+- [`@mcp-b/global`](https://docs.mcp-b.ai/packages/global) - W3C Web Model Context API polyfill (uses this package internally)
+- [`@mcp-b/transports`](https://docs.mcp-b.ai/packages/transports) - Browser-specific MCP transports
+- [`@mcp-b/react-webmcp`](https://docs.mcp-b.ai/packages/react-webmcp) - React hooks for MCP
+- [`@mcp-b/chrome-devtools-mcp`](https://docs.mcp-b.ai/packages/chrome-devtools-mcp) - Connect desktop AI agents to browser tools
+- [`@modelcontextprotocol/sdk`](https://www.npmjs.com/package/@modelcontextprotocol/sdk) - Official MCP SDK
+
+## Resources
+
+- [WebMCP Documentation](https://docs.mcp-b.ai)
+- [Web Model Context API Explainer](https://github.com/nicolo-ribaudo/model-context-protocol-api)
+- [Model Context Protocol Spec](https://modelcontextprotocol.io/)
+- [Official MCP TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk)
+- [MCP GitHub Repository](https://github.com/modelcontextprotocol)
+
+## 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)

package/dist/index.d.ts

@@ -0,0 +1,202 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { Server, ServerOptions } from "@modelcontextprotocol/sdk/server/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 { InputSchema, ModelContextCore, ModelContextOptions, ResourceContents as ResourceContents$1, ToolDescriptor, ToolListItem, ToolResponse } from "@mcp-b/webmcp-types";
+import { Transport, Transport as Transport$1, TransportSendOptions } from "@modelcontextprotocol/sdk/shared/transport.js";
+
+//#region src/browser-server.d.ts
+interface BrowserMcpServerOptions extends ServerOptions {
+  native?: ModelContextCore;
+}
+/**
+ * Browser-optimized MCP Server that speaks WebMCP natively.
+ *
+ * This server IS navigator.modelContext — it implements the WebMCP standard API
+ * (provideContext, registerTool, unregisterTool, clearContext) while retaining
+ * full MCP protocol capabilities (resources, prompts, elicitation, sampling)
+ * via the inherited BaseMcpServer surface.
+ *
+ * When `native` is provided, all tool operations are mirrored to it so that
+ * navigator.modelContextTesting (polyfill testing shim) stays in sync.
+ */
+declare class BrowserMcpServer extends McpServer {
+  private native;
+  constructor(serverInfo: Implementation$1, options?: BrowserMcpServerOptions);
+  private get _parentTools();
+  private get _parentResources();
+  private get _parentPrompts();
+  registerTool(tool: ToolDescriptor): {
+    unregister: () => void;
+  };
+  unregisterTool(name: string): 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;
+    get: (args: Record<string, unknown>) => Promise<{
+      messages: PromptMessage$1[];
+    }>;
+  }): {
+    unregister: () => void;
+  };
+  provideContext(options?: ModelContextOptions): void;
+  clearContext(): void;
+  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[];
+  callTool(params: {
+    name: string;
+    arguments?: Record<string, unknown>;
+  }): Promise<ToolResponse>;
+  executeTool(name: string, args?: Record<string, unknown>): Promise<ToolResponse>;
+  /**
+   * 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.
+   */
+  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>;
+}
+interface ResourceDescriptor {
+  uri: string;
+  name: string;
+  description?: string;
+  mimeType?: string;
+  read: (uri: URL, params?: Record<string, string>) => Promise<{
+    contents: ResourceContents$1[];
+  }>;
+}
+interface PromptDescriptor {
+  name: string;
+  description?: string;
+  argsSchema?: InputSchema;
+  get: (args: Record<string, unknown>) => Promise<{
+    messages: PromptMessage$1[];
+  }>;
+}
+//#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.
+ */
+/**
+ * Interface for JSON Schema validators.
+ * This matches the MCP SDK's jsonSchemaValidator interface.
+ */
+interface JsonSchemaValidator$1 {
+  getValidator<T>(schema: unknown): (input: unknown) => JsonSchemaValidatorResult$1<T>;
+}
+/**
+ * Result type for JSON Schema validation
+ */
+type JsonSchemaValidatorResult$1<T> = {
+  valid: true;
+  data: T;
+  errorMessage: undefined;
+} | {
+  valid: false;
+  data: undefined;
+  errorMessage: string;
+};
+/**
+ * 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$1 {
+  /**
+   * 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$1<T>;
+}
+//#endregion
+//#region src/polyfill-validator.d.ts
+interface JsonSchemaValidator {
+  getValidator<T>(schema: unknown): (input: unknown) => JsonSchemaValidatorResult<T>;
+}
+type JsonSchemaValidatorResult<T> = {
+  valid: true;
+  data: T;
+  errorMessage: undefined;
+} | {
+  valid: false;
+  data: undefined;
+  errorMessage: string;
+};
+declare class PolyfillJsonSchemaValidator implements JsonSchemaValidator {
+  getValidator<T>(schema: unknown): (input: unknown) => JsonSchemaValidatorResult<T>;
+}
+//#endregion
+//#region src/index.d.ts
+type SamplingRequestParams = CreateMessageRequest$1['params'];
+type SamplingResult = CreateMessageResult$1;
+declare global {
+  interface Navigator {
+    modelContext: BrowserMcpServer;
+  }
+}
+//# sourceMappingURL=index.d.ts.map
+
+//#endregion
+export { BrowserMcpServer, BrowserMcpServer as McpServer, type BrowserMcpServerOptions, type CallToolRequest, CallToolRequestSchema, type CallToolResult, CallToolResultSchema, Client, type ClientCapabilities, type ClientNotification, type ClientRequest, type ClientResult, type CreateMessageRequest, CreateMessageRequestSchema, type CreateMessageResult, CreateMessageResultSchema, type ElicitRequest, ElicitRequestSchema, type ElicitResult, ElicitResultSchema, ErrorCode, type GetPromptRequest, GetPromptRequestSchema, type GetPromptResult, GetPromptResultSchema, type Implementation, type InitializeRequest, InitializeRequestSchema, type InitializeResult, InitializeResultSchema, type JSONRPCMessage, JSONRPCMessageSchema, 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, 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, SUPPORTED_PROTOCOL_VERSIONS, SamplingRequestParams, SamplingResult, Server, type ServerCapabilities, type ServerNotification, type ServerRequest, type ServerResult, type Tool, type ToolAnnotations, ToolListChangedNotificationSchema, type Transport, type TransportSendOptions, mergeCapabilities, serializeMessage };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/browser-server.ts","../src/no-op-validator.ts","../src/polyfill-validator.ts","../src/index.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,226 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { mergeCapabilities, mergeCapabilities as mergeCapabilities$1 } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
+import { CallToolRequestSchema, CallToolResultSchema, CreateMessageRequestSchema, CreateMessageResultSchema, ElicitRequestSchema, ElicitResultSchema, ErrorCode, GetPromptRequestSchema, GetPromptResultSchema, InitializeRequestSchema, InitializeResultSchema, JSONRPCMessageSchema, LATEST_PROTOCOL_VERSION, ListPromptsRequestSchema, ListPromptsResultSchema, ListResourcesRequestSchema, ListResourcesResultSchema, ListToolsRequestSchema, ListToolsResultSchema, LoggingLevelSchema, ReadResourceRequestSchema, ReadResourceResultSchema, ResourceListChangedNotificationSchema, SUPPORTED_PROTOCOL_VERSIONS, ToolListChangedNotificationSchema } from "@modelcontextprotocol/sdk/types.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { isPlainObject, validateArgsWithSchema } from "@mcp-b/webmcp-polyfill";
+
+//#region src/polyfill-validator.ts
+var PolyfillJsonSchemaValidator = class {
+	getValidator(schema) {
+		return (input) => {
+			if (!isPlainObject(input)) return {
+				valid: false,
+				data: void 0,
+				errorMessage: "expected object arguments"
+			};
+			const issue = validateArgsWithSchema(input, schema);
+			if (issue) return {
+				valid: false,
+				data: void 0,
+				errorMessage: issue.message
+			};
+			return {
+				valid: true,
+				data: input,
+				errorMessage: void 0
+			};
+		};
+	}
+};
+
+//#endregion
+//#region src/browser-server.ts
+const DEFAULT_INPUT_SCHEMA = {
+	type: "object",
+	properties: {}
+};
+/**
+* Browser-optimized MCP Server that speaks WebMCP natively.
+*
+* This server IS navigator.modelContext — it implements the WebMCP standard API
+* (provideContext, registerTool, unregisterTool, clearContext) while retaining
+* full MCP protocol capabilities (resources, prompts, elicitation, sampling)
+* via the inherited BaseMcpServer surface.
+*
+* When `native` is provided, all tool operations are mirrored to it so that
+* navigator.modelContextTesting (polyfill testing shim) stays in sync.
+*/
+var BrowserMcpServer = class extends McpServer {
+	native;
+	constructor(serverInfo, options) {
+		const enhancedOptions = {
+			capabilities: mergeCapabilities$1(options?.capabilities || {}, {
+				tools: { listChanged: true },
+				resources: { listChanged: true },
+				prompts: { listChanged: true }
+			}),
+			jsonSchemaValidator: options?.jsonSchemaValidator ?? new PolyfillJsonSchemaValidator()
+		};
+		super(serverInfo, enhancedOptions);
+		this.native = options?.native;
+	}
+	get _parentTools() {
+		return this._registeredTools;
+	}
+	get _parentResources() {
+		return this._registeredResources;
+	}
+	get _parentPrompts() {
+		return this._registeredPrompts;
+	}
+	registerTool(tool) {
+		if (this.native) this.native.registerTool(tool);
+		const inputSchema = tool.inputSchema ?? DEFAULT_INPUT_SCHEMA;
+		try {
+			super.registerTool(tool.name, {
+				description: tool.description,
+				inputSchema,
+				...tool.outputSchema ? { outputSchema: tool.outputSchema } : {},
+				...tool.annotations ? { annotations: tool.annotations } : {}
+			}, async (args) => {
+				return tool.execute(args, { requestUserInteraction: async (cb) => cb() });
+			});
+			return { unregister: () => this.unregisterTool(tool.name) };
+		} catch (error) {
+			if (this.native) try {
+				this.native.unregisterTool(tool.name);
+			} catch {}
+			throw error;
+		}
+	}
+	unregisterTool(name) {
+		this._parentTools[name]?.remove();
+		if (this.native) this.native.unregisterTool(name);
+	}
+	registerResource(descriptor) {
+		const registered = super.registerResource(descriptor.name, descriptor.uri, {
+			...descriptor.description !== void 0 && { description: descriptor.description },
+			...descriptor.mimeType !== void 0 && { mimeType: descriptor.mimeType }
+		}, async (uri) => ({ contents: (await descriptor.read(uri)).contents }));
+		return { unregister: () => registered.remove() };
+	}
+	registerPrompt(descriptor) {
+		const registered = super.registerPrompt(descriptor.name, {
+			...descriptor.description !== void 0 && { description: descriptor.description },
+			...descriptor.argsSchema !== void 0 && { argsSchema: descriptor.argsSchema }
+		}, async (args) => ({ messages: (await descriptor.get(args)).messages }));
+		return { unregister: () => registered.remove() };
+	}
+	provideContext(options) {
+		for (const tool of Object.values(this._parentTools)) tool.remove();
+		if (this.native) this.native.clearContext();
+		for (const tool of options?.tools ?? []) this.registerTool(tool);
+	}
+	clearContext() {
+		for (const tool of Object.values(this._parentTools)) tool.remove();
+		if (this.native) this.native.clearContext();
+	}
+	listResources() {
+		return Object.entries(this._parentResources).filter(([, resource]) => resource.enabled).map(([uri, resource]) => ({
+			uri,
+			name: resource.name,
+			...resource.metadata
+		}));
+	}
+	async readResource(uri) {
+		const resource = this._parentResources[uri];
+		if (!resource) throw new Error(`Resource not found: ${uri}`);
+		return resource.readCallback(new URL(uri), {});
+	}
+	listPrompts() {
+		return Object.entries(this._parentPrompts).filter(([, prompt]) => prompt.enabled).map(([name, prompt]) => ({
+			name,
+			...prompt.description !== void 0 && { description: prompt.description },
+			...prompt.argsSchema ? { arguments: Object.entries(prompt.argsSchema ?? {}).map(([argName]) => ({ name: argName })) } : {}
+		}));
+	}
+	async getPrompt(name, args = {}) {
+		const prompt = this._parentPrompts[name];
+		if (!prompt) throw new Error(`Prompt not found: ${name}`);
+		return prompt.callback(args, {});
+	}
+	listTools() {
+		return Object.entries(this._parentTools).filter(([, tool]) => tool.enabled).map(([name, tool]) => {
+			const item = {
+				name,
+				description: tool.description ?? "",
+				inputSchema: tool.inputSchema ?? DEFAULT_INPUT_SCHEMA
+			};
+			if (tool.outputSchema) item.outputSchema = tool.outputSchema;
+			if (tool.annotations) item.annotations = tool.annotations;
+			return item;
+		});
+	}
+	async callTool(params) {
+		const tool = this._parentTools[params.name];
+		if (!tool) throw new Error(`Tool not found: ${params.name}`);
+		return tool.handler(params.arguments ?? {}, {});
+	}
+	async executeTool(name, args = {}) {
+		return this.callTool({
+			name,
+			arguments: args
+		});
+	}
+	/**
+	* 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.
+	*/
+	async connect(transport) {
+		this.setToolRequestHandlers();
+		this.setResourceRequestHandlers();
+		this.setPromptRequestHandlers();
+		return super.connect(transport);
+	}
+	async createMessage(params, options) {
+		return this.server.createMessage(params, options);
+	}
+	async elicitInput(params, options) {
+		return this.server.elicitInput(params, options);
+	}
+};
+
+//#endregion
+//#region src/no-op-validator.ts
+/**
+* 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() }
+* );
+* ```
+*/
+var NoOpJsonSchemaValidator = class {
+	/**
+	* 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(_schema) {
+		return (input) => ({
+			valid: true,
+			data: input,
+			errorMessage: void 0
+		});
+	}
+};
+
+//#endregion
+export { BrowserMcpServer, BrowserMcpServer as McpServer, CallToolRequestSchema, CallToolResultSchema, Client, CreateMessageRequestSchema, CreateMessageResultSchema, ElicitRequestSchema, ElicitResultSchema, ErrorCode, GetPromptRequestSchema, GetPromptResultSchema, InitializeRequestSchema, InitializeResultSchema, JSONRPCMessageSchema, LATEST_PROTOCOL_VERSION, ListPromptsRequestSchema, ListPromptsResultSchema, ListResourcesRequestSchema, ListResourcesResultSchema, ListToolsRequestSchema, ListToolsResultSchema, LoggingLevelSchema, NoOpJsonSchemaValidator, PolyfillJsonSchemaValidator, ReadBuffer, ReadResourceRequestSchema, ReadResourceResultSchema, ResourceListChangedNotificationSchema, SUPPORTED_PROTOCOL_VERSIONS, Server, ToolListChangedNotificationSchema, mergeCapabilities, serializeMessage };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["DEFAULT_INPUT_SCHEMA: InputSchema","BaseMcpServer","enhancedOptions: ServerOptions","mergeCapabilities","item: ToolListItem"],"sources":["../src/polyfill-validator.ts","../src/browser-server.ts","../src/no-op-validator.ts"],"sourcesContent":["import { isPlainObject, validateArgsWithSchema } from '@mcp-b/webmcp-polyfill';\nimport type { InputSchema } from '@mcp-b/webmcp-types';\n\ninterface JsonSchemaValidator {\n  getValidator<T>(schema: unknown): (input: unknown) => JsonSchemaValidatorResult<T>;\n}\n\ntype JsonSchemaValidatorResult<T> =\n  | { valid: true; data: T; errorMessage: undefined }\n  | { valid: false; data: undefined; errorMessage: string };\n\nexport class PolyfillJsonSchemaValidator implements JsonSchemaValidator {\n  getValidator<T>(schema: unknown): (input: unknown) => JsonSchemaValidatorResult<T> {\n    return (input: unknown): JsonSchemaValidatorResult<T> => {\n      if (!isPlainObject(input)) {\n        return { valid: false, data: undefined, errorMessage: 'expected object arguments' };\n      }\n\n      const issue = validateArgsWithSchema(input, schema as InputSchema);\n      if (issue) {\n        return { valid: false, data: undefined, errorMessage: issue.message };\n      }\n\n      return { valid: true, data: input as T, errorMessage: undefined };\n    };\n  }\n}\n","import type {\n  CallToolResult,\n  InputSchema,\n  ModelContextClient,\n  ModelContextCore,\n  ModelContextOptions,\n  ResourceContents,\n  ToolDescriptor,\n  ToolListItem,\n  ToolResponse,\n} from '@mcp-b/webmcp-types';\nimport type { ServerOptions } from '@modelcontextprotocol/sdk/server/index.js';\nimport { McpServer as BaseMcpServer } from '@modelcontextprotocol/sdk/server/mcp.js';\nimport type { RequestOptions } from '@modelcontextprotocol/sdk/shared/protocol.js';\nimport { mergeCapabilities } from '@modelcontextprotocol/sdk/shared/protocol.js';\nimport type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';\nimport type {\n  CreateMessageRequest,\n  CreateMessageResult,\n  ElicitRequest,\n  ElicitResult,\n  Implementation,\n  PromptMessage,\n} from '@modelcontextprotocol/sdk/types.js';\nimport { PolyfillJsonSchemaValidator } from './polyfill-validator.js';\n\nconst DEFAULT_INPUT_SCHEMA: InputSchema = { type: 'object', properties: {} };\n\ninterface ParentRegisteredTool {\n  description?: string;\n  inputSchema?: unknown;\n  outputSchema?: unknown;\n  annotations?: unknown;\n  handler: (args: Record<string, unknown>, extra: unknown) => Promise<CallToolResult>;\n  enabled: boolean;\n  remove: () => void;\n}\n\ninterface ParentRegisteredResource {\n  name: string;\n  metadata?: { description?: string; mimeType?: string; title?: string };\n  readCallback: (uri: URL, extra: unknown) => Promise<{ contents: ResourceContents[] }>;\n  enabled: boolean;\n  remove: () => void;\n}\n\ninterface ParentRegisteredPrompt {\n  title?: string;\n  description?: string;\n  argsSchema?: unknown;\n  callback: (\n    args: Record<string, unknown>,\n    extra: unknown\n  ) => Promise<{ messages: PromptMessage[] }>;\n  enabled: boolean;\n  remove: () => void;\n}\n\nexport interface BrowserMcpServerOptions extends ServerOptions {\n  native?: ModelContextCore;\n}\n\ntype ParentRegisterToolFn = (\n  name: string,\n  config: Record<string, unknown>,\n  cb: (args: Record<string, unknown>, extra: unknown) => Promise<CallToolResult>\n) => void;\n\n/**\n * Browser-optimized MCP Server that speaks WebMCP natively.\n *\n * This server IS navigator.modelContext — it implements the WebMCP standard API\n * (provideContext, registerTool, unregisterTool, clearContext) while retaining\n * full MCP protocol capabilities (resources, prompts, elicitation, sampling)\n * via the inherited BaseMcpServer surface.\n *\n * When `native` is provided, all tool operations are mirrored to it so that\n * navigator.modelContextTesting (polyfill testing shim) stays in sync.\n */\nexport class BrowserMcpServer extends BaseMcpServer {\n  private native: ModelContextCore | undefined;\n\n  constructor(serverInfo: Implementation, options?: BrowserMcpServerOptions) {\n    const enhancedOptions: ServerOptions = {\n      capabilities: mergeCapabilities(options?.capabilities || {}, {\n        tools: { listChanged: true },\n        resources: { listChanged: true },\n        prompts: { listChanged: true },\n      }),\n      jsonSchemaValidator: options?.jsonSchemaValidator ?? new PolyfillJsonSchemaValidator(),\n    };\n\n    super(serverInfo, enhancedOptions);\n    this.native = options?.native;\n  }\n\n  private get _parentTools(): Record<string, ParentRegisteredTool> {\n    return (this as unknown as { _registeredTools: Record<string, ParentRegisteredTool> })\n      ._registeredTools;\n  }\n\n  private get _parentResources(): Record<string, ParentRegisteredResource> {\n    return (this as unknown as { _registeredResources: Record<string, ParentRegisteredResource> })\n      ._registeredResources;\n  }\n\n  private get _parentPrompts(): Record<string, ParentRegisteredPrompt> {\n    return (this as unknown as { _registeredPrompts: Record<string, ParentRegisteredPrompt> })\n      ._registeredPrompts;\n  }\n\n  // --- WebMCP standard API (primary surface) ---\n\n  // @ts-expect-error -- WebMCP API: (ToolDescriptor) vs MCP SDK: (name, config, cb)\n  override registerTool(tool: ToolDescriptor): { unregister: () => void } {\n    // Mirror to native first — the polyfill validates the descriptor\n    if (this.native) {\n      (this.native.registerTool as (tool: ToolDescriptor) => void)(tool);\n    }\n\n    const inputSchema = tool.inputSchema ?? DEFAULT_INPUT_SCHEMA;\n\n    try {\n      // Cast needed: parent expects Zod-compatible schemas, we pass JSON Schema objects\n      (super.registerTool as unknown as ParentRegisterToolFn)(\n        tool.name,\n        {\n          description: tool.description,\n          inputSchema,\n          ...(tool.outputSchema ? { outputSchema: tool.outputSchema } : {}),\n          ...(tool.annotations ? { annotations: tool.annotations } : {}),\n        },\n        async (args: Record<string, unknown>) => {\n          const client: ModelContextClient = {\n            requestUserInteraction: async (cb: () => Promise<unknown>) => cb(),\n          };\n          return tool.execute(args, client);\n        }\n      );\n      return {\n        unregister: () => this.unregisterTool(tool.name),\n      }\n    } catch (error) {\n      // Rollback native registration on server failure\n      if (this.native) {\n        try {\n          this.native.unregisterTool(tool.name);\n        } catch {\n          // best-effort rollback\n        }\n      }\n      throw error;\n    }\n  }\n\n  unregisterTool(name: string): void {\n    this._parentTools[name]?.remove();\n\n    if (this.native) {\n      this.native.unregisterTool(name);\n    }\n  }\n\n  // @ts-expect-error -- WebMCP API: (descriptor) vs MCP SDK: (name, uri, config, readCallback)\n  override registerResource(descriptor: {\n    uri: string;\n    name: string;\n    description?: string;\n    mimeType?: string;\n    read: (uri: URL, params?: Record<string, string>) => Promise<{ contents: ResourceContents[] }>;\n  }): { unregister: () => void } {\n    const registered = (super.registerResource as Function)(\n      descriptor.name,\n      descriptor.uri,\n      {\n        ...(descriptor.description !== undefined && { description: descriptor.description }),\n        ...(descriptor.mimeType !== undefined && { mimeType: descriptor.mimeType }),\n      },\n      async (uri: URL) => ({\n        contents: (await descriptor.read(uri)).contents,\n      })\n    );\n\n    return {\n      unregister: () => registered.remove(),\n    };\n  }\n\n  // @ts-expect-error -- WebMCP API: (descriptor) vs MCP SDK: (name, config, cb)\n  override registerPrompt(descriptor: {\n    name: string;\n    description?: string;\n    argsSchema?: InputSchema;\n    get: (args: Record<string, unknown>) => Promise<{ messages: PromptMessage[] }>;\n  }): { unregister: () => void } {\n    const registered = (super.registerPrompt as Function)(\n      descriptor.name,\n      {\n        ...(descriptor.description !== undefined && { description: descriptor.description }),\n        ...(descriptor.argsSchema !== undefined && { argsSchema: descriptor.argsSchema }),\n      },\n      async (args: Record<string, unknown>) => ({\n        messages: (await descriptor.get(args)).messages,\n      })\n    );\n\n    return {\n      unregister: () => registered.remove(),\n    };\n  }\n\n  provideContext(options?: ModelContextOptions): void {\n    for (const tool of Object.values(this._parentTools)) {\n      tool.remove();\n    }\n\n    if (this.native) {\n      this.native.clearContext();\n    }\n\n    for (const tool of options?.tools ?? []) {\n      this.registerTool(tool);\n    }\n  }\n\n  clearContext(): void {\n    for (const tool of Object.values(this._parentTools)) {\n      tool.remove();\n    }\n\n    if (this.native) {\n      this.native.clearContext();\n    }\n  }\n\n  // --- Extension methods ---\n\n  listResources(): Array<{\n    uri: string;\n    name: string;\n    description?: string;\n    mimeType?: string;\n  }> {\n    return Object.entries(this._parentResources)\n      .filter(([, resource]) => resource.enabled)\n      .map(([uri, resource]) => ({\n        uri,\n        name: resource.name,\n        ...resource.metadata,\n      }));\n  }\n\n  async readResource(uri: string): Promise<{ contents: ResourceContents[] }> {\n    const resource = this._parentResources[uri];\n    if (!resource) {\n      throw new Error(`Resource not found: ${uri}`);\n    }\n\n    return resource.readCallback(new URL(uri), {});\n  }\n\n  listPrompts(): Array<{\n    name: string;\n    description?: string;\n    arguments?: Array<{ name: string; description?: string; required?: boolean }>;\n  }> {\n    return Object.entries(this._parentPrompts)\n      .filter(([, prompt]) => prompt.enabled)\n      .map(([name, prompt]) => ({\n        name,\n        ...(prompt.description !== undefined && { description: prompt.description }),\n        ...(prompt.argsSchema\n          ? {\n            arguments: Object.entries((prompt.argsSchema as Record<string, unknown>) ?? {}).map(\n              ([argName]) => ({ name: argName })\n            ),\n          }\n          : {}),\n      }));\n  }\n\n  async getPrompt(\n    name: string,\n    args: Record<string, unknown> = {}\n  ): Promise<{ messages: PromptMessage[] }> {\n    const prompt = this._parentPrompts[name];\n    if (!prompt) {\n      throw new Error(`Prompt not found: ${name}`);\n    }\n\n    return prompt.callback(args, {});\n  }\n\n  listTools(): ToolListItem[] {\n    return Object.entries(this._parentTools)\n      .filter(([, tool]) => tool.enabled)\n      .map(([name, tool]) => {\n        const item: ToolListItem = {\n          name,\n          description: tool.description ?? '',\n          inputSchema: (tool.inputSchema as InputSchema) ?? DEFAULT_INPUT_SCHEMA,\n        };\n        if (tool.outputSchema) item.outputSchema = tool.outputSchema as InputSchema;\n        if (tool.annotations)\n          item.annotations = tool.annotations as NonNullable<ToolListItem['annotations']>;\n        return item;\n      });\n  }\n\n  async callTool(params: {\n    name: string;\n    arguments?: Record<string, unknown>;\n  }): Promise<ToolResponse> {\n    const tool = this._parentTools[params.name];\n    if (!tool) {\n      throw new Error(`Tool not found: ${params.name}`);\n    }\n\n    return tool.handler(params.arguments ?? {}, {});\n  }\n\n  async executeTool(name: string, args: Record<string, unknown> = {}): Promise<ToolResponse> {\n    return this.callTool({ name, arguments: args });\n  }\n\n  /**\n   * Override connect to initialize request handlers BEFORE the transport connection.\n   * This prevents \"Cannot register capabilities after connecting to transport\" errors\n   * when tools are registered dynamically after connection.\n   */\n  override async connect(transport: Transport): Promise<void> {\n    (this as unknown as { setToolRequestHandlers: () => void }).setToolRequestHandlers();\n    (this as unknown as { setResourceRequestHandlers: () => void }).setResourceRequestHandlers();\n    (this as unknown as { setPromptRequestHandlers: () => void }).setPromptRequestHandlers();\n    return super.connect(transport);\n  }\n\n  // --- Sampling & Elicitation (delegated to Server) ---\n\n  async createMessage(\n    params: CreateMessageRequest['params'],\n    options?: RequestOptions\n  ): Promise<CreateMessageResult> {\n    return this.server.createMessage(params, options);\n  }\n\n  async elicitInput(\n    params: ElicitRequest['params'],\n    options?: RequestOptions\n  ): Promise<ElicitResult> {\n    return this.server.elicitInput(params, options);\n  }\n}\n\n// --- Exported descriptor types for consumers ---\n\nexport interface ResourceDescriptor {\n  uri: string;\n  name: string;\n  description?: string;\n  mimeType?: string;\n  read: (uri: URL, params?: Record<string, string>) => Promise<{ contents: ResourceContents[] }>;\n}\n\nexport interface PromptDescriptor {\n  name: string;\n  description?: string;\n  argsSchema?: InputSchema;\n  get: (args: Record<string, unknown>) => Promise<{ messages: PromptMessage[] }>;\n}\n","/**\n * No-op JSON Schema validator for browser environments.\n *\n * This validator bypasses the MCP SDK's internal ajv-based validation which causes\n * \"Error compiling schema\" errors in browser extensions due to ajv's use of\n * eval/Function constructor.\n *\n * Validation is handled externally by Zod in @mcp-b/global, making the SDK's\n * internal validation redundant. This no-op validator allows the SDK to function\n * without the ajv dependency issues.\n */\n\n/**\n * Interface for JSON Schema validators.\n * This matches the MCP SDK's jsonSchemaValidator interface.\n */\ninterface JsonSchemaValidator {\n  getValidator<T>(schema: unknown): (input: unknown) => JsonSchemaValidatorResult<T>;\n}\n\n/**\n * Result type for JSON Schema validation\n */\ntype JsonSchemaValidatorResult<T> =\n  | { valid: true; data: T; errorMessage: undefined }\n  | { valid: false; data: undefined; errorMessage: string };\n\n/**\n * A no-op JSON Schema validator that always returns valid.\n *\n * Use this in browser environments where:\n * - ajv causes \"Error compiling schema\" errors\n * - Validation is already handled elsewhere (e.g., by Zod)\n * - You need to avoid eval/Function constructor restrictions\n *\n * @example\n * ```typescript\n * import { BrowserMcpServer } from '@mcp-b/webmcp-ts-sdk';\n * import { NoOpJsonSchemaValidator } from '@mcp-b/webmcp-ts-sdk/no-op-validator';\n *\n * const server = new BrowserMcpServer(\n *   { name: 'my-server', version: '1.0.0' },\n *   { jsonSchemaValidator: new NoOpJsonSchemaValidator() }\n * );\n * ```\n */\nexport class NoOpJsonSchemaValidator implements JsonSchemaValidator {\n  /**\n   * Returns a validator function that always passes.\n   * The input data is passed through unchanged.\n   *\n   * @param _schema - The JSON Schema (ignored)\n   * @returns A validator function that always returns valid\n   */\n  getValidator<T>(_schema: unknown): (input: unknown) => JsonSchemaValidatorResult<T> {\n    return (input: unknown): JsonSchemaValidatorResult<T> => ({\n      valid: true,\n      data: input as T,\n      errorMessage: undefined,\n    });\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@mcp-b/webmcp-ts-sdk",
+  "version": "0.0.0-beta-20260216200013",
+  "description": "Browser-adapted MCP TypeScript SDK - Dynamic tool registration for W3C Web Model Context API and AI agent integration",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "browser",
+    "typescript",
+    "sdk",
+    "adapter",
+    "web-model-context",
+    "navigator-modelcontext",
+    "w3c",
+    "ai-agents",
+    "llm",
+    "claude",
+    "chatgpt",
+    "openai",
+    "anthropic",
+    "cursor",
+    "copilot",
+    "gemini",
+    "webmcp",
+    "dynamic-tools",
+    "mcp-server",
+    "mcp-client",
+    "tool-registration",
+    "ai-integration"
+  ],
+  "homepage": "https://docs.mcp-b.ai/packages/webmcp-ts-sdk",
+  "bugs": {
+    "url": "https://github.com/WebMCP-org/npm-packages/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/WebMCP-org/npm-packages.git",
+    "directory": "packages/webmcp-ts-sdk"
+  },
+  "license": "MIT",
+  "author": "Alex Nahas",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.25.2",
+    "@mcp-b/webmcp-polyfill": "0.0.0-beta-20260216200013",
+    "@mcp-b/webmcp-types": "0.0.0-beta-20260216200013"
+  },
+  "devDependencies": {
+    "@types/node": "22.17.2",
+    "tsdown": "^0.15.10",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check": "biome check --write .",
+    "clean": "rm -rf dist .turbo",
+    "format": "biome format --write .",
+    "lint": "biome lint --write .",
+    "publish:dry": "pnpm publish --access public --dry-run",
+    "publish:npm": "pnpm publish --access public",
+    "typecheck": "tsc --noEmit",
+    "version:major": "pnpm version major --no-git-tag-version",
+    "version:minor": "pnpm version minor --no-git-tag-version",
+    "version:patch": "pnpm version patch --no-git-tag-version"
+  }
+}