@mcp-b/react-webmcp 1.1.1 → 1.6.0

package/dist/index.d.ts

@@ -1,22 +1,49 @@
-import { ElicitationFormParams, ElicitationParams, ElicitationParams as ElicitationParams$1, ElicitationResult, ElicitationResult as ElicitationResult$1, ElicitationUrlParams, ModelContext as ModelContextProtocol, PromptDescriptor, ResourceDescriptor, SamplingRequestParams, SamplingRequestParams as SamplingRequestParams$1, SamplingResult, SamplingResult as SamplingResult$1, ToolDescriptor } from "@mcp-b/global";
 import { DependencyList, ReactElement, ReactNode } from "react";
+import { BrowserMcpServer as ModelContextProtocol, Client, PromptDescriptor, PromptMessage, RequestOptions, Resource, ResourceContents, ResourceDescriptor, SamplingRequestParams, SamplingResult, ServerCapabilities, Tool, Transport } from "@mcp-b/webmcp-ts-sdk";
+import { ToolInputSchema, ToolInputSchema as ToolInputSchema$1 } from "@mcp-b/webmcp-polyfill";
+import { CallToolResult, ElicitationParams, ElicitationResult, InferArgsFromInputSchema, InferJsonSchema, InputSchema, JsonSchemaObject, ToolAnnotations, ToolDescriptor } from "@mcp-b/webmcp-types";
 import { z } from "zod";
-import { CallToolResult, Client, PromptMessage, RequestOptions, Resource, Resource as Resource$1, ResourceContents, ServerCapabilities, ServerCapabilities as ServerCapabilities$1, Tool, Tool as Tool$1, ToolAnnotations, Transport } from "@mcp-b/webmcp-ts-sdk";
 
+//#region src/zod-utils.d.ts
+type ZodSchemaObject = Record<string, z.ZodTypeAny>;
+//#endregion
 //#region src/types.d.ts
-
 /**
- * Utility type to infer the output type from a Zod schema object.
+ * Union of all input schema types supported by react-webmcp:
+ * - `ToolInputSchema` (JSON Schema + Standard Schema v1)
+ * - `ZodSchemaObject` (Zod v3 `Record<string, z.ZodTypeAny>`)
+ */
+type ReactWebMCPInputSchema = ToolInputSchema$1 | ZodSchemaObject;
+/**
+ * Infers handler input type from a Standard Schema, Zod v3 schema, or JSON Schema.
+ *
+ * - **Standard Schema** (Zod v4, Valibot, ArkType): extracts `~standard.types.input`
+ * - **Zod v3** (`Record<string, z.ZodTypeAny>`): uses `z.infer<z.ZodObject<T>>`
+ * - **JSON Schema** (`as const`): uses `InferArgsFromInputSchema` for structural inference
+ * - **Fallback**: `Record<string, unknown>`
  *
- * When `TOutputSchema` is a non-empty Zod schema object, this resolves to
- * `z.infer<z.ZodObject<TOutputSchema>>`. When it's empty (`Record<string, never>`),
+ * @template T - The input schema type
+ * @internal
+ */
+type InferToolInput<T> = T extends {
+  readonly '~standard': {
+    readonly types?: infer Types;
+  };
+} ? Types extends {
+  readonly input: infer I;
+} ? I : Record<string, unknown> : T extends Record<string, z.ZodTypeAny> ? z.infer<z.ZodObject<T>> : T extends InputSchema ? InferArgsFromInputSchema<T> : Record<string, unknown>;
+/**
+ * Utility type to infer the output type from a JSON Schema object.
+ *
+ * When `TOutputSchema` is a literal `JsonSchemaObject`, this resolves to
+ * `InferJsonSchema<TOutputSchema>`. When it's `undefined`,
  * it falls back to the provided `TFallback` type.
  *
- * @template TOutputSchema - Zod schema object for output validation
+ * @template TOutputSchema - JSON Schema object for output inference
  * @template TFallback - Fallback type when no schema is provided
  * @internal
  */
-type InferOutput<TOutputSchema extends Record<string, z.ZodTypeAny>, TFallback = unknown> = TOutputSchema extends Record<string, never> ? TFallback : z.infer<z.ZodObject<TOutputSchema>>;
+type InferOutput<TOutputSchema extends JsonSchemaObject | undefined = undefined, TFallback = unknown> = TOutputSchema extends JsonSchemaObject ? InferJsonSchema<TOutputSchema> : TFallback;
 /**
  * Represents the current execution state of a tool, including loading status,
  * results, errors, and execution history.
@@ -42,7 +69,7 @@ interface ToolExecutionState<TOutput = unknown> {
   error: Error | null;
   /**
    * Total number of times this tool has been executed.
-   * Increments on both successful and failed executions.
+   * Increments on successful executions only.
    */
   executionCount: number;
 }
