@mcp-b/global 1.1.2 → 1.1.3-beta.2

package/dist/index.d.ts

@@ -1,55 +1,124 @@
 import { IframeChildTransportOptions, TabServerTransportOptions } from "@mcp-b/transports";
-import { CallToolResult, Server, ToolAnnotations, Transport } from "@mcp-b/webmcp-ts-sdk";
+import { CallToolResult, CreateMessageRequest, CreateMessageResult, ElicitRequest, ElicitResult, Prompt, PromptMessage, Resource, ResourceContents, ResourceTemplate, Server, ToolAnnotations, Transport } from "@mcp-b/webmcp-ts-sdk";
 import { z } from "zod";
 
 //#region src/types.d.ts
 
 /**
- * JSON Schema definition for tool input parameters
+ * JSON Schema definition for tool/prompt input parameters.
+ *
+ * This interface represents a JSON Schema object as defined by the JSON Schema
+ * specification. It's used for defining tool input schemas and prompt argument
+ * schemas when not using Zod.
+ *
+ * @see {@link https://json-schema.org/}
+ *
+ * @example
+ * ```typescript
+ * const schema: InputSchema = {
+ *   type: 'object',
+ *   properties: {
+ *     query: { type: 'string', description: 'Search query' },
+ *     limit: { type: 'number', description: 'Max results' }
+ *   },
+ *   required: ['query']
+ * };
+ * ```
  */
 interface InputSchema {
+  /** The JSON Schema type (typically "object" for tool inputs) */
   type: string;
+  /** Property definitions for object schemas */
   properties?: Record<string, {
+    /** The property type */
     type: string;
+    /** Human-readable description of the property */
     description?: string;
+    /** Additional JSON Schema keywords */
     [key: string]: unknown;
   }>;
+  /** Array of required property names */
   required?: string[];
+  /** Additional JSON Schema keywords */
   [key: string]: unknown;
 }
 /**
- * Zod schema object type (Record<string, ZodType>)
- * Used for type-safe tool definitions
+ * Zod schema object type for type-safe tool and prompt definitions.
+ *
+ * When using Zod schemas instead of JSON Schema, define your schema as an object
+ * where keys are parameter names and values are Zod type definitions.
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const mySchema: ZodSchemaObject = {
+ *   query: z.string().describe('Search query'),
+ *   limit: z.number().optional().describe('Max results')
+ * };
+ * ```
  */
 type ZodSchemaObject = Record<string, z.ZodTypeAny>;
 /**
- * Tool response format (Web API version)
- * This is compatible with MCP SDK's CallToolResult
+ * Tool response format for the Web Model Context API.
+ * This is an alias for MCP SDK's CallToolResult for API consistency.
+ * @see {@link CallToolResult}
  */
 type ToolResponse = CallToolResult;
 /**
  * Transport configuration for initializing the Web Model Context polyfill.
+ *
+ * The polyfill supports multiple transport modes:
+ * - **Custom transport**: Provide your own MCP transport implementation
+ * - **Tab server**: Same-window communication via postMessage
+ * - **Iframe server**: Parent-child iframe communication
+ *
+ * @example Custom transport
+ * ```typescript
+ * const config: TransportConfiguration = {
+ *   create: () => new MyCustomTransport()
+ * };
+ * ```
+ *
+ * @example Configure allowed origins
+ * ```typescript
+ * const config: TransportConfiguration = {
+ *   tabServer: { allowedOrigins: ['https://example.com'] },
+ *   iframeServer: false // disable iframe server
+ * };
+ * ```
  */
 interface TransportConfiguration {
   /**
-   * Provide a custom transport factory. When set, tabServer and iframeServer options are ignored.
+   * Provide a custom transport factory.
+   * When set, tabServer and iframeServer options are ignored.
    */
   create?: () => Transport;
   /**
    * Options passed to the built-in TabServerTransport when no custom factory is provided.
-   * Set to false to disable the tab server.
-   * Default: enabled with allowedOrigins: ['*']
+   * Set to `false` to disable the tab server.
+   * @default { allowedOrigins: ['*'] }
    */
   tabServer?: Partial<TabServerTransportOptions> | false;
   /**
    * Options passed to the built-in IframeChildTransport when no custom factory is provided.
-   * Set to false to disable the iframe server.
-   * Default: auto-enabled when running in an iframe (window.parent !== window)
+   * Set to `false` to disable the iframe server.
+   * @default Auto-enabled when `window.parent !== window`
    */
   iframeServer?: Partial<IframeChildTransportOptions> | false;
 }
 /**
  * Initialization options for the Web Model Context polyfill.
+ *
+ * @example
+ * ```typescript
+ * initializeWebModelContext({
+ *   autoInitialize: true,
+ *   transport: {
+ *     tabServer: { allowedOrigins: ['https://trusted.com'] }
+ *   }
+ * });
+ * ```
  */
 interface WebModelContextInitOptions {
   /**
@@ -57,18 +126,51 @@ interface WebModelContextInitOptions {
    */
   transport?: TransportConfiguration;
   /**
-   * When set to false, automatic initialization on module load is skipped.
+   * When set to `false`, automatic initialization on module load is skipped.
+   * Useful when you need to configure options before initialization.
+   * @default true
    */
   autoInitialize?: boolean;
 }
 /**
- * Tool descriptor for Web Model Context API
- * Extended with full MCP protocol support
+ * Tool descriptor for the Web Model Context API.
  *
- * Supports both JSON Schema (Web standard) and Zod schemas (type-safe)
+ * Tools are functions that AI models can call to perform actions or retrieve
+ * information. This interface supports both JSON Schema (Web standard) and
+ * Zod schemas (type-safe) for input/output validation.
+ *
+ * @template TInputSchema - Zod schema object type for input type inference
+ * @template TOutputSchema - Zod schema object type for output type inference
+ *
+ * @see {@link https://spec.modelcontextprotocol.io/specification/server/tools/}
+ *
+ * @example JSON Schema
+ * ```typescript
+ * const tool: ToolDescriptor = {
+ *   name: 'search',
+ *   description: 'Search the web',
+ *   inputSchema: {
+ *     type: 'object',
+ *     properties: { query: { type: 'string' } },
+ *     required: ['query']
+ *   },
+ *   execute: async ({ query }) => ({
+ *     content: [{ type: 'text', text: `Results for: ${query}` }]
+ *   })
+ * };
+ * ```
  *
- * @template TInputSchema - If using Zod, the schema object type for type inference
- * @template TOutputSchema - If using Zod, the output schema object type
+ * @example Zod Schema (type-safe)
+ * ```typescript
+ * const tool: ToolDescriptor<{ query: z.ZodString }> = {
+ *   name: 'search',
+ *   description: 'Search the web',
+ *   inputSchema: { query: z.string() },
+ *   execute: async ({ query }) => ({ // query is typed as string
+ *     content: [{ type: 'text', text: `Results for: ${query}` }]
+ *   })
+ * };
+ * ```
  */
 interface ToolDescriptor<TInputSchema extends ZodSchemaObject = Record<string, never>, TOutputSchema extends ZodSchemaObject = Record<string, never>> {
   /**
@@ -106,9 +208,10 @@ interface ToolDescriptor<TInputSchema extends ZodSchemaObject = Record<string, n
   execute: (args: TInputSchema extends Record<string, never> ? Record<string, unknown> : z.infer<z.ZodObject<TInputSchema>>) => Promise<ToolResponse>;
 }
 /**
- * Internal validated tool descriptor (used internally by the bridge)
- * Always stores JSON Schema format for MCP protocol
- * Plus Zod validators for runtime validation
+ * Internal validated tool descriptor (used internally by the bridge).
+ * Always stores JSON Schema format for MCP protocol compatibility,
+ * plus Zod validators for runtime validation.
+ * @internal
  */
 interface ValidatedToolDescriptor {
   name: string;
@@ -117,19 +220,349 @@ interface ValidatedToolDescriptor {
   outputSchema?: InputSchema;
   annotations?: ToolAnnotations;
   execute: (args: Record<string, unknown>) => Promise<ToolResponse>;
+  /** Zod validator for input arguments (not exposed via MCP) */
   inputValidator: z.ZodType;
+  /** Zod validator for output (not exposed via MCP) */
   outputValidator?: z.ZodType;
 }
 /**
- * Context provided to models via provideContext()
- * Contains the base set of tools (Bucket A)
+ * Resource descriptor for Web Model Context API
+ * Defines a resource that can be read by AI models
+ *
+ * Resources can be:
+ * - Static: Fixed URI like "config://app-settings"
+ * - Dynamic: URI template like "file://{path}" where {path} is a parameter
+ *
+ * @example Static resource
+ * ```typescript
+ * const configResource: ResourceDescriptor = {
+ *   uri: 'config://app-settings',
+ *   name: 'App Settings',
+ *   description: 'Application configuration',
+ *   mimeType: 'application/json',
+ *   read: async (uri) => ({
+ *     contents: [{ uri: uri.href, text: JSON.stringify(config) }]
+ *   })
+ * };
+ * ```
+ *
+ * @example Dynamic resource with URI template
+ * ```typescript
+ * const fileResource: ResourceDescriptor = {
+ *   uri: 'file://{path}',
+ *   name: 'File Reader',
+ *   description: 'Read files from the virtual filesystem',
+ *   read: async (uri, params) => ({
+ *     contents: [{ uri: uri.href, text: await readFile(params?.path ?? '') }]
+ *   })
+ * };
+ * ```
+ */
+interface ResourceDescriptor {
+  /**
+   * The resource URI or URI template
+   * - Static: "config://app-settings"
+   * - Template: "file://{path}" where {path} becomes a parameter
+   */
+  uri: string;
+  /**
+   * Human-readable name for the resource
+   */
+  name: string;
+  /**
+   * Optional description of what the resource provides
+   */
+  description?: string;
+  /**
+   * Optional MIME type of the resource content
+   */
+  mimeType?: string;
+  /**
+   * Function that reads and returns the resource content
+   *
+   * @param uri - The resolved URI being requested
+   * @param params - Parameters extracted from URI template (if applicable)
+   * @returns Resource contents with the data
+   */
+  read: (uri: URL, params?: Record<string, string>) => Promise<{
+    contents: ResourceContents[];
+  }>;
+}
+/**
+ * Internal validated resource descriptor (used internally by the bridge).
+ * @internal
+ */
+interface ValidatedResourceDescriptor {
+  uri: string;
+  name: string;
+  description: string | undefined;
+  mimeType: string | undefined;
+  read: (uri: URL, params?: Record<string, string>) => Promise<{
+    contents: ResourceContents[];
+  }>;
+  /** Whether this is a URI template (contains {param} placeholders) */
+  isTemplate: boolean;
+  /** Parameter names extracted from URI template (e.g., ['path'] for 'file://{path}') */
+  templateParams: string[];
+}
+/**
+ * Prompt descriptor for Web Model Context API
+ * Defines a reusable prompt template for AI interactions
+ *
+ * Prompts help users interact with AI models by providing
+ * pre-defined message templates. They can accept arguments
+ * to customize the prompt dynamically.
+ *
+ * @template TArgsSchema - If using Zod, the schema object type for argument inference
+ *
+ * @example Simple prompt without arguments
+ * ```typescript
+ * const helpPrompt: PromptDescriptor = {
+ *   name: 'help',
+ *   description: 'Get help with using the application',
+ *   get: async () => ({
+ *     messages: [{
+ *       role: 'user',
+ *       content: { type: 'text', text: 'How do I use this application?' }
+ *     }]
+ *   })
+ * };
+ * ```
+ *
+ * @example Prompt with typed arguments
+ * ```typescript
+ * const reviewPrompt: PromptDescriptor<{ code: z.ZodString }> = {
+ *   name: 'review-code',
+ *   description: 'Review code for best practices',
+ *   argsSchema: { code: z.string() },
+ *   get: async ({ code }) => ({
+ *     messages: [{
+ *       role: 'user',
+ *       content: { type: 'text', text: `Please review this code:\n\n${code}` }
+ *     }]
+ *   })
+ * };
+ * ```
+ */
+interface PromptDescriptor<TArgsSchema extends ZodSchemaObject = Record<string, never>> {
+  /**
+   * Unique identifier for the prompt
+   */
+  name: string;
+  /**
+   * Optional description of what the prompt does
+   */
+  description?: string;
+  /**
+   * Optional schema for prompt arguments
+   * Accepts EITHER:
+   * - JSON Schema object: { type: "object", properties: {...} }
+   * - Zod schema object: { code: z.string(), language: z.enum([...]) }
+   */
+  argsSchema?: InputSchema | TArgsSchema;
+  /**
+   * Function that generates prompt messages
+   *
+   * @param args - Arguments matching the argsSchema (if defined)
+   * @returns Object containing the prompt messages
+   */
+  get: (args: TArgsSchema extends Record<string, never> ? Record<string, unknown> : z.infer<z.ZodObject<TArgsSchema>>) => Promise<{
+    messages: PromptMessage[];
+  }>;
+}
+/**
+ * Internal validated prompt descriptor (used internally by the bridge).
+ * @internal
+ */
+interface ValidatedPromptDescriptor {
+  name: string;
+  description: string | undefined;
+  argsSchema: InputSchema | undefined;
+  get: (args: Record<string, unknown>) => Promise<{
+    messages: PromptMessage[];
+  }>;
+  /** Zod validator for arguments (not exposed via MCP) */
+  argsValidator: z.ZodType | undefined;
+}
+/**
+ * Tool information returned by listTools().
+ * Provides metadata about a registered tool without exposing the execute function.
+ */
+interface ToolListItem {
+  /** Unique identifier for the tool */
+  name: string;
+  /** Natural language description of what the tool does */
+  description: string;
+  /** JSON Schema for tool input parameters */
+  inputSchema: InputSchema;
+  /** Optional JSON Schema for tool output */
+  outputSchema?: InputSchema;
+  /** Optional annotations providing hints about tool behavior */
+  annotations?: ToolAnnotations;
+}
+/**
+ * Resource template information returned by listResourceTemplates().
+ * Describes a dynamic resource with URI template parameters.
+ */
+interface ResourceTemplateInfo {
+  /** The URI template (e.g., 'file://{path}') */
+  uriTemplate: string;
+  /** Human-readable name for the resource */
+  name: string;
+  /** Optional description of what the resource provides */
+  description?: string;
+  /** Optional MIME type of the resource content */
+  mimeType?: string;
+}
+/**
+ * Registration handle returned by registerTool, registerResource, registerPrompt.
+ * Provides a method to unregister the item.
+ */
+interface RegistrationHandle {
+  /** Unregister the item, removing it from the context */
+  unregister: () => void;
+}
+/**
+ * Parameters for a sampling request from the server.
+ * Extracted from CreateMessageRequest for handler convenience.
+ */
+interface SamplingRequestParams {
+  /** Messages to send to the LLM */
+  messages: Array<{
+    role: 'user' | 'assistant';
+    content: {
+      type: 'text';
+      text: string;
+    } | {
+      type: 'image';
+      data: string;
+      mimeType: string;
+    } | Array<{
+      type: 'text';
+      text: string;
+    } | {
+      type: 'image';
+      data: string;
+      mimeType: string;
+    }>;
+  }>;
+  /** Optional system prompt */
+  systemPrompt?: string | undefined;
+  /** Maximum tokens to generate */
+  maxTokens: number;
+  /** Optional temperature for sampling */
+  temperature?: number | undefined;
+  /** Optional stop sequences */
+  stopSequences?: string[] | undefined;
+  /** Optional model preferences */
+  modelPreferences?: {
+    hints?: Array<{
+      name?: string;
+    }>;
+    costPriority?: number;
+    speedPriority?: number;
+    intelligencePriority?: number;
+  } | undefined;
+  /** Optional context inclusion setting */
+  includeContext?: 'none' | 'thisServer' | 'allServers' | undefined;
+  /** Optional metadata */
+  metadata?: Record<string, unknown> | undefined;
+}
+/**
+ * Result of a sampling request.
+ * Returned by the sampling handler.
+ */
+interface SamplingResult {
+  /** The model that generated the response */
+  model: string;
+  /** The generated content */
+  content: {
+    type: 'text';
+    text: string;
+  } | {
+    type: 'image';
+    data: string;
+    mimeType: string;
+  };
+  /** Role of the responder */
+  role: 'user' | 'assistant';
+  /** Reason for stopping generation */
+  stopReason?: 'endTurn' | 'stopSequence' | 'maxTokens' | string;
+}
+/**
+ * Parameters for a form elicitation request.
+ */
+interface ElicitationFormParams {
+  /** Mode of elicitation */
+  mode?: 'form';
+  /** Message to show to the user */
+  message: string;
+  /** Schema for the form fields */
+  requestedSchema: {
+    type: 'object';
+    properties: Record<string, {
+      type: 'string' | 'number' | 'integer' | 'boolean';
+      title?: string;
+      description?: string;
+      default?: string | number | boolean;
+      minLength?: number;
+      maxLength?: number;
+      minimum?: number;
+      maximum?: number;
+      enum?: Array<string | number>;
+      enumNames?: string[];
+      format?: string;
+    }>;
+    required?: string[];
+  };
+}
+/**
+ * Parameters for a URL elicitation request.
+ */
+interface ElicitationUrlParams {
+  /** Mode of elicitation */
+  mode: 'url';
+  /** Message explaining why the URL needs to be opened */
+  message: string;
+  /** Unique identifier for this elicitation */
+  elicitationId: string;
+  /** URL to open */
+  url: string;
+}
+/**
+ * Parameters for an elicitation request.
+ * Can be either form-based or URL-based.
+ */
+type ElicitationParams = ElicitationFormParams | ElicitationUrlParams;
+/**
+ * Result of an elicitation request.
+ */
+interface ElicitationResult {
+  /** User action */
+  action: 'accept' | 'decline' | 'cancel';
+  /** Content returned when action is 'accept' */
+  content?: Record<string, string | number | boolean | string[]>;
+}
+/**
+ * Context provided to models via provideContext().
+ * Contains the base set of tools, resources, and prompts (Bucket A).
  */
 interface ModelContextInput {
   /**
    * Array of tool descriptors
    * Supports both JSON Schema and Zod schema formats
    */
-  tools: ToolDescriptor[];
+  tools?: ToolDescriptor[];
+  /**
+   * Array of resource descriptors
+   * Resources expose data that AI models can read
+   */
+  resources?: ResourceDescriptor[];
+  /**
+   * Array of prompt descriptors
+   * Prompts provide reusable message templates
+   */
+  prompts?: PromptDescriptor[];
 }
 /**
  * Tool call event
@@ -154,29 +587,110 @@ interface ToolCallEvent extends Event {
  */
 interface ModelContext {
   /**
-   * Provide context (tools) to AI models
-   * Clears base tools (Bucket A) and replaces with the provided array.
-   * Dynamic tools (Bucket B) registered via registerTool() persist.
+   * Provide context (tools, resources, prompts) to AI models
+   * Clears base items (Bucket A) and replaces with the provided arrays.
+   * Dynamic items (Bucket B) registered via register* methods persist.
    */
   provideContext(context: ModelContextInput): void;
   /**
-   * Register a single tool dynamically
-   * Returns an object with an unregister function to remove the tool
-   * Supports both JSON Schema and Zod schema formats
+   * Register a single tool dynamically.
+   * Returns a handle to unregister the tool.
+   * Supports both JSON Schema and Zod schema formats.
    */
-  registerTool<TInputSchema extends ZodSchemaObject = Record<string, never>, TOutputSchema extends ZodSchemaObject = Record<string, never>>(tool: ToolDescriptor<TInputSchema, TOutputSchema>): {
-    unregister: () => void;
-  };
+  registerTool<TInputSchema extends ZodSchemaObject = Record<string, never>, TOutputSchema extends ZodSchemaObject = Record<string, never>>(tool: ToolDescriptor<TInputSchema, TOutputSchema>): RegistrationHandle;
   /**
    * Unregister a tool by name
    * Available in Chromium's native implementation
    */
   unregisterTool(name: string): void;
   /**
-   * Clear all registered tools (both buckets)
+   * Get the list of all registered tools.
+   * Returns tools from both buckets (provideContext and registerTool).
+   */
+  listTools(): ToolListItem[];
+  /**
+   * Register a single resource dynamically.
+   * Returns a handle to unregister the resource.
+   */
+  registerResource(resource: ResourceDescriptor): RegistrationHandle;
+  /**
+   * Unregister a resource by URI
+   */
+  unregisterResource(uri: string): void;
+  /**
+   * Get the list of all registered resources
+   * Returns resources from both buckets (provideContext and registerResource)
+   */
+  listResources(): Resource[];
+  /**
+   * Get the list of all resource templates.
+   * Returns only resources with URI templates (dynamic resources).
+   */
+  listResourceTemplates(): ResourceTemplateInfo[];
+  /**
+   * Register a single prompt dynamically.
+   * Returns a handle to unregister the prompt.
+   * Supports both JSON Schema and Zod schema formats for argsSchema.
+   */
+  registerPrompt<TArgsSchema extends ZodSchemaObject = Record<string, never>>(prompt: PromptDescriptor<TArgsSchema>): RegistrationHandle;
+  /**
+   * Unregister a prompt by name
+   */
+  unregisterPrompt(name: string): void;
+  /**
+   * Get the list of all registered prompts
+   * Returns prompts from both buckets (provideContext and registerPrompt)
+   */
+  listPrompts(): Prompt[];
+  /**
+   * Clear all registered context (tools, resources, prompts from both buckets)
    * Available in Chromium's native implementation
    */
   clearContext(): void;
+  /**
+   * Request an LLM completion from the connected client.
+   * This allows the server (webpage) to request sampling from the client (AI agent).
+   *
+   * @param params - Parameters for the sampling request
+   * @returns Promise resolving to the LLM completion result
+   *
+   * @example
+   * ```typescript
+   * const result = await navigator.modelContext.createMessage({
+   *   messages: [
+   *     { role: 'user', content: { type: 'text', text: 'What is 2+2?' } }
+   *   ],
+   *   maxTokens: 100,
+   * });
+   * console.log(result.content); // { type: 'text', text: '4' }
+   * ```
+   */
+  createMessage(params: SamplingRequestParams): Promise<SamplingResult>;
+  /**
+   * Request user input from the connected client.
+   * This allows the server (webpage) to request form data or URL navigation from the client.
+   *
+   * @param params - Parameters for the elicitation request
+   * @returns Promise resolving to the user's response
+   *
+   * @example Form elicitation:
+   * ```typescript
+   * const result = await navigator.modelContext.elicitInput({
+   *   message: 'Please provide your API key',
+   *   requestedSchema: {
+   *     type: 'object',
+   *     properties: {
+   *       apiKey: { type: 'string', title: 'API Key', description: 'Your API key' }
+   *     },
+   *     required: ['apiKey']
+   *   }
+   * });
+   * if (result.action === 'accept') {
+   *   console.log(result.content?.apiKey);
+   * }
+   * ```
+   */
+  elicitInput(params: ElicitationParams): Promise<ElicitationResult>;
   /**
    * Add event listener for tool calls
    */
@@ -189,21 +703,11 @@ interface ModelContext {
    * Dispatch an event
    */
   dispatchEvent(event: Event): boolean;
-  /**
-   * Get the list of all registered tools
-   * Returns tools from both buckets (provideContext and registerTool)
-   */
-  listTools(): Array<{
-    name: string;
-    description: string;
-    inputSchema: InputSchema;
-    outputSchema?: InputSchema;
-    annotations?: ToolAnnotations;
-  }>;
 }
 /**
- * Internal ModelContext interface with additional methods for MCP bridge
- * Not exposed as part of the public Web Model Context API
+ * Internal ModelContext interface with additional methods for MCP bridge.
+ * Not exposed as part of the public Web Model Context API.
+ * @internal
  */
 interface InternalModelContext extends ModelContext {
   /**
@@ -211,21 +715,47 @@ interface InternalModelContext extends ModelContext {
    * @internal
    */
   executeTool(toolName: string, args: Record<string, unknown>): Promise<ToolResponse>;
+  /**
+   * Read a resource by URI (internal use only by MCP bridge)
+   * @internal
+   */
+  readResource(uri: string): Promise<{
+    contents: ResourceContents[];
+  }>;
+  /**
+   * Get a prompt with arguments (internal use only by MCP bridge)
+   * @internal
+   */
+  getPrompt(name: string, args?: Record<string, unknown>): Promise<{
+    messages: PromptMessage[];
+  }>;
 }
 /**
- * Internal MCP Bridge state
+ * Internal MCP Bridge state.
+ * Contains the MCP servers and registered context items.
+ * @internal
  */
 interface MCPBridge {
+  /** The main tab server transport */
   tabServer: Server;
+  /** Optional iframe server transport */
   iframeServer?: Server;
+  /** Map of tool name -> validated tool descriptor */
   tools: Map<string, ValidatedToolDescriptor>;
+  /** Map of resource URI -> validated resource descriptor */
+  resources: Map<string, ValidatedResourceDescriptor>;
+  /** Map of prompt name -> validated prompt descriptor */
+  prompts: Map<string, ValidatedPromptDescriptor>;
+  /** The internal model context instance */
   modelContext: InternalModelContext;
+  /** Optional testing API instance */
   modelContextTesting?: ModelContextTesting;
+  /** Whether the bridge has been initialized */
   isInitialized: boolean;
 }
 /**
- * Tool info returned by listTools() in testing API
- * Note: inputSchema is a JSON string, not an object (matches Chromium implementation)
+ * Tool info returned by listTools() in the testing API.
+ * Note: inputSchema is a JSON string, not an object (matches Chromium implementation).
  */
 interface ToolInfo {
   name: string;
@@ -377,5 +907,15 @@ declare function initializeWebModelContext(options?: WebModelContextInitOptions)
  */
 declare function cleanupWebModelContext(): void;
 //#endregion
-export { type CallToolResult, InputSchema, InternalModelContext, MCPBridge, ModelContext, ModelContextInput, ModelContextTesting, type ToolAnnotations, ToolCallEvent, ToolDescriptor, ToolInfo, ToolResponse, TransportConfiguration, ValidatedToolDescriptor, WebModelContextInitOptions, ZodSchemaObject, cleanupWebModelContext, initializeWebModelContext };
+//#region src/validation.d.ts
+/**
+ * Convert Zod schema object to JSON Schema
+ * Uses zod-to-json-schema package for comprehensive conversion
+ *
+ * @param schema - Record of Zod type definitions (e.g., { name: z.string(), age: z.number() })
+ * @returns JSON Schema object compatible with MCP InputSchema
+ */
+declare function zodToJsonSchema(schema: Record<string, z.ZodTypeAny>): InputSchema;
+//#endregion
+export { type CallToolResult, type CreateMessageRequest, type CreateMessageResult, type ElicitRequest, type ElicitResult, ElicitationFormParams, ElicitationParams, ElicitationResult, ElicitationUrlParams, InputSchema, InternalModelContext, MCPBridge, ModelContext, ModelContextInput, ModelContextTesting, type Prompt, PromptDescriptor, type PromptMessage, RegistrationHandle, type Resource, type ResourceContents, ResourceDescriptor, type ResourceTemplate, ResourceTemplateInfo, SamplingRequestParams, SamplingResult, type ToolAnnotations, ToolCallEvent, ToolDescriptor, ToolInfo, ToolListItem, ToolResponse, TransportConfiguration, ValidatedPromptDescriptor, ValidatedResourceDescriptor, ValidatedToolDescriptor, WebModelContextInitOptions, ZodSchemaObject, cleanupWebModelContext, initializeWebModelContext, zodToJsonSchema };
 //# sourceMappingURL=index.d.ts.map