@@ -50,10 +77,10 @@ interface ToolExecutionState<TOutput = unknown> {
  * Configuration options for the `useWebMCP` hook.
  *
  * Defines a tool's metadata, schema, handler, and lifecycle callbacks.
- * Supports full Zod type inference for both input and output schemas.
+ * Uses JSON Schema for type inference via `as const`.
  *
- * @template TInputSchema - Zod schema object defining input parameters
- * @template TOutputSchema - Zod schema object defining output structure (enables structuredContent)
+ * @template TInputSchema - JSON Schema defining input parameters
+ * @template TOutputSchema - JSON Schema object defining output structure (enables structuredContent)
  *
  * @public
  *
@@ -63,8 +90,10 @@ interface ToolExecutionState<TOutput = unknown> {
  *   name: 'posts_like',
  *   description: 'Like a post by its ID',
  *   inputSchema: {
- *     postId: z.string().uuid(),
- *   },
+ *     type: 'object',
+ *     properties: { postId: { type: 'string' } },
+ *     required: ['postId'],
+ *   } as const,
  *   handler: async ({ postId }) => {
  *     await api.likePost(postId);
  *     return { success: true };
@@ -74,28 +103,29 @@ interface ToolExecutionState<TOutput = unknown> {
  *
  * @example Tool with output schema (enables MCP structuredContent):
  * ```typescript
- * const config: WebMCPConfig<
- *   { postId: z.ZodString },
- *   { likes: z.ZodNumber; likedAt: z.ZodString }
- * > = {
+ * useWebMCP({
  *   name: 'posts_like',
  *   description: 'Like a post and return updated like count',
  *   inputSchema: {
- *     postId: z.string().uuid(),
- *   },
+ *     type: 'object',
+ *     properties: { postId: { type: 'string' } },
+ *     required: ['postId'],
+ *   } as const,
  *   outputSchema: {
- *     likes: z.number().describe('Updated like count'),
- *     likedAt: z.string().describe('ISO timestamp of the like'),
- *   },
- *   // Handler return type is inferred from outputSchema
+ *     type: 'object',
+ *     properties: {
+ *       likes: { type: 'number', description: 'Updated like count' },
+ *       likedAt: { type: 'string', description: 'ISO timestamp of the like' },
+ *     },
+ *   } as const,
  *   handler: async ({ postId }) => {
  *     const result = await api.likePost(postId);
  *     return { likes: result.likes, likedAt: new Date().toISOString() };
  *   },
- * };
+ * });
  * ```
  */
-interface WebMCPConfig<TInputSchema extends Record<string, z.ZodTypeAny> = Record<string, never>, TOutputSchema extends Record<string, z.ZodTypeAny> = Record<string, never>> {
+interface WebMCPConfig<TInputSchema extends ReactWebMCPInputSchema = InputSchema, TOutputSchema extends JsonSchemaObject | undefined = undefined> {
   /**
    * Unique identifier for the tool (e.g., 'posts_like', 'graph_navigate').
    * Must follow naming conventions: lowercase with underscores.
@@ -107,20 +137,24 @@ interface WebMCPConfig<TInputSchema extends Record<string, z.ZodTypeAny> = Recor
    */
   description: string;
   /**
-   * Zod schema object defining the input parameters for the tool.
-   * Each key is a parameter name, and the value is a Zod type definition.
+   * JSON Schema defining the input parameters for the tool.
+   * Use `as const` to enable type inference for the handler's input.
    *
    * @example
    * ```typescript
    * inputSchema: {
-   *   postId: z.string().uuid().describe('The ID of the post to like'),
-   *   userId: z.string().optional(),
-   * }
+   *   type: 'object',
+   *   properties: {
+   *     postId: { type: 'string', description: 'The ID of the post to like' },
+   *     userId: { type: 'string' },
+   *   },
+   *   required: ['postId'],
+   * } as const
    * ```
    */
   inputSchema?: TInputSchema;
   /**
-   * **Recommended:** Zod schema object defining the expected output structure.
+   * **Recommended:** JSON Schema object defining the expected output structure.
    *
    * When provided, this enables three key features:
    * 1. **Type Safety**: The handler's return type is inferred from this schema
@@ -128,20 +162,17 @@ interface WebMCPConfig<TInputSchema extends Record<string, z.ZodTypeAny> = Recor
    *    containing the typed output per the MCP specification
    * 3. **AI Understanding**: AI models can better understand and use the tool's output
    *
-   * This is the recommended way to define tool outputs. The schema provides
-   * both compile-time type checking and runtime structure for MCP clients.
-   *
    * @see {@link https://spec.modelcontextprotocol.io/specification/server/tools/#output-schemas}
    *
    * @example
    * ```typescript
    * outputSchema: {
-   *   counter: z.number().describe('The current counter value'),
-   *   timestamp: z.string().describe('ISO timestamp'),
-   *   metadata: z.object({
-   *     updatedBy: z.string(),
-   *   }).describe('Additional metadata'),
-   * }
+   *   type: 'object',
+   *   properties: {
+   *     counter: { type: 'number', description: 'The current counter value' },
+   *     timestamp: { type: 'string', description: 'ISO timestamp' },
+   *   },
+   * } as const
    * ```
    */
   outputSchema?: TOutputSchema;
@@ -160,7 +191,7 @@ interface WebMCPConfig<TInputSchema extends Record<string, z.ZodTypeAny> = Recor
    * @param input - Validated input parameters matching the inputSchema
    * @returns The result data or a Promise resolving to the result
    */
-  handler: (input: z.infer<z.ZodObject<TInputSchema>>) => Promise<InferOutput<TOutputSchema>> | InferOutput<TOutputSchema>;
+  handler: (input: InferToolInput<TInputSchema>) => Promise<InferOutput<TOutputSchema>> | InferOutput<TOutputSchema>;
   /**
    * Custom formatter for the MCP text response.
    *
@@ -193,10 +224,10 @@ interface WebMCPConfig<TInputSchema extends Record<string, z.ZodTypeAny> = Recor
  * Return value from the `useWebMCP` hook.
  * Provides access to execution state and methods for manual tool control.
  *
- * @template TOutputSchema - Zod schema object defining output structure
+ * @template TOutputSchema - JSON Schema object defining output structure
  * @public
  */
-interface WebMCPReturn<TOutputSchema extends Record<string, z.ZodTypeAny> = Record<string, never>> {
+interface WebMCPReturn<TOutputSchema extends JsonSchemaObject | undefined = undefined> {
   /**
    * Current execution state including loading status, results, and errors.
    * See {@link ToolExecutionState} for details.
@@ -221,7 +252,7 @@ interface WebMCPReturn<TOutputSchema extends Record<string, z.ZodTypeAny> = Reco
  * Configuration options for the `useWebMCPPrompt` hook.
  * Defines a prompt's metadata, argument schema, and message generator.
  *
- * @template TArgsSchema - Zod schema object defining prompt arguments
+ * @template TArgsSchema - JSON Schema defining prompt arguments
  * @public
  *
  * @example
@@ -230,9 +261,13 @@ interface WebMCPReturn<TOutputSchema extends Record<string, z.ZodTypeAny> = Reco
  *   name: 'review_code',
  *   description: 'Review code for best practices',
  *   argsSchema: {
- *     code: z.string().describe('The code to review'),
- *     language: z.string().optional().describe('Programming language'),
- *   },
+ *     type: 'object',
+ *     properties: {
+ *       code: { type: 'string', description: 'The code to review' },
+ *       language: { type: 'string', description: 'Programming language' },
+ *     },
+ *     required: ['code'],
+ *   } as const,
  *   get: async ({ code, language }) => ({
  *     messages: [{
  *       role: 'user',
@@ -242,7 +277,7 @@ interface WebMCPReturn<TOutputSchema extends Record<string, z.ZodTypeAny> = Reco
  * };
  * ```
  */
-interface WebMCPPromptConfig<TArgsSchema extends Record<string, z.ZodTypeAny> = Record<string, never>> {
+interface WebMCPPromptConfig<TArgsSchema extends ReactWebMCPInputSchema = InputSchema> {
   /**
    * Unique identifier for the prompt (e.g., 'review_code', 'summarize_text').
    */
@@ -253,8 +288,8 @@ interface WebMCPPromptConfig<TArgsSchema extends Record<string, z.ZodTypeAny> =
    */
   description?: string;
   /**
-   * Optional Zod schema object defining the arguments for the prompt.
-   * Each key is an argument name, and the value is a Zod type definition.
+   * Optional JSON Schema defining the arguments for the prompt.
+   * Use `as const` to enable type inference for the `get` function's arguments.
    */
   argsSchema?: TArgsSchema;
   /**
@@ -264,7 +299,7 @@ interface WebMCPPromptConfig<TArgsSchema extends Record<string, z.ZodTypeAny> =
    * @param args - Validated arguments matching the argsSchema
    * @returns Object containing the prompt messages
    */
-  get: (args: z.infer<z.ZodObject<TArgsSchema>>) => Promise<{
+  get: (args: InferToolInput<TArgsSchema>) => Promise<{
     messages: PromptMessage[];
   }> | {
     messages: PromptMessage[];
@@ -366,7 +401,6 @@ interface WebMCPResourceReturn {
  * This hook handles the complete lifecycle of an MCP tool:
  * - Registers the tool with `window.navigator.modelContext`
  * - Manages execution state (loading, results, errors)
- * - Validates input using Zod schemas
  * - Handles tool execution and lifecycle callbacks
  * - Automatically unregisters on component unmount
  * - Returns `structuredContent` when `outputSchema` is defined
@@ -382,12 +416,19 @@ interface WebMCPResourceReturn {
  * useWebMCP({
  *   name: 'get_user',
  *   description: 'Get user by ID',
- *   inputSchema: { userId: z.string() },
+ *   inputSchema: {
+ *     type: 'object',
+ *     properties: { userId: { type: 'string' } },
+ *     required: ['userId'],
+ *   } as const,
  *   outputSchema: {
- *     id: z.string(),
- *     name: z.string(),
- *     email: z.string().email(),
- *   },
+ *     type: 'object',
+ *     properties: {
+ *       id: { type: 'string' },
+ *       name: { type: 'string' },
+ *       email: { type: 'string' },
+ *     },
+ *   } as const,
  *   handler: async ({ userId }) => {
  *     const user = await fetchUser(userId);
  *     return { id: user.id, name: user.name, email: user.email };
@@ -395,185 +436,17 @@ interface WebMCPResourceReturn {
  * });
  * ```
  *
- * ## Re-render Optimization
- *
- * This hook is optimized to minimize unnecessary tool re-registrations:
- *
- * - **Memoized JSON conversion**: Zod-to-JSON schema conversions are memoized to
- *   avoid recomputation on every render.
- *
- * - **Ref-based callbacks**: `handler`, `onSuccess`, `onError`, and `formatOutput`
- *   are stored in refs, so changing these functions won't trigger re-registration.
- *
- * **IMPORTANT**: If `inputSchema`, `outputSchema`, or `annotations` are defined inline
- * or change on every render, the tool will re-register unnecessarily. To avoid this,
- * memoize these values using `useMemo` or define them outside your component:
- *
- * ```tsx
- * // Good: Memoized schema (won't change unless deps change)
- * const outputSchema = useMemo(() => ({
- *   count: z.number(),
- *   items: z.array(z.string()),
- * }), []);
- *
- * // Good: Static schema defined outside component
- * const OUTPUT_SCHEMA = {
- *   count: z.number(),
- *   items: z.array(z.string()),
- * };
- *
- * // Bad: Inline schema (creates new object every render)
- * useWebMCP({
- *   outputSchema: { count: z.number() }, // Re-registers every render!
- * });
- * ```
- *
- * **What triggers re-registration:**
- * - Changes to `name` or `description`
- * - Changes to `inputSchema`, `outputSchema`, or `annotations` (reference comparison)
- * - Changes to any value in the `deps` argument (reference comparison)
- *
- * **What does NOT trigger re-registration:**
- * - Changes to `handler`, `onSuccess`, `onError`, or `formatOutput` functions
- *
- * @template TInputSchema - Zod schema object defining input parameter types
- * @template TOutputSchema - Zod schema object defining output structure (enables structuredContent)
+ * @template TInputSchema - JSON Schema defining input parameter types (use `as const` for inference)
+ * @template TOutputSchema - JSON Schema object defining output structure (enables structuredContent)
  *
  * @param config - Configuration object for the tool
  * @param deps - Optional dependency array that triggers tool re-registration when values change.
- *   Similar to React's `useEffect` dependencies. When any value changes (by reference),
- *   the tool will be unregistered and re-registered. Prefer primitive values over
- *   objects/arrays to minimize re-registrations.
  *
  * @returns Object containing execution state and control methods
  *
- * @remarks
- * The hook uses React refs to store callbacks (`handler`, `onSuccess`, `onError`, `formatOutput`)
- * which prevents re-registration when these functions change. This is a performance optimization
- * that follows the "latest ref" pattern.
- *
- * When `outputSchema` is provided, the MCP response includes both text content and
- * `structuredContent` per the MCP specification. The type system ensures that the handler's
- * return type matches the output schema through Zod's type inference.
- *
  * @public
- *
- * @example
- * Basic tool with outputSchema (recommended):
- * ```tsx
- * function PostActions() {
- *   const likeTool = useWebMCP({
- *     name: 'posts_like',
- *     description: 'Like a post by ID',
- *     inputSchema: {
- *       postId: z.string().uuid().describe('The ID of the post to like'),
- *     },
- *     outputSchema: {
- *       success: z.boolean().describe('Whether the like was successful'),
- *       likeCount: z.number().describe('Updated like count'),
- *     },
- *     handler: async ({ postId }) => {
- *       const result = await api.posts.like(postId);
- *       return { success: true, likeCount: result.likes };
- *     },
- *   });
- *
- *   // likeTool.state.lastResult is typed as { success: boolean; likeCount: number } | null
- *   if (likeTool.state.isExecuting) {
- *     return <Spinner />;
- *   }
- *
- *   return <div>Likes: {likeTool.state.lastResult?.likeCount ?? 0}</div>;
- * }
- * ```
- *
- * @example
- * Tool with annotations and callbacks:
- * ```tsx
- * const deleteTool = useWebMCP({
- *   name: 'posts_delete',
- *   description: 'Delete a post permanently',
- *   inputSchema: {
- *     postId: z.string().uuid(),
- *   },
- *   outputSchema: {
- *     deleted: z.boolean(),
- *     deletedAt: z.string().describe('ISO timestamp of deletion'),
- *   },
- *   annotations: {
- *     destructiveHint: true,
- *     idempotentHint: false,
- *   },
- *   handler: async ({ postId }) => {
- *     await api.posts.delete(postId);
- *     return { deleted: true, deletedAt: new Date().toISOString() };
- *   },
- *   onSuccess: () => {
- *     navigate('/posts');
- *     toast.success('Post deleted');
- *   },
- *   onError: (error) => {
- *     toast.error(`Failed to delete: ${error.message}`);
- *   },
- * });
- * ```
- *
- * @example
- * Tool with deps for automatic re-registration:
- * ```tsx
- * function SitesManager({ sites }: { sites: Site[] }) {
- *   // Without deps, you'd need getter functions like: getSiteCount: () => sites.length
- *   // With deps, values can be used directly in description and handler
- *   const sitesTool = useWebMCP(
- *     {
- *       name: 'sites_query',
- *       description: `Query available sites. Current count: ${sites.length}`,
- *       outputSchema: {
- *         count: z.number(),
- *         sites: z.array(z.object({ id: z.string(), name: z.string() })),
- *       },
- *       handler: async () => ({
- *         count: sites.length,
- *         sites: sites.map(s => ({ id: s.id, name: s.name })),
- *       }),
- *     },
- *     [sites] // Re-register tool when sites array changes (by reference)
- *   );
- *
- *   return <SitesList sites={sites} />;
- * }
- * ```
- *
- * @example
- * Optimizing with memoization and deps:
- * ```tsx
- * function OptimizedSites({ sites }: { sites: Site[] }) {
- *   // Memoize schema to prevent re-registration on every render
- *   const outputSchema = useMemo(() => ({
- *     sites: z.array(z.object({ id: z.string(), name: z.string() })),
- *   }), []);
- *
- *   // Use primitive values in deps for better control
- *   const siteIds = sites.map(s => s.id).join(',');
- *   const siteCount = sites.length;
- *
- *   const sitesTool = useWebMCP(
- *     {
- *       name: 'sites_query',
- *       description: `Query ${siteCount} available sites`,
- *       outputSchema,
- *       handler: async () => ({
- *         sites: sites.map(s => ({ id: s.id, name: s.name })),
- *       }),
- *     },
- *     [siteIds, siteCount] // Only re-register when IDs or count actually change
- *   );
- *
- *   return <SitesList sites={sites} />;
- * }
- * ```
  */
-declare function useWebMCP<TInputSchema extends Record<string, z.ZodTypeAny> = Record<string, never>, TOutputSchema extends Record<string, z.ZodTypeAny> = Record<string, never>>(config: WebMCPConfig<TInputSchema, TOutputSchema>, deps?: DependencyList): WebMCPReturn<TOutputSchema>;
+declare function useWebMCP<TInputSchema extends ReactWebMCPInputSchema = InputSchema, TOutputSchema extends JsonSchemaObject | undefined = undefined>(config: WebMCPConfig<TInputSchema, TOutputSchema>, deps?: DependencyList): WebMCPReturn<TOutputSchema>;
 //#endregion
 //#region src/useWebMCPContext.d.ts
 /**
@@ -686,9 +559,13 @@ declare function useWebMCPContext<T>(name: string, description: string, getValue
  *     name: 'review_code',
  *     description: 'Review code for best practices',
  *     argsSchema: {
- *       code: z.string().describe('The code to review'),
- *       language: z.string().optional().describe('Programming language'),
- *     },
+ *       type: 'object',
+ *       properties: {
+ *         code: { type: 'string', description: 'The code to review' },
+ *         language: { type: 'string', description: 'Programming language' },
+ *       },
+ *       required: ['code'],
+ *     } as const,
  *     get: async ({ code, language }) => ({
  *       messages: [{
  *         role: 'user',
@@ -704,7 +581,7 @@ declare function useWebMCPContext<T>(name: string, description: string, getValue
  * }
  * ```
  */
-declare function useWebMCPPrompt<TArgsSchema extends Record<string, z.ZodTypeAny> = Record<string, never>>(config: WebMCPPromptConfig<TArgsSchema>): WebMCPPromptReturn;
+declare function useWebMCPPrompt<TArgsSchema extends ReactWebMCPInputSchema = InputSchema>(config: WebMCPPromptConfig<TArgsSchema>): WebMCPPromptReturn;
 //#endregion
 //#region src/useWebMCPResource.d.ts
 /**
@@ -776,7 +653,7 @@ interface ElicitationState {
   /** Whether an elicitation request is currently in progress */
   isLoading: boolean;
   /** The last elicitation result received */
-  result: ElicitationResult$1 | null;
+  result: ElicitationResult | null;
   /** Any error that occurred during the last request */
   error: Error | null;
   /** Total number of requests made */
@@ -789,7 +666,7 @@ interface UseElicitationConfig {
   /**
    * Optional callback invoked when an elicitation request completes successfully.
    */
-  onSuccess?: (result: ElicitationResult$1) => void;
+  onSuccess?: (result: ElicitationResult) => void;
   /**
    * Optional callback invoked when an elicitation request fails.
    */
@@ -802,7 +679,7 @@ interface UseElicitationReturn {
   /** Current state of elicitation */
   state: ElicitationState;
   /** Function to request user input from the connected client */
-  elicitInput: (params: ElicitationParams$1) => Promise<ElicitationResult$1>;
+  elicitInput: (params: ElicitationParams) => Promise<ElicitationResult>;
   /** Reset the state */
   reset: () => void;
 }
@@ -882,7 +759,7 @@ interface SamplingState {
   /** Whether a sampling request is currently in progress */
   isLoading: boolean;
   /** The last sampling result received */
-  result: SamplingResult$1 | null;
+  result: SamplingResult | null;
   /** Any error that occurred during the last request */
   error: Error | null;
   /** Total number of requests made */
@@ -895,7 +772,7 @@ interface UseSamplingConfig {
   /**
    * Optional callback invoked when a sampling request completes successfully.
    */
-  onSuccess?: (result: SamplingResult$1) => void;
+  onSuccess?: (result: SamplingResult) => void;
   /**
    * Optional callback invoked when a sampling request fails.
    */
@@ -908,7 +785,7 @@ interface UseSamplingReturn {
   /** Current state of sampling */
   state: SamplingState;
   /** Function to request LLM completion from the connected client */
-  createMessage: (params: SamplingRequestParams$1) => Promise<SamplingResult$1>;
+  createMessage: (params: SamplingRequestParams) => Promise<SamplingResult>;
   /** Reset the state */
   reset: () => void;
 }
@@ -961,12 +838,12 @@ declare function useSampling(config?: UseSamplingConfig): UseSamplingReturn;
  */
 interface McpClientContextValue {
   client: Client;
-  tools: Tool$1[];
-  resources: Resource$1[];
+  tools: Tool[];
+  resources: Resource[];
   isConnected: boolean;
   isLoading: boolean;
   error: Error | null;
-  capabilities: ServerCapabilities$1 | null;
+  capabilities: ServerCapabilities | null;
   reconnect: () => Promise<void>;
 }
 /**
@@ -1105,5 +982,5 @@ declare function McpClientProvider({
  */
 declare function useMcpClient(): McpClientContextValue;
 //#endregion
-export { type CallToolResult, type ElicitationFormParams, type ElicitationState as ElicitationHandlerState, type ElicitationState, type ElicitationParams, type ElicitationResult, type ElicitationUrlParams, type InferOutput, McpClientProvider, type McpClientProviderProps, type ModelContextProtocol, type PromptDescriptor, type PromptMessage, type Resource, type ResourceContents, type ResourceDescriptor, type SamplingState as SamplingHandlerState, type SamplingState, type SamplingRequestParams, type SamplingResult, type ServerCapabilities, type Tool, type ToolAnnotations, type ToolDescriptor, type ToolExecutionState, type UseElicitationConfig, type UseElicitationConfig as UseElicitationHandlerConfig, type UseElicitationReturn as UseElicitationHandlerReturn, type UseElicitationReturn, type UseSamplingConfig, type UseSamplingConfig as UseSamplingHandlerConfig, type UseSamplingReturn as UseSamplingHandlerReturn, type UseSamplingReturn, type WebMCPConfig, type WebMCPPromptConfig, type WebMCPPromptReturn, type WebMCPResourceConfig, type WebMCPResourceReturn, type WebMCPReturn, useElicitation, useElicitation as useElicitationHandler, useMcpClient, useSampling, useSampling as useSamplingHandler, useWebMCP, useWebMCPContext, useWebMCPPrompt, useWebMCPResource };
+export { type CallToolResult, type ElicitationState as ElicitationHandlerState, type ElicitationState, type InferOutput, type InferToolInput, McpClientProvider, type McpClientProviderProps, type ModelContextProtocol, type PromptDescriptor, type PromptMessage, type ReactWebMCPInputSchema, type ResourceContents, type ResourceDescriptor, type SamplingState as SamplingHandlerState, type SamplingState, type ToolAnnotations, type ToolDescriptor, type ToolExecutionState, type ToolInputSchema, type UseElicitationConfig, type UseElicitationConfig as UseElicitationHandlerConfig, type UseElicitationReturn as UseElicitationHandlerReturn, type UseElicitationReturn, type UseSamplingConfig, type UseSamplingConfig as UseSamplingHandlerConfig, type UseSamplingReturn as UseSamplingHandlerReturn, type UseSamplingReturn, type WebMCPConfig, type WebMCPPromptConfig, type WebMCPPromptReturn, type WebMCPResourceConfig, type WebMCPResourceReturn, type WebMCPReturn, type ZodSchemaObject, useElicitation, useElicitation as useElicitationHandler, useMcpClient, useSampling, useSampling as useSamplingHandler, useWebMCP, useWebMCPContext, useWebMCPPrompt, useWebMCPResource };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/useWebMCP.ts","../src/useWebMCPContext.ts","../src/useWebMCPPrompt.ts","../src/useWebMCPResource.ts","../src/useElicitationHandler.ts","../src/useSamplingHandler.ts","../src/client/McpClientProvider.tsx"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/zod-utils.ts","../src/types.ts","../src/useWebMCP.ts","../src/useWebMCPContext.ts","../src/useWebMCPPrompt.ts","../src/useWebMCPResource.ts","../src/useElicitationHandler.ts","../src/useSamplingHandler.ts","../src/client/McpClientProvider.tsx"],"sourcesContent":[],"mappings":";;;;;;;KAIY,eAAA,GAAkB,eAAe,CAAA,CAAE;;;;;ACwB/C;AAaA;;AAGM,KAhBM,sBAAA,GAAyB,iBAgB/B,GAhBiD,eAgBjD;;;;;;;;;;;;AAQI,KAXE,cAWF,CAAA,CAAA,CAAA,GATR,CASQ,SAAA;EACA,SAAA,WAAA,EAAA;IAAM,SAAA,KAAA,CAAA,EAAA,KAAA,MAAA;EAaJ,CAAA;CACY,GAvBlB,KAuBkB,SAAA;EAEpB,SAAA,KAAA,EAAA,KAAA,EAAA;CAAsB,GAxBlB,CAwBkB,GAvBlB,MAuBkB,CAAA,MAAA,EAAA,OAAA,CAAA,GArBpB,CAqBoB,SArBV,MAqBU,CAAA,MAAA,EArBK,CAAA,CAAE,UAqBP,CAAA,GApBlB,CAAA,CAAE,KAoBgB,CApBV,CAAA,CAAE,SAoBQ,CApBE,CAoBF,CAAA,CAAA,GAlBlB,CAkBkB,SAlBR,WAkBQ,GAjBhB,wBAiBgB,CAjBS,CAiBT,CAAA,GAhBhB,MAgBgB,CAAA,MAAA,EAAA,OAAA,CAAA;;;;;AAS1B;AA8EA;;;;;;AA8DgB,KAxJJ,WAwJI,CAAA,sBAvJQ,gBAuJR,GAAA,SAAA,GAAA,SAAA,EAAA,YAAA,OAAA,CAAA,GArJZ,aAqJY,SArJU,gBAqJV,GArJ6B,eAqJ7B,CArJ6C,aAqJ7C,CAAA,GArJ8D,SAqJ9D;;;;;;;;AA0BsB,UAtKrB,kBAsKqB,CAAA,UAAA,OAAA,CAAA,CAAA;EAAZ;;;;EAkBD,WAAA,EAAA,OAAA;EAUR;;;;EAKR,UAAA,EA5LK,OA4LL,GAAA,IAAA;EAU0C;;;;EAkDlC,KAAA,EAlPR,KAkPQ,GAAA,IAAA;EAAuC;;;;EA0B9C,cAAA,EAAA,MAAA;;;;;AAUV;AA6CA;;;;;;AAuCA;;;;AChWA;;;;;;;;;;;;;;ACpCA;;;;ACcA;;;;;;;;;;ACXA;;;;AC9DA;AAcA;AAeA;;;;AAI8C,ULiH7B,YKjH6B,CAAA,qBLkHvB,sBKlHuB,GLkHE,WKlHF,EAAA,sBLmHtB,gBKnHsB,GAAA,SAAA,GAAA,SAAA,CAAA,CAAA;EAAO;AAuErD;;;;ECxGiB;AAcjB;AAeA;;EAI0B,WAAA,EAAA,MAAA;EAAkC;;;AA4C5D;;;;ACpEe;;;;;;;;AAqDf;EAIY,WAAA,CAAA,EPgHI,YOhHJ;EAKF;;;;AAiFV;;;;;;;;AAsPA;;;;;;;;;;iBPpMiB;;;;;gBAMD;;;;;;;;;;;mBAaL,eAAe,kBACnB,QAAQ,YAAY,kBAAkB,YAAY;;;;;;;;;;;0BAY/B,YAAY;;;;;;;;uBASf,YAAY;;;;;;;;oBASf;;;;;;;;;UAUH,mCAAmC;;;;;SAK3C,mBAAmB,YAAY;;;;;;;;;+BAUT,QAAQ,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAkDlC,uCAAuC,yBAAyB;;;;;;;;;;;;;;eAgBlE;;;;;;;;cAUL,eAAe,iBAClB;cAAoB;;cAAiC;;;;;;;;;UAS3C,kBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA6CA,oBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BH,cAAc,2BAA2B;cAAoB;;;;;;;;;UAS1D,oBAAA;;;;;;;;;;;;ADrcjB;;;;ACwBA;AAaA;;;;;;;;;;;;;;;;;AAyBA;;;;;;;;AAYA;AA8EA;;;;;;;;;;;;;;;;AAiGmC,iBCpJnB,SDoJmB,CAAA,qBCnJZ,sBDmJY,GCnJa,WDmJb,EAAA,sBClJX,gBDkJW,GAAA,SAAA,GAAA,SAAA,CAAA,CAAA,MAAA,EChJzB,YDgJyB,CChJZ,YDgJY,EChJE,aDgJF,CAAA,EAAA,IAAA,CAAA,EC/I1B,cD+I0B,CAAA,EC9IhC,YD8IgC,CC9InB,aD8ImB,CAAA;;;;;;;;;ADzPnC;;;;ACwBA;AAaA;;;;;;;;;;;;;;;;;AAyBA;;;;;;;;AAYA;AA8EA;;;;;;;;;;;;;;;;;;;;AAoHA;;;;;;;;AAesC,iBE1NtB,gBF0NsB,CAAA,CAAA,CAAA,CAAA,IAAA,EAAA,MAAA,EAAA,WAAA,EAAA,MAAA,EAAA,QAAA,EAAA,GAAA,GEvNpB,CFuNoB,CAAA,EEtNnC,YFsNmC;;;;;;;;AD3RtC;;;;ACwBA;AAaA;;;;;;;;;;;;;;;;;AAyBA;;;;;;;;AAYA;AA8EA;;;;;;;;;;;;;;;;;;;;AAoHA;;;;;;;;AAesC,iBG5MtB,eH4MsB,CAAA,oBG5Mc,sBH4Md,GG5MuC,WH4MvC,CAAA,CAAA,MAAA,EG3M5B,kBH2M4B,CG3MT,WH2MS,CAAA,CAAA,EG1MnC,kBH0MmC;;;;;;;;;AD3RtC;;;;ACwBA;AAaA;;;;;;;;;;;;;;;;;AAyBA;;;;;;;;AAYA;AA8EA;;;;;;;;;;;;;;;;;;;;AAoHA;;AAKwC,iBI7MxB,iBAAA,CJ6MwB,MAAA,EI7ME,oBJ6MF,CAAA,EI7MyB,oBJ6MzB;;;;;;UK3QvB,gBAAA;;;ENNL;UMUF;;SAED;ELYG;EAaA,YAAA,EAAA,MAAc;;;;;AAOpB,UKxBW,oBAAA,CLwBX;EAA2B;;;EACf,SAAA,CAAA,EAAA,CAAA,MAAA,EKrBK,iBLqBL,EAAA,GAAA,IAAA;EAAR;;;EAGyB,OAAA,CAAA,EAAA,CAAA,KAAA,EKnBf,KLmBe,EAAA,GAAA,IAAA;;;;AAcnC;AACwB,UK5BP,oBAAA,CL4BO;EAEpB;EAAsB,KAAA,EK5BjB,gBL4BiB;EAAmC;EAAhB,WAAA,EAAA,CAAA,MAAA,EK1BrB,iBL0BqB,EAAA,GK1BC,OL0BD,CK1BS,iBL0BT,CAAA;EAAiC;EAAS,KAAA,EAAA,GAAA,GAAA,IAAA;AASvF;AA8EA;;;;;;;;;;;;;;;;;;;;AAoHA;;;;;;;;;AAiEA;;;;;;;;;;AAoCA;AA6CA;;;;;;AAuCA;;;;AChWA;;;;;;;;;;;;;;ACpCA;;iBG6CgB,cAAA,UAAuB,uBAA4B;;;;;;UCxGlD,aAAA;;;EPNL;UOUF;;SAED;ENYG;EAaA,YAAA,EAAA,MAAc;;;;;AAOpB,UMxBW,iBAAA,CNwBX;EAA2B;;;EACf,SAAA,CAAA,EAAA,CAAA,MAAA,EMrBK,cNqBL,EAAA,GAAA,IAAA;EAAR;;;EAGyB,OAAA,CAAA,EAAA,CAAA,KAAA,EMnBf,KNmBe,EAAA,GAAA,IAAA;;;;AAcnC;AACwB,UM5BP,iBAAA,CN4BO;EAEpB;EAAsB,KAAA,EM5BjB,aN4BiB;EAAmC;EAAhB,aAAA,EAAA,CAAA,MAAA,EM1BnB,qBN0BmB,EAAA,GM1BO,ON0BP,CM1Be,cN0Bf,CAAA;EAAiC;EAAS,KAAA,EAAA,GAAA,GAAA,IAAA;AASvF;AA8EA;;;;;;;;;;;;;;;;;;;;AAoHA;;;;;;;;;AAiEA;;;;;;;;;;AAoCiB,iBM9RD,WAAA,CN8RmB,MAAA,CAAA,EM9RC,iBN8RD,CAAA,EM9R0B,iBN8R1B;;;;;;;;ADjXnC,UQsBU,qBAAA,CRtBiB;UQuBjB;SACD;aACI;EPDD,WAAA,EAAA,OAAA;EAaA,SAAA,EAAA,OAAc;EAExB,KAAA,EOXO,KPWP,GAAA,IAAA;EACI,YAAA,EOXU,kBPWV,GAAA,IAAA;EACE,SAAA,EAAA,GAAA,GOXW,OPWX,CAAA,IAAA,CAAA;;;;;;;AAIE,UOuBO,sBAAA,CPvBP;EAEF;;;EACE,QAAA,EOwBE,SPxBF;EACA;;AAaV;EACwB,MAAA,EOcd,MPdc;EAEpB;;;EAAyC,SAAA,EOiBhC,SPjBgC;EAAiC;;AAS9E;EA8EiB,IAAA,CAAA,EOjER,cPiEoB;;;;;;;;;;;;;;;;;;;;AAoH7B;;;;;;;;;AAiEA;;;;;;;;;;AAoCA;AA6CA;;;;;;AAuCA;;;;AChWA;;;;;;;;;;;;;;ACpCA;;;;ACcA;;AAA6E,iBI+E7D,iBAAA,CJ/E6D;EAAA,QAAA;EAAA,MAAA;EAAA,SAAA;EAAA;AAAA,CAAA,EIoF1E,sBJpF0E,CAAA,EIoFjD,YJpFiD;;;;;;;;ACX7E;;;;AC9DA;AAcA;AAeA;;;;;;AA2EA;;;;ACxGA;AAcA;AAeA;;;;;;AAgDA;;;;ACpEe;;AASN,iBA4XO,YAAA,CAAA,CA5XP,EA4XmB,qBA5XnB"}