@mcp-b/react-webmcp 2.1.0 → 2.3.0

package/README.md

@@ -14,13 +14,13 @@
 
 ## Why Use @mcp-b/react-webmcp?
 
-| Feature | Benefit |
-|---------|---------|
-| **React-First Design** | Hooks follow React patterns with automatic cleanup and StrictMode support |
-| **Type-Safe with Zod** | Full TypeScript support with Zod schema validation for inputs/outputs |
-| **Two-Way Integration** | Both expose tools TO AI agents AND consume tools FROM MCP servers |
-| **Execution State Tracking** | Built-in loading, success, and error states for UI feedback |
-| **Works with Any AI** | Compatible with Claude, ChatGPT, Gemini, Cursor, Copilot, and any MCP client |
+| Feature                      | Benefit                                                                      |
+| ---------------------------- | ---------------------------------------------------------------------------- |
+| **React-First Design**       | Hooks follow React patterns with automatic cleanup and StrictMode support    |
+| **Type-Safe with Zod**       | Full TypeScript support with Zod schema validation for inputs/outputs        |
+| **Two-Way Integration**      | Both expose tools TO AI agents AND consume tools FROM MCP servers            |
+| **Execution State Tracking** | Built-in loading, success, and error states for UI feedback                  |
+| **Works with Any AI**        | Compatible with Claude, ChatGPT, Gemini, Cursor, Copilot, and any MCP client |
 
 ## Installation
 
@@ -31,12 +31,15 @@ pnpm add @mcp-b/react-webmcp zod
 If you only want strict core WebMCP hooks (without MCP-B extension APIs like prompts/resources/sampling/elicitation), use `usewebmcp` instead.
 
 For client functionality, you'll also need:
+
 ```bash
 pnpm add @mcp-b/transports @modelcontextprotocol/sdk
 ```
 
 **Prerequisites:** Provider hooks require the `navigator.modelContext` API. Install `@mcp-b/global` or use a browser that implements the Web Model Context API.
 
+Provider hooks register tools with `navigator.modelContext.registerTool(tool, { signal })` and abort the controller on unmount. On Chrome Beta 147 native (which ignores the second arg) cleanup cannot remove the tool. Install `@mcp-b/global` for spec-aligned behavior.
+
 ## Quick Start - Provider (Registering Tools)
 
 ```tsx
@@ -101,7 +104,9 @@ function ToolConsumer() {
     <div>
       <p>Connected: {isConnected ? 'Yes' : 'No'}</p>
       <p>Available Tools: {tools.length}</p>
-      <button onClick={handleCallTool} disabled={!isConnected}>Call Tool</button>
+      <button onClick={handleCallTool} disabled={!isConnected}>
+        Call Tool
+      </button>
     </div>
   );
 }
@@ -111,17 +116,17 @@ function ToolConsumer() {
 
 ### Provider Hooks
 
-| Hook | Description |
-|------|-------------|
-| `useWebMCP(config, deps?)` | Register a tool with full control over behavior and state |
-| `useWebMCPContext(name, description, getValue)` | Simplified hook for read-only context exposure |
+| Hook                                            | Description                                               |
+| ----------------------------------------------- | --------------------------------------------------------- |
+| `useWebMCP(config, deps?)`                      | Register a tool with full control over behavior and state |
+| `useWebMCPContext(name, description, getValue)` | Simplified hook for read-only context exposure            |
 
 ### Client Hooks
 
-| Hook / Component | Description |
-|-------------------|-------------|
-| `McpClientProvider` | Provider component managing an MCP client connection |
-| `useMcpClient()` | Access client, tools, connection status, and capabilities |
+| Hook / Component    | Description                                               |
+| ------------------- | --------------------------------------------------------- |
+| `McpClientProvider` | Provider component managing an MCP client connection      |
+| `useMcpClient()`    | Access client, tools, connection status, and capabilities |
 
 ## Zod Version Compatibility
 

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 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 { CallToolResult, ElicitationParams, ElicitationResult, InferArgsFromInputSchema, InferJsonSchema, InputSchema, JsonSchemaForInference, ToolAnnotations, ToolDescriptor } from "@mcp-b/webmcp-types";
 import { z } from "zod";
 
 //#region src/zod-utils.d.ts
@@ -16,10 +16,19 @@ type ZodSchemaObject = Record<string, z.ZodTypeAny>;
 type ReactWebMCPInputSchema = ToolInputSchema$1 | ZodSchemaObject;
 /**
  * Union of all output schema types supported by react-webmcp:
- * - `JsonSchemaObject` (MCP output schema)
+ * - `JsonSchemaForInference` (MCP output schema)
  * - `ZodSchemaObject` (Zod v3 `Record<string, z.ZodTypeAny>`, converted at runtime)
  */
-type ReactWebMCPOutputSchema = JsonSchemaObject | ZodSchemaObject;
+type ReactWebMCPOutputSchema = JsonSchemaForInference | ZodSchemaObject;
+interface ReactWebMCPStandardOutputSchema<TInput = unknown, TOutput = unknown> {
+  readonly '~standard': {
+    readonly types?: {
+      readonly input: TInput;
+      readonly output: TOutput;
+    };
+  };
+}
+type ReactWebMCPSupportedOutputSchema = ReactWebMCPOutputSchema | ReactWebMCPStandardOutputSchema;
 /**
  * Infers handler input type from a Standard Schema, Zod v3 schema, or JSON Schema.
  *
@@ -31,17 +40,17 @@ type ReactWebMCPOutputSchema = JsonSchemaObject | ZodSchemaObject;
  * @template T - The input schema type
  * @internal
  */
-type InferToolInput<T> = T extends {
+type InferToolInput<T> = T extends Record<string, z.ZodTypeAny> ? z.infer<z.ZodObject<T>> : T extends {
   readonly '~standard': {
     readonly types?: infer Types;
   };
-} ? Types extends {
+} ? NonNullable<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>;
+} ? I : Record<string, unknown> : T extends InputSchema ? InferArgsFromInputSchema<T> : Record<string, unknown>;
 /**
  * Utility type to infer the output type from an output schema.
  *
- * - `JsonSchemaObject` resolves via `InferJsonSchema`
+ * - inferable JSON Schema resolves via `InferJsonSchema`
  * - `ZodSchemaObject` resolves via `z.infer<z.ZodObject<...>>`
  * - `undefined` falls back to `TFallback`
  *
@@ -49,7 +58,13 @@ type InferToolInput<T> = T extends {
  * @template TFallback - Fallback type when no schema is provided
  * @internal
  */
-type InferOutput<TOutputSchema extends ReactWebMCPOutputSchema | undefined = undefined, TFallback = unknown> = TOutputSchema extends undefined ? TFallback : TOutputSchema extends Record<string, z.ZodTypeAny> ? z.infer<z.ZodObject<TOutputSchema>> : TOutputSchema extends JsonSchemaObject ? InferJsonSchema<TOutputSchema> : TFallback;
+type InferOutput<TOutputSchema extends ReactWebMCPSupportedOutputSchema | undefined = undefined, TFallback = unknown> = TOutputSchema extends undefined ? TFallback : TOutputSchema extends {
+  readonly '~standard': {
+    readonly types?: infer Types;
+  };
+} ? NonNullable<Types> extends {
+  readonly output: infer O;
+} ? O : TFallback : TOutputSchema extends Record<string, z.ZodTypeAny> ? z.infer<z.ZodObject<TOutputSchema>> : TOutputSchema extends JsonSchemaForInference ? InferJsonSchema<TOutputSchema> : TFallback;
 /**
  * Represents the current execution state of a tool, including loading status,
  * results, errors, and execution history.
@@ -86,7 +101,7 @@ interface ToolExecutionState<TOutput = unknown> {
  * Uses JSON Schema for type inference via `as const`.
  *
  * @template TInputSchema - JSON Schema defining input parameters
- * @template TOutputSchema - Output schema defining output structure (enables structuredContent)
+ * @template TOutputSchema - Output schema defining output structure (object schemas enable structuredContent)
  *
  * @public
  *
@@ -131,7 +146,7 @@ interface ToolExecutionState<TOutput = unknown> {
  * });
  * ```
  */
-interface WebMCPConfig<TInputSchema extends ReactWebMCPInputSchema = InputSchema, TOutputSchema extends ReactWebMCPOutputSchema | undefined = undefined> {
+interface WebMCPConfig<TInputSchema extends ReactWebMCPInputSchema = InputSchema, TOutputSchema extends ReactWebMCPSupportedOutputSchema | undefined = undefined> {
   /**
    * Unique identifier for the tool (e.g., 'posts_like', 'graph_navigate').
    * Must follow naming conventions: lowercase with underscores.
@@ -161,7 +176,7 @@ interface WebMCPConfig<TInputSchema extends ReactWebMCPInputSchema = InputSchema
   inputSchema?: TInputSchema;
   /**
    * **Recommended:** Output schema defining the expected output structure.
-   * Accepts either a JSON Schema object or a Zod schema map.
+   * Accepts either an inferable JSON Schema or a Zod schema map.
    *
    * When provided, this enables three key features:
    * 1. **Type Safety**: The handler's return type is inferred from this schema
@@ -234,7 +249,7 @@ interface WebMCPConfig<TInputSchema extends ReactWebMCPInputSchema = InputSchema
  * @template TOutputSchema - Output schema defining output structure
  * @public
  */
-interface WebMCPReturn<TOutputSchema extends ReactWebMCPOutputSchema | undefined = undefined> {
+interface WebMCPReturn<TOutputSchema extends ReactWebMCPSupportedOutputSchema | undefined = undefined, TInputSchema extends ReactWebMCPInputSchema = InputSchema> {
   /**
    * Current execution state including loading status, results, and errors.
    * See {@link ToolExecutionState} for details.
@@ -248,7 +263,7 @@ interface WebMCPReturn<TOutputSchema extends ReactWebMCPOutputSchema | undefined
    * @returns Promise resolving to the tool's output
    * @throws Error if validation fails or handler throws
    */
-  execute: (input: unknown) => Promise<InferOutput<TOutputSchema>>;
+  execute: (input: InferToolInput<TInputSchema>) => Promise<InferOutput<TOutputSchema>>;
   /**
    * Reset the execution state to its initial values.
    * Clears results, errors, and resets the execution count.
@@ -444,7 +459,7 @@ interface WebMCPResourceReturn {
  * ```
  *
  * @template TInputSchema - JSON Schema defining input parameter types (use `as const` for inference)
- * @template TOutputSchema - JSON Schema object defining output structure (enables structuredContent)
+ * @template TOutputSchema - JSON Schema defining output structure (object schemas enable structuredContent)
  *
  * @param config - Configuration object for the tool
  * @param deps - Optional dependency array that triggers tool re-registration when values change.
@@ -453,7 +468,7 @@ interface WebMCPResourceReturn {
  *
  * @public
  */
-declare function useWebMCP<TInputSchema extends ReactWebMCPInputSchema = InputSchema, TOutputSchema extends ReactWebMCPOutputSchema | undefined = undefined>(config: WebMCPConfig<TInputSchema, TOutputSchema>, deps?: DependencyList): WebMCPReturn<TOutputSchema>;
+declare function useWebMCP<TInputSchema extends ReactWebMCPInputSchema = InputSchema, TOutputSchema extends ReactWebMCPOutputSchema | undefined = undefined>(config: WebMCPConfig<TInputSchema, TOutputSchema>, deps?: DependencyList): WebMCPReturn<TOutputSchema, TInputSchema>;
 //#endregion
 //#region src/useWebMCPContext.d.ts
 /**

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"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":"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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"],"mappings":"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"}

package/dist/index.js

@@ -1,2 +1,2 @@
-"use client";import{createContext as e,useCallback as t,useContext as n,useEffect as r,useLayoutEffect as i,useMemo as a,useRef as o,useState as s}from"react";import{zodToJsonSchema as c}from"zod-to-json-schema";import{ResourceListChangedNotificationSchema as l,ToolListChangedNotificationSchema as u}from"@mcp-b/webmcp-ts-sdk";import{jsx as d}from"react/jsx-runtime";function f(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function p(e){return f(e)&&`_def`in e}function m(e){if(!f(e))return!1;let t=e._def;return f(t)&&`typeName`in t}function h(e){if(!f(e))return!1;let t=Object.values(e);return t.length===0?!1:t.some(e=>p(e))}function g(e){if(!m(e))return!1;let{typeName:t}=e._def;return t===`ZodOptional`||t===`ZodDefault`}function _(e){let t={...e};if(delete t.$schema,t.properties){let e={};for(let[n,r]of Object.entries(t.properties))e[n]=_(r);t.properties=e}return t}function v(e){let t={},n=[];for(let[r,i]of Object.entries(e)){if(!p(i))continue;let e=i;t[r]=_(c(e,{strictUnions:!0,$refStrategy:`none`})),g(e)||n.push(r)}let r={type:`object`,properties:t};return n.length>0&&(r.required=n),r}function y(e){return typeof e==`string`?e:JSON.stringify(e,null,2)}const b=new Map;function x(e){if(!e||typeof e!=`object`||Array.isArray(e))return null;try{let t=JSON.parse(JSON.stringify(e));return!t||typeof t!=`object`||Array.isArray(t)?null:t}catch{return null}}const S=typeof window<`u`?i:r;function C(e,n){let{name:i,description:a,inputSchema:c,outputSchema:l,annotations:u,handler:d,formatOutput:f=y,onSuccess:p,onError:m}=e,[g,_]=s({isExecuting:!1,lastResult:null,error:null,executionCount:0}),C=o(d),w=o(p),T=o(m),E=o(f),D=o(!0);S(()=>{C.current=d,w.current=p,T.current=m,E.current=f},[d,p,m,f]),r(()=>(D.current=!0,()=>{D.current=!1}),[]);let O=t(async e=>{_(e=>({...e,isExecuting:!0,error:null}));try{let t=await C.current(e);return D.current&&_(e=>({isExecuting:!1,lastResult:t,error:null,executionCount:e.executionCount+1})),w.current&&w.current(t,e),t}catch(t){let n=t instanceof Error?t:Error(String(t));throw D.current&&_(e=>({...e,isExecuting:!1,error:n})),T.current&&T.current(n,e),n}},[]),k=o(O);r(()=>{k.current=O},[O]);let A=t(e=>k.current(e),[]),j=t(()=>{_({isExecuting:!1,lastResult:null,error:null,executionCount:0})},[]);return r(()=>{if(typeof window>`u`||!window.navigator?.modelContext){console.warn(`[ReactWebMCP:useWebMCP]`,`Tool "${i}" skipped: modelContext is not available`);return}let e=window.navigator.modelContext,t=async e=>{try{let t=await k.current(e),n={content:[{type:`text`,text:E.current(t)}]};if(l){let e=x(t);if(!e)throw Error(`Tool "${i}" outputSchema requires the handler to return a JSON object result`);n.structuredContent=e}return n}catch(e){return{content:[{type:`text`,text:`Error: ${e instanceof Error?e.message:String(e)}`}],isError:!0}}},n=c?h(c)?v(c):c:void 0,r=l?h(l)?v(l):l:void 0,o=Symbol(i);return e.registerTool({name:i,description:a,...n&&{inputSchema:n},...r&&{outputSchema:r},...u&&{annotations:u},execute:t}),b.set(i,o),()=>{if(b.get(i)===o){b.delete(i);try{e.unregisterTool(i)}catch(e){console.warn(`[ReactWebMCP:useWebMCP]`,`Failed to unregister tool "${i}"`,e)}}}},[i,a,c,l,u,...n??[]]),{state:g,execute:A,reset:j}}function w(e,t,n){let r=o(n);return r.current=n,C({name:e,description:t,annotations:a(()=>({title:`Context: ${e}`,readOnlyHint:!0,idempotentHint:!0,destructiveHint:!1,openWorldHint:!1}),[e]),handler:async e=>r.current(),formatOutput:e=>typeof e==`string`?e:JSON.stringify(e,null,2)})}function T(e){let{name:t,description:n,argsSchema:i,get:a}=e,[c,l]=s(!1),u=o(a);return r(()=>{u.current=a},[a]),r(()=>{if(typeof window>`u`||!window.navigator?.modelContext){console.warn(`[ReactWebMCP] window.navigator.modelContext is not available. Prompt "${t}" will not be registered.`);return}let e=window.navigator.modelContext,r=async e=>u.current(e),a=i?h(i)?v(i):i:void 0,o;try{o=e.registerPrompt({name:t,...n!==void 0&&{description:n},...a&&{argsSchema:a},get:r})}catch(e){throw l(!1),e}if(!o){console.warn(`[ReactWebMCP] Prompt "${t}" did not return a registration handle.`),l(!1);return}return l(!0),()=>{o.unregister(),l(!1)}},[t,n,i]),{isRegistered:c}}function E(e){let{uri:t,name:n,description:i,mimeType:a,read:c}=e,[l,u]=s(!1),d=o(c);return r(()=>{d.current=c},[c]),r(()=>{if(typeof window>`u`||!window.navigator?.modelContext){console.warn(`[ReactWebMCP] window.navigator.modelContext is not available. Resource "${t}" will not be registered.`);return}let e=window.navigator.modelContext,r=async(e,t)=>d.current(e,t),o;try{o=e.registerResource({uri:t,name:n,...i!==void 0&&{description:i},...a!==void 0&&{mimeType:a},read:r})}catch(e){throw u(!1),e}if(!o){console.warn(`[ReactWebMCP] Resource "${t}" did not return a registration handle.`),u(!1);return}return u(!0),()=>{o.unregister(),u(!1)}},[t,n,i,a]),{isRegistered:l}}function D(e={}){let{onSuccess:n,onError:r}=e,[i,a]=s({isLoading:!1,result:null,error:null,requestCount:0}),o=t(()=>{a({isLoading:!1,result:null,error:null,requestCount:0})},[]);return{state:i,elicitInput:t(async e=>{if(typeof window>`u`||!window.navigator?.modelContext)throw Error(`navigator.modelContext is not available`);let t=window.navigator.modelContext;a(e=>({...e,isLoading:!0,error:null}));try{let r=await t.elicitInput(e);return a(e=>({isLoading:!1,result:r,error:null,requestCount:e.requestCount+1})),n?.(r),r}catch(e){let t=e instanceof Error?e:Error(String(e));throw a(e=>({...e,isLoading:!1,error:t})),r?.(t),t}},[n,r]),reset:o}}function O(e={}){let{onSuccess:n,onError:r}=e,[i,a]=s({isLoading:!1,result:null,error:null,requestCount:0}),o=t(()=>{a({isLoading:!1,result:null,error:null,requestCount:0})},[]);return{state:i,createMessage:t(async e=>{if(typeof window>`u`||!window.navigator?.modelContext)throw Error(`navigator.modelContext is not available`);let t=window.navigator.modelContext;a(e=>({...e,isLoading:!0,error:null}));try{let r=await t.createMessage(e);return a(e=>({isLoading:!1,result:r,error:null,requestCount:e.requestCount+1})),n?.(r),r}catch(e){let t=e instanceof Error?e:Error(String(e));throw a(e=>({...e,isLoading:!1,error:t})),r?.(t),t}},[n,r]),reset:o}}const k=e(null),A={};function j(e,t){let n=globalThis.console;if(!n)return;let r=n.debug??n.log;typeof r==`function`&&r.call(n,`[ReactWebMCP:McpClientProvider:ToolFlow]`,e,t)}function M(){if(typeof window>`u`)return!1;try{return window.localStorage.getItem(`WEBMCP_TRACE_TOOL_FLOW`)===`1`}catch{return!1}}function N({children:e,client:n,transport:i,opts:a}){let[c,f]=s([]),[p,m]=s([]),[h,g]=s(!1),[_,v]=s(null),[y,b]=s(!1),[x,S]=s(null),C=a??A,w=o(`disconnected`),T=o(0),E=t((e,t={})=>{let n=`[${++T.current}] ${e}`;M()&&j(n,t)},[]),D=t(async()=>{if(n){if(!n.getServerCapabilities()?.resources){f([]);return}try{f((await n.listResources()).resources)}catch(e){throw console.error(`[ReactWebMCP:McpClientProvider]`,`Error fetching resources:`,e),e}}},[n]),O=t(async()=>{if(!n)return;let e=n.getServerCapabilities();if(!e?.tools){E(`listTools:capability_missing`,{}),m([]);return}let t=Date.now();E(`listTools:start`,{hasToolsCapability:!!e.tools});try{let e=await n.listTools();m(e.tools),E(`listTools:success`,{durationMs:Date.now()-t,toolCount:e.tools.length})}catch(e){throw E(`listTools:error`,{durationMs:Date.now()-t,errorMessage:e instanceof Error?e.message:String(e)}),console.error(`[ReactWebMCP:McpClientProvider]`,`Error fetching tools:`,e),e}},[n,E]),N=t(async()=>{if(!n||!i)throw Error(`Client or transport not available`);if(w.current===`disconnected`){w.current=`connecting`,g(!0),v(null);try{await n.connect(i,C);let e=n.getServerCapabilities();b(!0),S(e||null),w.current=`connected`,E(`reconnect:connected`,{hasToolsListChanged:!!e?.tools?.listChanged}),await Promise.all([D(),O()])}catch(e){let t=e instanceof Error?e:Error(String(e));throw w.current=`disconnected`,v(t),t}finally{g(!1)}}},[n,i,C,D,O,E]);return r(()=>{if(!y||!n)return;let e=n.getServerCapabilities();return e?.resources?.listChanged&&n.setNotificationHandler(l,()=>{D().catch(e=>{console.error(`[ReactWebMCP:McpClientProvider]`,`Failed to refresh resources after list_changed:`,e)})}),e?.tools?.listChanged&&n.setNotificationHandler(u,()=>{E(`notification:tools/list_changed`,{}),O().catch(e=>{console.error(`[ReactWebMCP:McpClientProvider]`,`Failed to refresh tools after list_changed:`,e)})}),Promise.all([D(),O()]).catch(e=>{console.error(`[ReactWebMCP:McpClientProvider]`,`Failed to refresh tools/resources after handler registration:`,e)}),()=>{e?.resources?.listChanged&&n.removeNotificationHandler(`notifications/resources/list_changed`),e?.tools?.listChanged&&n.removeNotificationHandler(`notifications/tools/list_changed`)}},[n,y,D,O,E]),r(()=>(N().catch(e=>{console.error(`[ReactWebMCP:McpClientProvider]`,`Failed to connect MCP client:`,e)}),()=>{w.current=`disconnected`,b(!1)}),[n,i,N]),d(k.Provider,{value:{client:n,tools:p,resources:c,isConnected:y,isLoading:h,error:_,capabilities:x,reconnect:N},children:e})}function P(){let e=n(k);if(!e)throw Error(`useMcpClient must be used within an McpClientProvider`);return e}export{N as McpClientProvider,D as useElicitation,D as useElicitationHandler,P as useMcpClient,O as useSampling,O as useSamplingHandler,C as useWebMCP,w as useWebMCPContext,T as useWebMCPPrompt,E as useWebMCPResource};
+"use client";import{createContext as e,useCallback as t,useContext as n,useEffect as r,useLayoutEffect as i,useMemo as a,useRef as o,useState as s}from"react";import{zodToJsonSchema as c}from"zod-to-json-schema";import{ResourceListChangedNotificationSchema as l,ToolListChangedNotificationSchema as u}from"@mcp-b/webmcp-ts-sdk";import{jsx as d}from"react/jsx-runtime";function f(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function p(e){return f(e)&&`_def`in e}function m(e){if(!f(e))return!1;let t=e._def;return f(t)&&`typeName`in t}function h(e){if(!f(e))return!1;let t=Object.values(e);return t.length===0?!1:t.some(e=>p(e))}function g(e){if(!m(e))return!1;let{typeName:t}=e._def;return t===`ZodOptional`||t===`ZodDefault`}function _(e){let t={...e};if(delete t.$schema,t.properties){let e={};for(let[n,r]of Object.entries(t.properties))e[n]=_(r);t.properties=e}return t}function v(e){let t={},n=[];for(let[r,i]of Object.entries(e)){if(!p(i))continue;let e=i;t[r]=_(c(e,{strictUnions:!0,$refStrategy:`none`})),g(e)||n.push(r)}let r={type:`object`,properties:t};return n.length>0&&(r.required=n),r}function y(e){return typeof e==`string`?e:JSON.stringify(e,null,2)}const b=new Map,x={type:`object`,properties:{}},S=[`draft-2020-12`,`draft-07`];function C(e){return e?h(e)?!0:`type`in e&&e.type===`object`:!1}function w(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function T(e){return!(!w(e)||`type`in e&&e.type!==void 0&&typeof e.type!=`string`||`properties`in e&&e.properties!==void 0&&!w(e.properties)||`required`in e&&e.required!==void 0&&(!Array.isArray(e.required)||e.required.some(e=>typeof e!=`string`)))}function E(e){if(!w(e)||!(`type`in e))return!1;let t=e.type;return typeof t==`string`?[`array`,`boolean`,`integer`,`null`,`number`,`object`,`string`].includes(t)?t===`array`?`items`in e&&E(e.items):t===`object`&&`properties`in e&&e.properties!==void 0?w(e.properties)&&Object.values(e.properties).every(E):!0:!1:Array.isArray(t)&&t.length>0&&t.every(e=>[`array`,`boolean`,`integer`,`null`,`number`,`object`,`string`].includes(e))}function D(e){return e===null||typeof e==`string`||typeof e==`number`||typeof e==`boolean`?!0:Array.isArray(e)?e.every(D):typeof e==`object`?Object.values(e).every(D):!1}function O(e){return typeof e==`object`&&!!e&&!Array.isArray(e)&&D(e)}function k(e){if(!e||typeof e!=`object`||Array.isArray(e))return null;try{let t=JSON.parse(JSON.stringify(e));return O(t)?t:null}catch{return null}}const A=typeof window<`u`?i:r;function j(e,t){let n=new AbortController;return e.registerTool.call(e,t,{signal:n.signal}),n}function M(e){if(!e)return;if(h(e))return v(e);if(!w(e)||!(`~standard`in e))return T(e)?e:x;let t=e[`~standard`];if(!w(t))return x;let n=t.jsonSchema;if(!w(n)||typeof n.input!=`function`)return x;for(let e of S)try{let t=n.input({target:e});if(T(t))return t}catch{}return x}function N(e){if(!e)return;let t=h(e)?v(e):e;return E(t)?t:void 0}function P(e,n){let{name:i,description:a,inputSchema:c,outputSchema:l,annotations:u,handler:d,formatOutput:f=y,onSuccess:p,onError:m}=e,[h,g]=s({isExecuting:!1,lastResult:null,error:null,executionCount:0}),_=o(d),v=o(p),x=o(m),S=o(f),w=o(!0);A(()=>{_.current=d,v.current=p,x.current=m,S.current=f},[d,p,m,f]),r(()=>(w.current=!0,()=>{w.current=!1}),[]);let T=t(async e=>{g(e=>({...e,isExecuting:!0,error:null}));try{let t=await _.current(e);return w.current&&g(e=>({isExecuting:!1,lastResult:t,error:null,executionCount:e.executionCount+1})),v.current&&v.current(t,e),t}catch(t){let n=t instanceof Error?t:Error(String(t));throw w.current&&g(e=>({...e,isExecuting:!1,error:n})),x.current&&x.current(n,e),n}},[]),E=o(T);r(()=>{E.current=T},[T]);let D=t(e=>E.current(e),[]),O=t(()=>{g({isExecuting:!1,lastResult:null,error:null,executionCount:0})},[]);return r(()=>{if(typeof window>`u`||!window.navigator?.modelContext){console.warn(`[ReactWebMCP:useWebMCP]`,`Tool "${i}" skipped: modelContext is not available`);return}let e=window.navigator.modelContext,t=async e=>{try{let t=await Reflect.apply(E.current,void 0,[e]),n={content:[{type:`text`,text:S.current(t)}]};if(C(l)){let e=k(t);if(!e)throw Error(`Tool "${i}" outputSchema requires the handler to return a JSON object result`);n.structuredContent=e}return n}catch(e){return{content:[{type:`text`,text:`Error: ${e instanceof Error?e.message:String(e)}`}],isError:!0}}},n=M(c),r=N(l),o=Symbol(i),s=j(e,{name:i,description:a,...n&&{inputSchema:n},...r&&{outputSchema:r},...u&&{annotations:u},execute:t});return b.set(i,o),()=>{b.get(i)===o&&(b.delete(i),s.abort())}},[i,a,c,l,u,...n??[]]),{state:h,execute:D,reset:O}}function F(e,t,n){let r=o(n);return r.current=n,P({name:e,description:t,annotations:a(()=>({title:`Context: ${e}`,readOnlyHint:!0,idempotentHint:!0,destructiveHint:!1,openWorldHint:!1}),[e]),handler:async e=>r.current(),formatOutput:e=>typeof e==`string`?e:JSON.stringify(e,null,2)})}function I(e){let{name:t,description:n,argsSchema:i,get:a}=e,[c,l]=s(!1),u=o(a);return r(()=>{u.current=a},[a]),r(()=>{if(typeof window>`u`||!window.navigator?.modelContext){console.warn(`[ReactWebMCP] window.navigator.modelContext is not available. Prompt "${t}" will not be registered.`);return}let e=window.navigator.modelContext,r=async e=>u.current(e),a=i?h(i)?v(i):i:void 0,o;try{o=e.registerPrompt({name:t,...n!==void 0&&{description:n},...a&&{argsSchema:a},get:r})}catch(e){throw l(!1),e}if(!o){console.warn(`[ReactWebMCP] Prompt "${t}" did not return a registration handle.`),l(!1);return}return l(!0),()=>{o.unregister(),l(!1)}},[t,n,i]),{isRegistered:c}}function L(e){let{uri:t,name:n,description:i,mimeType:a,read:c}=e,[l,u]=s(!1),d=o(c);return r(()=>{d.current=c},[c]),r(()=>{if(typeof window>`u`||!window.navigator?.modelContext){console.warn(`[ReactWebMCP] window.navigator.modelContext is not available. Resource "${t}" will not be registered.`);return}let e=window.navigator.modelContext,r=async(e,t)=>d.current(e,t),o;try{o=e.registerResource({uri:t,name:n,...i!==void 0&&{description:i},...a!==void 0&&{mimeType:a},read:r})}catch(e){throw u(!1),e}if(!o){console.warn(`[ReactWebMCP] Resource "${t}" did not return a registration handle.`),u(!1);return}return u(!0),()=>{o.unregister(),u(!1)}},[t,n,i,a]),{isRegistered:l}}function R(e={}){let{onSuccess:n,onError:r}=e,[i,a]=s({isLoading:!1,result:null,error:null,requestCount:0}),o=t(()=>{a({isLoading:!1,result:null,error:null,requestCount:0})},[]);return{state:i,elicitInput:t(async e=>{if(typeof window>`u`||!window.navigator?.modelContext)throw Error(`navigator.modelContext is not available`);let t=window.navigator.modelContext;a(e=>({...e,isLoading:!0,error:null}));try{let r=await t.elicitInput(e);return a(e=>({isLoading:!1,result:r,error:null,requestCount:e.requestCount+1})),n?.(r),r}catch(e){let t=e instanceof Error?e:Error(String(e));throw a(e=>({...e,isLoading:!1,error:t})),r?.(t),t}},[n,r]),reset:o}}function z(e={}){let{onSuccess:n,onError:r}=e,[i,a]=s({isLoading:!1,result:null,error:null,requestCount:0}),o=t(()=>{a({isLoading:!1,result:null,error:null,requestCount:0})},[]);return{state:i,createMessage:t(async e=>{if(typeof window>`u`||!window.navigator?.modelContext)throw Error(`navigator.modelContext is not available`);let t=window.navigator.modelContext;a(e=>({...e,isLoading:!0,error:null}));try{let r=await t.createMessage(e);return a(e=>({isLoading:!1,result:r,error:null,requestCount:e.requestCount+1})),n?.(r),r}catch(e){let t=e instanceof Error?e:Error(String(e));throw a(e=>({...e,isLoading:!1,error:t})),r?.(t),t}},[n,r]),reset:o}}const B=e(null),V={};function H(e,t){let n=globalThis.console;if(!n)return;let r=n.debug??n.log;typeof r==`function`&&r.call(n,`[ReactWebMCP:McpClientProvider:ToolFlow]`,e,t)}function U(){if(typeof window>`u`)return!1;try{return window.localStorage.getItem(`WEBMCP_TRACE_TOOL_FLOW`)===`1`}catch{return!1}}function W({children:e,client:n,transport:i,opts:a}){let[c,f]=s([]),[p,m]=s([]),[h,g]=s(!1),[_,v]=s(null),[y,b]=s(!1),[x,S]=s(null),C=a??V,w=o(`disconnected`),T=o(0),E=t((e,t={})=>{let n=`[${++T.current}] ${e}`;U()&&H(n,t)},[]),D=t(async()=>{if(n){if(!n.getServerCapabilities()?.resources){f([]);return}try{f((await n.listResources()).resources)}catch(e){throw console.error(`[ReactWebMCP:McpClientProvider]`,`Error fetching resources:`,e),e}}},[n]),O=t(async()=>{if(!n)return;let e=n.getServerCapabilities();if(!e?.tools){E(`listTools:capability_missing`,{}),m([]);return}let t=Date.now();E(`listTools:start`,{hasToolsCapability:!!e.tools});try{let e=await n.listTools();m(e.tools),E(`listTools:success`,{durationMs:Date.now()-t,toolCount:e.tools.length})}catch(e){throw E(`listTools:error`,{durationMs:Date.now()-t,errorMessage:e instanceof Error?e.message:String(e)}),console.error(`[ReactWebMCP:McpClientProvider]`,`Error fetching tools:`,e),e}},[n,E]),k=t(async()=>{if(!n||!i)throw Error(`Client or transport not available`);if(w.current===`disconnected`){w.current=`connecting`,g(!0),v(null);try{await n.connect(i,C);let e=n.getServerCapabilities();b(!0),S(e||null),w.current=`connected`,E(`reconnect:connected`,{hasToolsListChanged:!!e?.tools?.listChanged}),await Promise.all([D(),O()])}catch(e){let t=e instanceof Error?e:Error(String(e));throw w.current=`disconnected`,v(t),t}finally{g(!1)}}},[n,i,C,D,O,E]);return r(()=>{if(!y||!n)return;let e=n.getServerCapabilities();return e?.resources?.listChanged&&n.setNotificationHandler(l,()=>{D().catch(e=>{console.error(`[ReactWebMCP:McpClientProvider]`,`Failed to refresh resources after list_changed:`,e)})}),e?.tools?.listChanged&&n.setNotificationHandler(u,()=>{E(`notification:tools/list_changed`,{}),O().catch(e=>{console.error(`[ReactWebMCP:McpClientProvider]`,`Failed to refresh tools after list_changed:`,e)})}),Promise.all([D(),O()]).catch(e=>{console.error(`[ReactWebMCP:McpClientProvider]`,`Failed to refresh tools/resources after handler registration:`,e)}),()=>{e?.resources?.listChanged&&n.removeNotificationHandler(`notifications/resources/list_changed`),e?.tools?.listChanged&&n.removeNotificationHandler(`notifications/tools/list_changed`)}},[n,y,D,O,E]),r(()=>(k().catch(e=>{console.error(`[ReactWebMCP:McpClientProvider]`,`Failed to connect MCP client:`,e)}),()=>{w.current=`disconnected`,b(!1)}),[n,i,k]),d(B.Provider,{value:{client:n,tools:p,resources:c,isConnected:y,isLoading:h,error:_,capabilities:x,reconnect:k},children:e})}function G(){let e=n(B);if(!e)throw Error(`useMcpClient must be used within an McpClientProvider`);return e}export{W as McpClientProvider,R as useElicitation,R as useElicitationHandler,G as useMcpClient,z as useSampling,z as useSamplingHandler,P as useWebMCP,F as useWebMCPContext,I as useWebMCPPrompt,L as useWebMCPResource};
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["props: Record<string, InputSchema>","zodToJsonSchema","properties: Record<string, InputSchema>","required: string[]","zodToJsonSchemaLib","result: InputSchema","response: CallToolResult","zodToJsonSchema","zodToJsonSchema","registration: { unregister: () => void } | undefined","registration: { unregister: () => void } | undefined","result: ElicitationResult","EMPTY_REQUEST_OPTS: RequestOptions","error"],"sources":["../src/zod-utils.ts","../src/useWebMCP.ts","../src/useWebMCPContext.ts","../src/useWebMCPPrompt.ts","../src/useWebMCPResource.ts","../src/useElicitationHandler.ts","../src/useSamplingHandler.ts","../src/client/McpClientProvider.tsx"],"sourcesContent":["import type { InputSchema } from '@mcp-b/webmcp-types';\nimport type { z } from 'zod';\nimport { zodToJsonSchema as zodToJsonSchemaLib } from 'zod-to-json-schema';\n\nexport type ZodSchemaObject = Record<string, z.ZodTypeAny>;\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === 'object' && !Array.isArray(value);\n}\n\nfunction isZodLikeValue(value: unknown): boolean {\n  // `_def` is present on both zod/v3 and zod v4 schema instances.\n  // Restricting detection to `_def` avoids misclassifying non-Zod Standard Schema values.\n  return isRecord(value) && '_def' in value;\n}\n\ntype ZodDefinitionCarrier = {\n  _def: {\n    typeName: unknown;\n  };\n};\n\nfunction hasZodTypeName(schema: unknown): schema is ZodDefinitionCarrier {\n  if (!isRecord(schema)) {\n    return false;\n  }\n\n  const definition = schema._def;\n  return isRecord(definition) && 'typeName' in definition;\n}\n\nexport function isZodSchema(schema: unknown): schema is ZodSchemaObject {\n  if (!isRecord(schema)) return false;\n  const values = Object.values(schema);\n  if (values.length === 0) return false;\n  return values.some((value) => isZodLikeValue(value));\n}\n\nfunction isOptionalSchema(schema: unknown): boolean {\n  if (!hasZodTypeName(schema)) {\n    return false;\n  }\n\n  const { typeName } = schema._def;\n  return typeName === 'ZodOptional' || typeName === 'ZodDefault';\n}\n\nfunction stripSchemaMeta(schema: InputSchema): InputSchema {\n  const rest = { ...schema } as InputSchema & { $schema?: string };\n  delete rest.$schema;\n  if (rest.properties) {\n    const props: Record<string, InputSchema> = {};\n    for (const [k, v] of Object.entries(rest.properties)) {\n      props[k] = stripSchemaMeta(v as InputSchema);\n    }\n    rest.properties = props;\n  }\n  return rest;\n}\n\nexport function zodToJsonSchema(schema: ZodSchemaObject): InputSchema {\n  const properties: Record<string, InputSchema> = {};\n  const required: string[] = [];\n\n  for (const [key, rawValue] of Object.entries(schema)) {\n    if (!isZodLikeValue(rawValue)) {\n      continue;\n    }\n\n    const zodSchema = rawValue as z.ZodTypeAny;\n    const propSchema = zodToJsonSchemaLib(zodSchema, {\n      strictUnions: true,\n      $refStrategy: 'none',\n    });\n    properties[key] = stripSchemaMeta(propSchema as InputSchema);\n    if (!isOptionalSchema(zodSchema)) {\n      required.push(key);\n    }\n  }\n\n  const result: InputSchema = { type: 'object', properties };\n  if (required.length > 0) result.required = required;\n  return result;\n}\n","import type { CallToolResult, InputSchema, ToolDescriptor } from '@mcp-b/webmcp-types';\nimport type { DependencyList } from 'react';\nimport { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';\nimport type {\n  InferOutput,\n  InferToolInput,\n  ReactWebMCPInputSchema,\n  ReactWebMCPOutputSchema,\n  ToolExecutionState,\n  WebMCPConfig,\n  WebMCPReturn,\n} from './types.js';\nimport { isZodSchema, zodToJsonSchema } from './zod-utils.js';\n\n/**\n * Default output formatter that converts values to formatted JSON strings.\n *\n * String values are returned as-is; all other types are serialized to\n * indented JSON for readability.\n *\n * @internal\n */\nfunction defaultFormatOutput(output: unknown): string {\n  if (typeof output === 'string') {\n    return output;\n  }\n  return JSON.stringify(output, null, 2);\n}\n\nconst TOOL_OWNER_BY_NAME = new Map<string, symbol>();\ntype StructuredContent = Exclude<CallToolResult['structuredContent'], undefined>;\n\nfunction toStructuredContent(value: unknown): StructuredContent | null {\n  if (!value || typeof value !== 'object' || Array.isArray(value)) {\n    return null;\n  }\n\n  try {\n    const normalized = JSON.parse(JSON.stringify(value)) as unknown;\n    if (!normalized || typeof normalized !== 'object' || Array.isArray(normalized)) {\n      return null;\n    }\n    return normalized as StructuredContent;\n  } catch {\n    return null;\n  }\n}\n\nconst useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;\n\n/**\n * React hook for registering and managing Model Context Protocol (MCP) tools.\n *\n * This hook handles the complete lifecycle of an MCP tool:\n * - Registers the tool with `window.navigator.modelContext`\n * - Manages execution state (loading, results, errors)\n * - Handles tool execution and lifecycle callbacks\n * - Automatically unregisters on component unmount\n * - Returns `structuredContent` when `outputSchema` is defined\n *\n * ## Output Schema (Recommended)\n *\n * Always define an `outputSchema` for your tools. This provides:\n * - **Type Safety**: Handler return type is inferred from the schema\n * - **MCP structuredContent**: AI models receive structured, typed data\n * - **Better AI Understanding**: Models can reason about your tool's output format\n *\n * ```tsx\n * useWebMCP({\n *   name: 'get_user',\n *   description: 'Get user by ID',\n *   inputSchema: {\n *     type: 'object',\n *     properties: { userId: { type: 'string' } },\n *     required: ['userId'],\n *   } as const,\n *   outputSchema: {\n *     type: 'object',\n *     properties: {\n *       id: { type: 'string' },\n *       name: { type: 'string' },\n *       email: { type: 'string' },\n *     },\n *   } as const,\n *   handler: async ({ userId }) => {\n *     const user = await fetchUser(userId);\n *     return { id: user.id, name: user.name, email: user.email };\n *   },\n * });\n * ```\n *\n * @template TInputSchema - JSON Schema defining input parameter types (use `as const` for inference)\n * @template TOutputSchema - JSON Schema object defining output structure (enables structuredContent)\n *\n * @param config - Configuration object for the tool\n * @param deps - Optional dependency array that triggers tool re-registration when values change.\n *\n * @returns Object containing execution state and control methods\n *\n * @public\n */\nexport function useWebMCP<\n  TInputSchema extends ReactWebMCPInputSchema = InputSchema,\n  TOutputSchema extends ReactWebMCPOutputSchema | undefined = undefined,\n>(\n  config: WebMCPConfig<TInputSchema, TOutputSchema>,\n  deps?: DependencyList\n): WebMCPReturn<TOutputSchema> {\n  type TOutput = InferOutput<TOutputSchema>;\n  type TInput = InferToolInput<TInputSchema>;\n  const {\n    name,\n    description,\n    inputSchema,\n    outputSchema,\n    annotations,\n    handler,\n    formatOutput = defaultFormatOutput,\n    onSuccess,\n    onError,\n  } = config;\n\n  const [state, setState] = useState<ToolExecutionState<TOutput>>({\n    isExecuting: false,\n    lastResult: null,\n    error: null,\n    executionCount: 0,\n  });\n\n  const handlerRef = useRef(handler);\n  const onSuccessRef = useRef(onSuccess);\n  const onErrorRef = useRef(onError);\n  const formatOutputRef = useRef(formatOutput);\n  const isMountedRef = useRef(true);\n  // Update refs when callbacks change (doesn't trigger re-registration)\n  useIsomorphicLayoutEffect(() => {\n    handlerRef.current = handler;\n    onSuccessRef.current = onSuccess;\n    onErrorRef.current = onError;\n    formatOutputRef.current = formatOutput;\n  }, [handler, onSuccess, onError, formatOutput]);\n\n  // Cleanup: mark component as unmounted\n  useEffect(() => {\n    isMountedRef.current = true;\n    return () => {\n      isMountedRef.current = false;\n    };\n  }, []);\n\n  /**\n   * Executes the tool handler with input validation and state management.\n   *\n   * @param input - The input parameters to validate and pass to the handler\n   * @returns Promise resolving to the handler's output\n   * @throws Error if validation fails or the handler throws\n   */\n  const execute = useCallback(async (input: unknown): Promise<TOutput> => {\n    setState((prev) => ({\n      ...prev,\n      isExecuting: true,\n      error: null,\n    }));\n\n    try {\n      const result = await handlerRef.current(input as TInput);\n\n      // Only update state if component is still mounted\n      if (isMountedRef.current) {\n        setState((prev) => ({\n          isExecuting: false,\n          lastResult: result,\n          error: null,\n          executionCount: prev.executionCount + 1,\n        }));\n      }\n\n      if (onSuccessRef.current) {\n        onSuccessRef.current(result, input);\n      }\n\n      return result;\n    } catch (error) {\n      const err = error instanceof Error ? error : new Error(String(error));\n\n      // Only update state if component is still mounted\n      if (isMountedRef.current) {\n        setState((prev) => ({\n          ...prev,\n          isExecuting: false,\n          error: err,\n        }));\n      }\n\n      if (onErrorRef.current) {\n        onErrorRef.current(err, input);\n      }\n\n      throw err;\n    }\n  }, []);\n  const executeRef = useRef(execute);\n\n  useEffect(() => {\n    executeRef.current = execute;\n  }, [execute]);\n\n  const stableExecute = useCallback(\n    (input: unknown): Promise<TOutput> => executeRef.current(input),\n    []\n  );\n\n  /**\n   * Resets the execution state to initial values.\n   */\n  const reset = useCallback(() => {\n    setState({\n      isExecuting: false,\n      lastResult: null,\n      error: null,\n      executionCount: 0,\n    });\n  }, []);\n\n  useEffect(() => {\n    if (typeof window === 'undefined' || !window.navigator?.modelContext) {\n      console.warn(\n        '[ReactWebMCP:useWebMCP]',\n        `Tool \"${name}\" skipped: modelContext is not available`\n      );\n      return;\n    }\n    const modelContext = window.navigator.modelContext;\n\n    /**\n     * Handles MCP tool execution by running the handler and formatting the response.\n     *\n     * @param input - The input parameters from the MCP client\n     * @returns CallToolResult with text content and optional structuredContent\n     */\n    const mcpHandler = async (input: unknown): Promise<CallToolResult> => {\n      try {\n        const result = await executeRef.current(input);\n        const formattedOutput = formatOutputRef.current(result);\n\n        const response: CallToolResult = {\n          content: [\n            {\n              type: 'text',\n              text: formattedOutput,\n            },\n          ],\n        };\n\n        if (outputSchema) {\n          const structuredContent = toStructuredContent(result);\n          if (!structuredContent) {\n            throw new Error(\n              `Tool \"${name}\" outputSchema requires the handler to return a JSON object result`\n            );\n          }\n          response.structuredContent = structuredContent;\n        }\n\n        return response;\n      } catch (error) {\n        const errorMessage = error instanceof Error ? error.message : String(error);\n\n        return {\n          content: [\n            {\n              type: 'text',\n              text: `Error: ${errorMessage}`,\n            },\n          ],\n          isError: true,\n        };\n      }\n    };\n\n    const resolvedInputSchema = inputSchema\n      ? isZodSchema(inputSchema)\n        ? zodToJsonSchema(inputSchema)\n        : (inputSchema as InputSchema)\n      : undefined;\n    const resolvedOutputSchema = outputSchema\n      ? isZodSchema(outputSchema)\n        ? zodToJsonSchema(outputSchema)\n        : (outputSchema as InputSchema)\n      : undefined;\n\n    const ownerToken = Symbol(name);\n    (modelContext.registerTool as (tool: ToolDescriptor) => void)({\n      name,\n      description,\n      ...(resolvedInputSchema && { inputSchema: resolvedInputSchema }),\n      ...(resolvedOutputSchema && { outputSchema: resolvedOutputSchema }),\n      ...(annotations && { annotations }),\n      execute: mcpHandler,\n    });\n    TOOL_OWNER_BY_NAME.set(name, ownerToken);\n\n    return () => {\n      const currentOwner = TOOL_OWNER_BY_NAME.get(name);\n      if (currentOwner !== ownerToken) {\n        return;\n      }\n\n      TOOL_OWNER_BY_NAME.delete(name);\n      try {\n        modelContext.unregisterTool(name);\n      } catch (error) {\n        console.warn('[ReactWebMCP:useWebMCP]', `Failed to unregister tool \"${name}\"`, error);\n      }\n    };\n    // Spread operator in dependencies intentionally allows consumers to trigger\n    // re-registration with custom reactive inputs.\n  }, [name, description, inputSchema, outputSchema, annotations, ...(deps ?? [])]);\n\n  return {\n    state,\n    execute: stableExecute,\n    reset,\n  };\n}\n","import { useMemo, useRef } from 'react';\nimport type { WebMCPReturn } from './types.js';\nimport { useWebMCP } from './useWebMCP.js';\n\n/**\n * Convenience hook for exposing read-only context data to AI assistants.\n *\n * This is a simplified wrapper around {@link useWebMCP} specifically designed for\n * context tools that expose data without performing actions. The hook automatically\n * configures appropriate annotations (read-only, idempotent) and handles value\n * serialization.\n *\n * Note: This hook does not use an output schema, so the result will not include\n * `structuredContent` in the MCP response. Use {@link useWebMCP} directly with\n * `outputSchema` if you need structured output for MCP compliance.\n *\n * @template T - The type of context data to expose\n *\n * @param name - Unique identifier for the context tool (e.g., 'context_current_post')\n * @param description - Human-readable description of the context for AI assistants\n * @param getValue - Function that returns the current context value\n * @returns Tool execution state and control methods\n *\n * @public\n *\n * @example\n * Expose current post context:\n * ```tsx\n * function PostDetailPage() {\n *   const { postId } = useParams();\n *   const { data: post } = useQuery(['post', postId], () => fetchPost(postId));\n *\n *   useWebMCPContext(\n *     'context_current_post',\n *     'Get the currently viewed post ID and metadata',\n *     () => ({\n *       postId,\n *       title: post?.title,\n *       author: post?.author,\n *       tags: post?.tags,\n *       createdAt: post?.createdAt,\n *     })\n *   );\n *\n *   return <PostContent post={post} />;\n * }\n * ```\n *\n * @example\n * Expose user session context:\n * ```tsx\n * function AppRoot() {\n *   const { user, isAuthenticated } = useAuth();\n *\n *   useWebMCPContext(\n *     'context_user_session',\n *     'Get the current user session information',\n *     () => ({\n *       isAuthenticated,\n *       userId: user?.id,\n *       email: user?.email,\n *       permissions: user?.permissions,\n *     })\n *   );\n *\n *   return <App />;\n * }\n * ```\n */\nexport function useWebMCPContext<T>(\n  name: string,\n  description: string,\n  getValue: () => T\n): WebMCPReturn {\n  const getValueRef = useRef(getValue);\n  getValueRef.current = getValue;\n  const annotations = useMemo(\n    () => ({\n      title: `Context: ${name}`,\n      readOnlyHint: true,\n      idempotentHint: true,\n      destructiveHint: false,\n      openWorldHint: false,\n    }),\n    [name]\n  );\n\n  // Use default generics (no input/output schema) since context tools\n  // don't define structured schemas. The handler returns T but it's\n  // treated as `unknown` in the return type since no outputSchema is defined.\n  return useWebMCP({\n    name,\n    description,\n    annotations,\n    // Cast to unknown since context tools return arbitrary types\n    // that don't need to conform to a specific schema\n    handler: async (_input: Record<string, unknown>) => {\n      return getValueRef.current() as Record<string, unknown>;\n    },\n    formatOutput: (output) => {\n      if (typeof output === 'string') {\n        return output as string;\n      }\n      return JSON.stringify(output, null, 2);\n    },\n  });\n}\n","import type { InputSchema } from '@mcp-b/webmcp-types';\nimport { useEffect, useRef, useState } from 'react';\nimport type {\n  PromptMessage,\n  ReactWebMCPInputSchema,\n  WebMCPPromptConfig,\n  WebMCPPromptReturn,\n} from './types.js';\nimport { isZodSchema, zodToJsonSchema } from './zod-utils.js';\n\ntype PromptModelContext = Navigator['modelContext'] & {\n  registerPrompt: (descriptor: {\n    name: string;\n    description?: string;\n    argsSchema?: InputSchema;\n    get: (args: Record<string, unknown>) => Promise<{ messages: PromptMessage[] }>;\n  }) => { unregister: () => void } | undefined;\n};\n\n/**\n * React hook for registering Model Context Protocol (MCP) prompts.\n *\n * This hook handles the complete lifecycle of an MCP prompt:\n * - Registers the prompt with `window.navigator.modelContext`\n * - Converts Zod schemas to JSON Schema for argument validation\n * - Automatically unregisters on component unmount\n *\n * @template TArgsSchema - Zod schema object defining argument types\n *\n * @param config - Configuration object for the prompt\n * @returns Object indicating registration status\n *\n * @public\n *\n * @example\n * Simple prompt without arguments:\n * ```tsx\n * function HelpPrompt() {\n *   const { isRegistered } = useWebMCPPrompt({\n *     name: 'help',\n *     description: 'Get help with using the application',\n *     get: async () => ({\n *       messages: [{\n *         role: 'user',\n *         content: { type: 'text', text: 'How do I use this application?' }\n *       }]\n *     }),\n *   });\n *\n *   return <div>Help prompt {isRegistered ? 'ready' : 'loading'}</div>;\n * }\n * ```\n *\n * @example\n * Prompt with typed arguments:\n * ```tsx\n * function CodeReviewPrompt() {\n *   const { isRegistered } = useWebMCPPrompt({\n *     name: 'review_code',\n *     description: 'Review code for best practices',\n *     argsSchema: {\n *       type: 'object',\n *       properties: {\n *         code: { type: 'string', description: 'The code to review' },\n *         language: { type: 'string', description: 'Programming language' },\n *       },\n *       required: ['code'],\n *     } as const,\n *     get: async ({ code, language }) => ({\n *       messages: [{\n *         role: 'user',\n *         content: {\n *           type: 'text',\n *           text: `Please review this ${language ?? ''} code:\\n\\n${code}`\n *         }\n *       }]\n *     }),\n *   });\n *\n *   return <div>Code review prompt {isRegistered ? 'ready' : 'loading'}</div>;\n * }\n * ```\n */\nexport function useWebMCPPrompt<TArgsSchema extends ReactWebMCPInputSchema = InputSchema>(\n  config: WebMCPPromptConfig<TArgsSchema>\n): WebMCPPromptReturn {\n  const { name, description, argsSchema, get } = config;\n\n  const [isRegistered, setIsRegistered] = useState(false);\n\n  const getRef = useRef(get);\n\n  useEffect(() => {\n    getRef.current = get;\n  }, [get]);\n\n  useEffect(() => {\n    if (typeof window === 'undefined' || !window.navigator?.modelContext) {\n      console.warn(\n        `[ReactWebMCP] window.navigator.modelContext is not available. Prompt \"${name}\" will not be registered.`\n      );\n      return;\n    }\n    const modelContext = window.navigator.modelContext as PromptModelContext;\n\n    const promptHandler = async (\n      args: Record<string, unknown>\n    ): Promise<{ messages: PromptMessage[] }> => {\n      return getRef.current(args as never);\n    };\n\n    const resolvedArgsSchema = argsSchema\n      ? isZodSchema(argsSchema)\n        ? zodToJsonSchema(argsSchema)\n        : (argsSchema as InputSchema)\n      : undefined;\n\n    let registration: { unregister: () => void } | undefined;\n    try {\n      registration = modelContext.registerPrompt({\n        name,\n        ...(description !== undefined && { description }),\n        ...(resolvedArgsSchema && { argsSchema: resolvedArgsSchema }),\n        get: promptHandler,\n      });\n    } catch (error) {\n      setIsRegistered(false);\n      throw error;\n    }\n\n    if (!registration) {\n      console.warn(`[ReactWebMCP] Prompt \"${name}\" did not return a registration handle.`);\n      setIsRegistered(false);\n      return;\n    }\n\n    setIsRegistered(true);\n\n    return () => {\n      registration.unregister();\n      setIsRegistered(false);\n    };\n  }, [name, description, argsSchema]);\n\n  return {\n    isRegistered,\n  };\n}\n","import { useEffect, useRef, useState } from 'react';\nimport type { ResourceContents, WebMCPResourceConfig, WebMCPResourceReturn } from './types.js';\n\ntype ResourceModelContext = Navigator['modelContext'] & {\n  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 } | undefined;\n};\n\n/**\n * React hook for registering Model Context Protocol (MCP) resources.\n *\n * This hook handles the complete lifecycle of an MCP resource:\n * - Registers the resource with `window.navigator.modelContext`\n * - Supports both static URIs and URI templates with parameters\n * - Automatically unregisters on component unmount\n *\n * @param config - Configuration object for the resource\n * @returns Object indicating registration status\n *\n * @public\n *\n * @example\n * Static resource:\n * ```tsx\n * function AppSettingsResource() {\n *   const { isRegistered } = useWebMCPResource({\n *     uri: 'config://app-settings',\n *     name: 'App Settings',\n *     description: 'Application configuration',\n *     mimeType: 'application/json',\n *     read: async (uri) => ({\n *       contents: [{\n *         uri: uri.href,\n *         text: JSON.stringify({ theme: 'dark', language: 'en' })\n *       }]\n *     }),\n *   });\n *\n *   return <div>Settings resource {isRegistered ? 'ready' : 'loading'}</div>;\n * }\n * ```\n *\n * @example\n * Dynamic resource with URI template:\n * ```tsx\n * function UserProfileResource() {\n *   const { isRegistered } = useWebMCPResource({\n *     uri: 'user://{userId}/profile',\n *     name: 'User Profile',\n *     description: 'User profile data by ID',\n *     mimeType: 'application/json',\n *     read: async (uri, params) => {\n *       const userId = params?.userId ?? '';\n *       const profile = await fetchUserProfile(userId);\n *       return {\n *         contents: [{\n *           uri: uri.href,\n *           text: JSON.stringify(profile)\n *         }]\n *       };\n *     },\n *   });\n *\n *   return <div>User profile resource {isRegistered ? 'ready' : 'loading'}</div>;\n * }\n * ```\n */\nexport function useWebMCPResource(config: WebMCPResourceConfig): WebMCPResourceReturn {\n  const { uri, name, description, mimeType, read } = config;\n\n  const [isRegistered, setIsRegistered] = useState(false);\n\n  const readRef = useRef(read);\n\n  useEffect(() => {\n    readRef.current = read;\n  }, [read]);\n\n  useEffect(() => {\n    if (typeof window === 'undefined' || !window.navigator?.modelContext) {\n      console.warn(\n        `[ReactWebMCP] window.navigator.modelContext is not available. Resource \"${uri}\" will not be registered.`\n      );\n      return;\n    }\n    const modelContext = window.navigator.modelContext as ResourceModelContext;\n\n    const resourceHandler = async (\n      resolvedUri: URL,\n      params?: Record<string, string>\n    ): Promise<{ contents: ResourceContents[] }> => {\n      return readRef.current(resolvedUri, params);\n    };\n\n    let registration: { unregister: () => void } | undefined;\n    try {\n      registration = modelContext.registerResource({\n        uri,\n        name,\n        ...(description !== undefined && { description }),\n        ...(mimeType !== undefined && { mimeType }),\n        read: resourceHandler,\n      });\n    } catch (error) {\n      setIsRegistered(false);\n      throw error;\n    }\n\n    if (!registration) {\n      console.warn(`[ReactWebMCP] Resource \"${uri}\" did not return a registration handle.`);\n      setIsRegistered(false);\n      return;\n    }\n\n    setIsRegistered(true);\n\n    return () => {\n      registration.unregister();\n      setIsRegistered(false);\n    };\n  }, [uri, name, description, mimeType]);\n\n  return {\n    isRegistered,\n  };\n}\n","import type { ElicitationParams, ElicitationResult } from '@mcp-b/webmcp-types';\nimport { useCallback, useState } from 'react';\n\ntype ElicitationModelContext = Navigator['modelContext'] & {\n  elicitInput: (params: ElicitationParams) => Promise<ElicitationResult>;\n};\n\n/**\n * State for elicitation requests, tracking the current request and results.\n */\nexport interface ElicitationState {\n  /** Whether an elicitation request is currently in progress */\n  isLoading: boolean;\n  /** The last elicitation result received */\n  result: ElicitationResult | null;\n  /** Any error that occurred during the last request */\n  error: Error | null;\n  /** Total number of requests made */\n  requestCount: number;\n}\n\n/**\n * Configuration options for the useElicitation hook.\n */\nexport interface UseElicitationConfig {\n  /**\n   * Optional callback invoked when an elicitation request completes successfully.\n   */\n  onSuccess?: (result: ElicitationResult) => void;\n\n  /**\n   * Optional callback invoked when an elicitation request fails.\n   */\n  onError?: (error: Error) => void;\n}\n\n/**\n * Return value from the useElicitation hook.\n */\nexport interface UseElicitationReturn {\n  /** Current state of elicitation */\n  state: ElicitationState;\n  /** Function to request user input from the connected client */\n  elicitInput: (params: ElicitationParams) => Promise<ElicitationResult>;\n  /** Reset the state */\n  reset: () => void;\n}\n\n/**\n * React hook for requesting user input from the connected MCP client.\n *\n * Elicitation allows the server (webpage) to request user input from the\n * connected client. This is useful when the page needs additional information\n * from the user, such as API keys, configuration options, or confirmations.\n *\n * There are two modes:\n * 1. **Form mode**: For non-sensitive data collection using a schema-driven form.\n * 2. **URL mode**: For sensitive data collection via a web URL (API keys, OAuth, etc.).\n *\n * @param config - Optional configuration including callbacks\n * @returns Object containing state and the elicitInput function\n *\n * @example Form elicitation:\n * ```tsx\n * function ConfigForm() {\n *   const { state, elicitInput } = useElicitation({\n *     onSuccess: (result) => console.log('Got input:', result),\n *     onError: (error) => console.error('Elicitation failed:', error),\n *   });\n *\n *   const handleConfigure = async () => {\n *     const result = await elicitInput({\n *       message: 'Please provide your configuration',\n *       requestedSchema: {\n *         type: 'object',\n *         properties: {\n *           apiKey: { type: 'string', title: 'API Key', description: 'Your API key' },\n *           model: { type: 'string', enum: ['gpt-4', 'gpt-3.5'], title: 'Model' }\n *         },\n *         required: ['apiKey']\n *       }\n *     });\n *\n *     if (result.action === 'accept') {\n *       console.log('Config:', result.content);\n *     }\n *   };\n *\n *   return (\n *     <button onClick={handleConfigure} disabled={state.isLoading}>\n *       Configure\n *     </button>\n *   );\n * }\n * ```\n *\n * @example URL elicitation (for sensitive data):\n * ```tsx\n * const { elicitInput } = useElicitation();\n *\n * const handleOAuth = async () => {\n *   const result = await elicitInput({\n *     mode: 'url',\n *     message: 'Please authenticate with GitHub',\n *     elicitationId: 'github-oauth-123',\n *     url: 'https://github.com/login/oauth/authorize?client_id=...'\n *   });\n *\n *   if (result.action === 'accept') {\n *     console.log('OAuth completed');\n *   }\n * };\n * ```\n */\nexport function useElicitation(config: UseElicitationConfig = {}): UseElicitationReturn {\n  const { onSuccess, onError } = config;\n\n  const [state, setState] = useState<ElicitationState>({\n    isLoading: false,\n    result: null,\n    error: null,\n    requestCount: 0,\n  });\n\n  const reset = useCallback(() => {\n    setState({\n      isLoading: false,\n      result: null,\n      error: null,\n      requestCount: 0,\n    });\n  }, []);\n\n  const elicitInput = useCallback(\n    async (params: ElicitationParams): Promise<ElicitationResult> => {\n      if (typeof window === 'undefined' || !window.navigator?.modelContext) {\n        throw new Error('navigator.modelContext is not available');\n      }\n      const mc = window.navigator.modelContext as ElicitationModelContext;\n\n      setState((prev) => ({\n        ...prev,\n        isLoading: true,\n        error: null,\n      }));\n\n      try {\n        const result: ElicitationResult = await mc.elicitInput(params);\n\n        setState((prev) => ({\n          isLoading: false,\n          result,\n          error: null,\n          requestCount: prev.requestCount + 1,\n        }));\n\n        onSuccess?.(result);\n        return result;\n      } catch (err) {\n        const error = err instanceof Error ? err : new Error(String(err));\n\n        setState((prev) => ({\n          ...prev,\n          isLoading: false,\n          error,\n        }));\n\n        onError?.(error);\n        throw error;\n      }\n    },\n    [onSuccess, onError]\n  );\n\n  return {\n    state,\n    elicitInput,\n    reset,\n  };\n}\n\n// Also export with the old name for backwards compatibility during migration\nexport { useElicitation as useElicitationHandler };\nexport type { ElicitationState as ElicitationHandlerState };\nexport type { UseElicitationConfig as UseElicitationHandlerConfig };\nexport type { UseElicitationReturn as UseElicitationHandlerReturn };\n","import type { SamplingRequestParams, SamplingResult } from '@mcp-b/webmcp-ts-sdk';\nimport { useCallback, useState } from 'react';\n\ntype SamplingModelContext = Navigator['modelContext'] & {\n  createMessage: (params: SamplingRequestParams) => Promise<SamplingResult>;\n};\n\n/**\n * State for sampling requests, tracking the current request and results.\n */\nexport interface SamplingState {\n  /** Whether a sampling request is currently in progress */\n  isLoading: boolean;\n  /** The last sampling result received */\n  result: SamplingResult | null;\n  /** Any error that occurred during the last request */\n  error: Error | null;\n  /** Total number of requests made */\n  requestCount: number;\n}\n\n/**\n * Configuration options for the useSampling hook.\n */\nexport interface UseSamplingConfig {\n  /**\n   * Optional callback invoked when a sampling request completes successfully.\n   */\n  onSuccess?: (result: SamplingResult) => void;\n\n  /**\n   * Optional callback invoked when a sampling request fails.\n   */\n  onError?: (error: Error) => void;\n}\n\n/**\n * Return value from the useSampling hook.\n */\nexport interface UseSamplingReturn {\n  /** Current state of sampling */\n  state: SamplingState;\n  /** Function to request LLM completion from the connected client */\n  createMessage: (params: SamplingRequestParams) => Promise<SamplingResult>;\n  /** Reset the state */\n  reset: () => void;\n}\n\n/**\n * React hook for requesting LLM completions from the connected MCP client.\n *\n * Sampling allows the server (webpage) to request LLM completions from the\n * connected client. This is useful when the page needs AI capabilities like\n * summarization, generation, or analysis.\n *\n * @param config - Optional configuration including callbacks\n * @returns Object containing state and the createMessage function\n *\n * @example Basic usage:\n * ```tsx\n * function AIAssistant() {\n *   const { state, createMessage } = useSampling({\n *     onSuccess: (result) => console.log('Got response:', result),\n *     onError: (error) => console.error('Sampling failed:', error),\n *   });\n *\n *   const handleAsk = async () => {\n *     const result = await createMessage({\n *       messages: [\n *         { role: 'user', content: { type: 'text', text: 'What is 2+2?' } }\n *       ],\n *       maxTokens: 100,\n *     });\n *     console.log(result.content);\n *   };\n *\n *   return (\n *     <div>\n *       <button onClick={handleAsk} disabled={state.isLoading}>\n *         Ask AI\n *       </button>\n *       {state.result && <p>{JSON.stringify(state.result.content)}</p>}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useSampling(config: UseSamplingConfig = {}): UseSamplingReturn {\n  const { onSuccess, onError } = config;\n\n  const [state, setState] = useState<SamplingState>({\n    isLoading: false,\n    result: null,\n    error: null,\n    requestCount: 0,\n  });\n\n  const reset = useCallback(() => {\n    setState({\n      isLoading: false,\n      result: null,\n      error: null,\n      requestCount: 0,\n    });\n  }, []);\n\n  const createMessage = useCallback(\n    async (params: SamplingRequestParams): Promise<SamplingResult> => {\n      if (typeof window === 'undefined' || !window.navigator?.modelContext) {\n        throw new Error('navigator.modelContext is not available');\n      }\n      const modelContext = window.navigator.modelContext as SamplingModelContext;\n\n      setState((prev) => ({\n        ...prev,\n        isLoading: true,\n        error: null,\n      }));\n\n      try {\n        const result = await modelContext.createMessage(params);\n\n        setState((prev) => ({\n          isLoading: false,\n          result,\n          error: null,\n          requestCount: prev.requestCount + 1,\n        }));\n\n        onSuccess?.(result);\n        return result;\n      } catch (err) {\n        const error = err instanceof Error ? err : new Error(String(err));\n\n        setState((prev) => ({\n          ...prev,\n          isLoading: false,\n          error,\n        }));\n\n        onError?.(error);\n        throw error;\n      }\n    },\n    [onSuccess, onError]\n  );\n\n  return {\n    state,\n    createMessage,\n    reset,\n  };\n}\n\n// Also export with the old name for backwards compatibility during migration\nexport { useSampling as useSamplingHandler };\nexport type { SamplingState as SamplingHandlerState };\nexport type { UseSamplingConfig as UseSamplingHandlerConfig };\nexport type { UseSamplingReturn as UseSamplingHandlerReturn };\n","import {\n  type Client,\n  type Tool as McpTool,\n  type RequestOptions,\n  type Resource,\n  ResourceListChangedNotificationSchema,\n  type ServerCapabilities,\n  ToolListChangedNotificationSchema,\n  type Transport,\n} from '@mcp-b/webmcp-ts-sdk';\nimport {\n  createContext,\n  type ReactElement,\n  type ReactNode,\n  useCallback,\n  useContext,\n  useEffect,\n  useRef,\n  useState,\n} from 'react';\n\n/**\n * Context value provided by McpClientProvider.\n *\n * @internal\n */\ninterface McpClientContextValue {\n  client: Client;\n  tools: McpTool[];\n  resources: Resource[];\n  isConnected: boolean;\n  isLoading: boolean;\n  error: Error | null;\n  capabilities: ServerCapabilities | null;\n  reconnect: () => Promise<void>;\n}\n\nconst McpClientContext = createContext<McpClientContextValue | null>(null);\nconst EMPTY_REQUEST_OPTS: RequestOptions = {};\nconst TOOL_FLOW_TRACE_KEY = 'WEBMCP_TRACE_TOOL_FLOW';\n\nfunction emitForcedToolFlowTrace(event: string, details: Record<string, unknown>): void {\n  const consoleRef = globalThis.console;\n  if (!consoleRef) {\n    return;\n  }\n\n  const method = consoleRef.debug ?? consoleRef.log;\n  if (typeof method !== 'function') {\n    return;\n  }\n\n  method.call(consoleRef, '[ReactWebMCP:McpClientProvider:ToolFlow]', event, details);\n}\n\nfunction isToolFlowTraceEnabled(): boolean {\n  if (typeof window === 'undefined') {\n    return false;\n  }\n\n  try {\n    return window.localStorage.getItem(TOOL_FLOW_TRACE_KEY) === '1';\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Props for the McpClientProvider component.\n *\n * @public\n */\nexport interface McpClientProviderProps {\n  /**\n   * React children to render within the provider.\n   */\n  children: ReactNode;\n\n  /**\n   * MCP Client instance to use for communication.\n   */\n  client: Client;\n\n  /**\n   * Transport instance for the client to connect through.\n   */\n  transport: Transport;\n\n  /**\n   * Optional request options for the connection.\n   */\n  opts?: RequestOptions;\n}\n\n/**\n * Provider component that manages an MCP client connection and exposes\n * tools, resources, and connection state to child components.\n *\n * This provider handles:\n * - Establishing and maintaining the MCP client connection\n * - Fetching available tools and resources from the server\n * - Listening for server notifications about tool/resource changes\n * - Managing connection state and errors\n * - Automatic cleanup on unmount\n *\n * @param props - Component props\n * @returns Provider component wrapping children\n *\n * @public\n *\n * @example\n * Connect to an MCP server via tab transport:\n * ```tsx\n * import { Client } from '@modelcontextprotocol/sdk/client/index.js';\n * import { TabClientTransport } from '@mcp-b/transports';\n * import { McpClientProvider } from '@mcp-b/react-webmcp';\n *\n * const client = new Client(\n *   { name: 'my-app', version: '1.0.0' },\n *   { capabilities: {} }\n * );\n *\n * const transport = new TabClientTransport('mcp', {\n *   clientInstanceId: 'my-app-instance',\n * });\n *\n * function App() {\n *   return (\n *     <McpClientProvider client={client} transport={transport}>\n *       <MyAppContent />\n *     </McpClientProvider>\n *   );\n * }\n * ```\n *\n * @example\n * Access tools from child components:\n * ```tsx\n * function MyAppContent() {\n *   const { tools, isConnected, isLoading } = useMcpClient();\n *\n *   if (isLoading) {\n *     return <div>Connecting to MCP server...</div>;\n *   }\n *\n *   if (!isConnected) {\n *     return <div>Failed to connect to MCP server</div>;\n *   }\n *\n *   return (\n *     <div>\n *       <h2>Available Tools:</h2>\n *       <ul>\n *         {tools.map(tool => (\n *           <li key={tool.name}>{tool.description}</li>\n *         ))}\n *       </ul>\n *     </div>\n *   );\n * }\n * ```\n */\nexport function McpClientProvider({\n  children,\n  client,\n  transport,\n  opts,\n}: McpClientProviderProps): ReactElement {\n  const [resources, setResources] = useState<Resource[]>([]);\n  const [tools, setTools] = useState<McpTool[]>([]);\n  const [isLoading, setIsLoading] = useState<boolean>(false);\n  const [error, setError] = useState<Error | null>(null);\n  const [isConnected, setIsConnected] = useState<boolean>(false);\n  const [capabilities, setCapabilities] = useState<ServerCapabilities | null>(null);\n  const requestOpts = opts ?? EMPTY_REQUEST_OPTS;\n\n  const connectionStateRef = useRef<'disconnected' | 'connecting' | 'connected'>('disconnected');\n  const toolFlowSequenceRef = useRef(0);\n  const logToolFlow = useCallback((event: string, details: Record<string, unknown> = {}) => {\n    const sequence = ++toolFlowSequenceRef.current;\n    const message = `[${sequence}] ${event}`;\n\n    if (isToolFlowTraceEnabled()) {\n      emitForcedToolFlowTrace(message, details);\n    }\n  }, []);\n\n  /**\n   * Fetches available resources from the MCP server.\n   * Only fetches if the server supports the resources capability.\n   */\n  const fetchResourcesInternal = useCallback(async () => {\n    if (!client) return;\n\n    const serverCapabilities = client.getServerCapabilities();\n    if (!serverCapabilities?.resources) {\n      setResources([]);\n      return;\n    }\n\n    try {\n      const response = await client.listResources();\n      setResources(response.resources);\n    } catch (e) {\n      console.error('[ReactWebMCP:McpClientProvider]', 'Error fetching resources:', e);\n      throw e;\n    }\n  }, [client]);\n\n  /**\n   * Fetches available tools from the MCP server.\n   * Only fetches if the server supports the tools capability.\n   */\n  const fetchToolsInternal = useCallback(async () => {\n    if (!client) return;\n\n    const serverCapabilities = client.getServerCapabilities();\n    if (!serverCapabilities?.tools) {\n      logToolFlow('listTools:capability_missing', {});\n      setTools([]);\n      return;\n    }\n\n    const startedAt = Date.now();\n    logToolFlow('listTools:start', {\n      hasToolsCapability: Boolean(serverCapabilities.tools),\n    });\n    try {\n      const response = await client.listTools();\n      setTools(response.tools);\n      logToolFlow('listTools:success', {\n        durationMs: Date.now() - startedAt,\n        toolCount: response.tools.length,\n      });\n    } catch (e) {\n      logToolFlow('listTools:error', {\n        durationMs: Date.now() - startedAt,\n        errorMessage: e instanceof Error ? e.message : String(e),\n      });\n      console.error('[ReactWebMCP:McpClientProvider]', 'Error fetching tools:', e);\n      throw e;\n    }\n  }, [client, logToolFlow]);\n\n  /**\n   * Establishes connection to the MCP server.\n   * Safe to call multiple times - will no-op if already connected or connecting.\n   */\n  const reconnect = useCallback(async () => {\n    if (!client || !transport) {\n      throw new Error('Client or transport not available');\n    }\n\n    if (connectionStateRef.current !== 'disconnected') {\n      return;\n    }\n\n    connectionStateRef.current = 'connecting';\n    setIsLoading(true);\n    setError(null);\n\n    try {\n      await client.connect(transport, requestOpts);\n      const caps = client.getServerCapabilities();\n      setIsConnected(true);\n      setCapabilities(caps || null);\n      connectionStateRef.current = 'connected';\n      logToolFlow('reconnect:connected', {\n        hasToolsListChanged: Boolean(caps?.tools?.listChanged),\n      });\n\n      await Promise.all([fetchResourcesInternal(), fetchToolsInternal()]);\n    } catch (e) {\n      const err = e instanceof Error ? e : new Error(String(e));\n      connectionStateRef.current = 'disconnected';\n      setError(err);\n      throw err;\n    } finally {\n      setIsLoading(false);\n    }\n  }, [client, transport, requestOpts, fetchResourcesInternal, fetchToolsInternal, logToolFlow]);\n\n  useEffect(() => {\n    if (!isConnected || !client) {\n      return;\n    }\n\n    const serverCapabilities = client.getServerCapabilities();\n\n    const handleResourcesChanged = () => {\n      fetchResourcesInternal().catch((error) => {\n        console.error(\n          '[ReactWebMCP:McpClientProvider]',\n          'Failed to refresh resources after list_changed:',\n          error\n        );\n      });\n    };\n\n    const handleToolsChanged = () => {\n      logToolFlow('notification:tools/list_changed', {});\n      fetchToolsInternal().catch((error) => {\n        console.error(\n          '[ReactWebMCP:McpClientProvider]',\n          'Failed to refresh tools after list_changed:',\n          error\n        );\n      });\n    };\n\n    if (serverCapabilities?.resources?.listChanged) {\n      client.setNotificationHandler(ResourceListChangedNotificationSchema, handleResourcesChanged);\n    }\n\n    if (serverCapabilities?.tools?.listChanged) {\n      client.setNotificationHandler(ToolListChangedNotificationSchema, handleToolsChanged);\n    }\n\n    // Re-fetch after setting up handlers to catch any changes that occurred\n    // during the gap between initial fetch and handler setup\n    Promise.all([fetchResourcesInternal(), fetchToolsInternal()]).catch((error) => {\n      console.error(\n        '[ReactWebMCP:McpClientProvider]',\n        'Failed to refresh tools/resources after handler registration:',\n        error\n      );\n    });\n\n    return () => {\n      if (serverCapabilities?.resources?.listChanged) {\n        client.removeNotificationHandler('notifications/resources/list_changed');\n      }\n\n      if (serverCapabilities?.tools?.listChanged) {\n        client.removeNotificationHandler('notifications/tools/list_changed');\n      }\n    };\n  }, [client, isConnected, fetchResourcesInternal, fetchToolsInternal, logToolFlow]);\n\n  // biome-ignore lint/correctness/useExhaustiveDependencies: intentional - reconnect when client/transport props change\n  useEffect(() => {\n    // Initial connection - reconnect() has its own guard to prevent concurrent connections\n    reconnect().catch((err) => {\n      console.error('[ReactWebMCP:McpClientProvider]', 'Failed to connect MCP client:', err);\n    });\n\n    // Cleanup: mark as disconnected so next mount will reconnect\n    return () => {\n      connectionStateRef.current = 'disconnected';\n      setIsConnected(false);\n    };\n  }, [client, transport, reconnect]);\n\n  return (\n    <McpClientContext.Provider\n      value={{\n        client,\n        tools,\n        resources,\n        isConnected,\n        isLoading,\n        error,\n        capabilities,\n        reconnect,\n      }}\n    >\n      {children}\n    </McpClientContext.Provider>\n  );\n}\n\n/**\n * Hook to access the MCP client context.\n * Must be used within an {@link McpClientProvider}.\n *\n * @returns The MCP client context including client instance, tools, resources, and connection state\n * @throws Error if used outside of McpClientProvider\n *\n * @public\n *\n * @example\n * ```tsx\n * function ToolsList() {\n *   const { tools, isConnected, error, reconnect } = useMcpClient();\n *\n *   if (error) {\n *     return (\n *       <div>\n *         Error: {error.message}\n *         <button onClick={reconnect}>Retry</button>\n *       </div>\n *     );\n *   }\n *\n *   if (!isConnected) {\n *     return <div>Not connected</div>;\n *   }\n *\n *   return (\n *     <ul>\n *       {tools.map(tool => (\n *         <li key={tool.name}>{tool.description}</li>\n *       ))}\n *     </ul>\n *   );\n * }\n * ```\n */\nexport function useMcpClient() {\n  const context = useContext(McpClientContext);\n  if (!context) {\n    throw new Error('useMcpClient must be used within an McpClientProvider');\n  }\n  return context;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["zodToJsonSchema","zodToJsonSchemaLib","zodToJsonSchema","zodToJsonSchema"],"sources":["../src/zod-utils.ts","../src/useWebMCP.ts","../src/useWebMCPContext.ts","../src/useWebMCPPrompt.ts","../src/useWebMCPResource.ts","../src/useElicitationHandler.ts","../src/useSamplingHandler.ts","../src/client/McpClientProvider.tsx"],"sourcesContent":["import type { InputSchema } from '@mcp-b/webmcp-types';\nimport type { z } from 'zod';\nimport { zodToJsonSchema as zodToJsonSchemaLib } from 'zod-to-json-schema';\n\nexport type ZodSchemaObject = Record<string, z.ZodTypeAny>;\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === 'object' && !Array.isArray(value);\n}\n\nfunction isZodLikeValue(value: unknown): boolean {\n  // `_def` is present on both zod/v3 and zod v4 schema instances.\n  // Restricting detection to `_def` avoids misclassifying non-Zod Standard Schema values.\n  return isRecord(value) && '_def' in value;\n}\n\ntype ZodDefinitionCarrier = {\n  _def: {\n    typeName: unknown;\n  };\n};\n\nfunction hasZodTypeName(schema: unknown): schema is ZodDefinitionCarrier {\n  if (!isRecord(schema)) {\n    return false;\n  }\n\n  const definition = schema._def;\n  return isRecord(definition) && 'typeName' in definition;\n}\n\nexport function isZodSchema(schema: unknown): schema is ZodSchemaObject {\n  if (!isRecord(schema)) return false;\n  const values = Object.values(schema);\n  if (values.length === 0) return false;\n  return values.some((value) => isZodLikeValue(value));\n}\n\nfunction isOptionalSchema(schema: unknown): boolean {\n  if (!hasZodTypeName(schema)) {\n    return false;\n  }\n\n  const { typeName } = schema._def;\n  return typeName === 'ZodOptional' || typeName === 'ZodDefault';\n}\n\nfunction stripSchemaMeta(schema: InputSchema): InputSchema {\n  const rest = { ...schema } as InputSchema & { $schema?: string };\n  delete rest.$schema;\n  if (rest.properties) {\n    const props: Record<string, InputSchema> = {};\n    for (const [k, v] of Object.entries(rest.properties)) {\n      props[k] = stripSchemaMeta(v as InputSchema);\n    }\n    rest.properties = props;\n  }\n  return rest;\n}\n\nexport function zodToJsonSchema(schema: ZodSchemaObject): InputSchema {\n  const properties: Record<string, InputSchema> = {};\n  const required: string[] = [];\n\n  for (const [key, rawValue] of Object.entries(schema)) {\n    if (!isZodLikeValue(rawValue)) {\n      continue;\n    }\n\n    const zodSchema = rawValue as z.ZodTypeAny;\n    const propSchema = zodToJsonSchemaLib(zodSchema, {\n      strictUnions: true,\n      $refStrategy: 'none',\n    });\n    properties[key] = stripSchemaMeta(propSchema as InputSchema);\n    if (!isOptionalSchema(zodSchema)) {\n      required.push(key);\n    }\n  }\n\n  const result: InputSchema = { type: 'object', properties };\n  if (required.length > 0) result.required = required;\n  return result;\n}\n","import type {\n  CallToolResult,\n  InputSchema,\n  JsonObject,\n  JsonSchemaForInference,\n  ToolDescriptor,\n} from '@mcp-b/webmcp-types';\nimport type { DependencyList } from 'react';\nimport { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';\nimport type {\n  InferOutput,\n  InferToolInput,\n  ReactWebMCPInputSchema,\n  ReactWebMCPOutputSchema,\n  ToolExecutionState,\n  WebMCPConfig,\n  WebMCPReturn,\n} from './types.js';\nimport { isZodSchema, zodToJsonSchema } from './zod-utils.js';\n\n/**\n * Default output formatter that converts values to formatted JSON strings.\n *\n * String values are returned as-is; all other types are serialized to\n * indented JSON for readability.\n *\n * @internal\n */\nfunction defaultFormatOutput(output: unknown): string {\n  if (typeof output === 'string') {\n    return output;\n  }\n  return JSON.stringify(output, null, 2);\n}\n\nconst TOOL_OWNER_BY_NAME = new Map<string, symbol>();\nconst DEFAULT_REGISTERED_INPUT_SCHEMA: InputSchema = { type: 'object', properties: {} };\nconst STANDARD_JSON_SCHEMA_TARGETS = ['draft-2020-12', 'draft-07'] as const;\ntype StructuredContent = Exclude<CallToolResult['structuredContent'], undefined>;\n\nfunction isObjectOutputSchema(schema: ReactWebMCPOutputSchema | undefined): boolean {\n  if (!schema) {\n    return false;\n  }\n\n  if (isZodSchema(schema)) {\n    return true;\n  }\n\n  return 'type' in schema && schema.type === 'object';\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nfunction isInputSchema(value: unknown): value is InputSchema {\n  if (!isPlainObject(value)) {\n    return false;\n  }\n\n  if ('type' in value && value.type !== undefined && typeof value.type !== 'string') {\n    return false;\n  }\n\n  if ('properties' in value && value.properties !== undefined && !isPlainObject(value.properties)) {\n    return false;\n  }\n\n  if (\n    'required' in value &&\n    value.required !== undefined &&\n    (!Array.isArray(value.required) || value.required.some((entry) => typeof entry !== 'string'))\n  ) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction isJsonSchemaForInference(value: unknown): value is JsonSchemaForInference {\n  if (!isPlainObject(value) || !('type' in value)) {\n    return false;\n  }\n\n  const schemaType = value.type;\n  if (typeof schemaType === 'string') {\n    if (\n      !['array', 'boolean', 'integer', 'null', 'number', 'object', 'string'].includes(schemaType)\n    ) {\n      return false;\n    }\n\n    if (schemaType === 'array') {\n      return 'items' in value && isJsonSchemaForInference(value.items);\n    }\n\n    if (schemaType === 'object' && 'properties' in value && value.properties !== undefined) {\n      return (\n        isPlainObject(value.properties) &&\n        Object.values(value.properties).every(isJsonSchemaForInference)\n      );\n    }\n\n    return true;\n  }\n\n  return (\n    Array.isArray(schemaType) &&\n    schemaType.length > 0 &&\n    schemaType.every((entry) =>\n      ['array', 'boolean', 'integer', 'null', 'number', 'object', 'string'].includes(entry)\n    )\n  );\n}\n\nfunction isJsonValue(value: unknown): boolean {\n  if (value === null) {\n    return true;\n  }\n\n  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {\n    return true;\n  }\n\n  if (Array.isArray(value)) {\n    return value.every(isJsonValue);\n  }\n\n  if (typeof value !== 'object') {\n    return false;\n  }\n\n  return Object.values(value).every(isJsonValue);\n}\n\nfunction isJsonObject(value: unknown): value is JsonObject {\n  return typeof value === 'object' && value !== null && !Array.isArray(value) && isJsonValue(value);\n}\n\nfunction toStructuredContent(value: unknown): StructuredContent | null {\n  if (!value || typeof value !== 'object' || Array.isArray(value)) {\n    return null;\n  }\n\n  try {\n    const normalized = JSON.parse(JSON.stringify(value));\n    return isJsonObject(normalized) ? normalized : null;\n  } catch {\n    return null;\n  }\n}\n\nconst useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;\n\n/**\n * On Chrome Beta 147 native (which ignores the second arg), aborting\n * the controller cannot remove the tool. Install `@mcp-b/global`\n * or `@mcp-b/webmcp-polyfill` there.\n */\nfunction registerToolWithCleanup(\n  modelContext: Navigator['modelContext'],\n  toolDescriptor: ToolDescriptor\n): AbortController {\n  const controller = new AbortController();\n  (\n    modelContext.registerTool as (tool: ToolDescriptor, options?: { signal?: AbortSignal }) => void\n  ).call(modelContext, toolDescriptor, { signal: controller.signal });\n  return controller;\n}\n\nfunction toRegisteredInputSchema(\n  schema: ReactWebMCPInputSchema | undefined\n): InputSchema | undefined {\n  if (!schema) {\n    return undefined;\n  }\n\n  if (isZodSchema(schema)) {\n    return zodToJsonSchema(schema);\n  }\n\n  if (!isPlainObject(schema) || !('~standard' in schema)) {\n    return isInputSchema(schema) ? schema : DEFAULT_REGISTERED_INPUT_SCHEMA;\n  }\n\n  const standard = schema['~standard'];\n  if (!isPlainObject(standard)) {\n    return DEFAULT_REGISTERED_INPUT_SCHEMA;\n  }\n\n  const jsonSchema = standard.jsonSchema;\n  if (!isPlainObject(jsonSchema) || typeof jsonSchema.input !== 'function') {\n    return DEFAULT_REGISTERED_INPUT_SCHEMA;\n  }\n\n  for (const target of STANDARD_JSON_SCHEMA_TARGETS) {\n    try {\n      const converted = jsonSchema.input({ target });\n      if (isInputSchema(converted)) {\n        return converted;\n      }\n    } catch {\n      // Try the next target before falling back to the default registration schema.\n    }\n  }\n\n  return DEFAULT_REGISTERED_INPUT_SCHEMA;\n}\n\nfunction toRegisteredOutputSchema(\n  schema: ReactWebMCPOutputSchema | undefined\n): JsonSchemaForInference | undefined {\n  if (!schema) {\n    return undefined;\n  }\n\n  const jsonSchema = isZodSchema(schema) ? zodToJsonSchema(schema) : schema;\n  return isJsonSchemaForInference(jsonSchema) ? jsonSchema : undefined;\n}\n\n/**\n * React hook for registering and managing Model Context Protocol (MCP) tools.\n *\n * This hook handles the complete lifecycle of an MCP tool:\n * - Registers the tool with `window.navigator.modelContext`\n * - Manages execution state (loading, results, errors)\n * - Handles tool execution and lifecycle callbacks\n * - Automatically unregisters on component unmount\n * - Returns `structuredContent` when `outputSchema` is defined\n *\n * ## Output Schema (Recommended)\n *\n * Always define an `outputSchema` for your tools. This provides:\n * - **Type Safety**: Handler return type is inferred from the schema\n * - **MCP structuredContent**: AI models receive structured, typed data\n * - **Better AI Understanding**: Models can reason about your tool's output format\n *\n * ```tsx\n * useWebMCP({\n *   name: 'get_user',\n *   description: 'Get user by ID',\n *   inputSchema: {\n *     type: 'object',\n *     properties: { userId: { type: 'string' } },\n *     required: ['userId'],\n *   } as const,\n *   outputSchema: {\n *     type: 'object',\n *     properties: {\n *       id: { type: 'string' },\n *       name: { type: 'string' },\n *       email: { type: 'string' },\n *     },\n *   } as const,\n *   handler: async ({ userId }) => {\n *     const user = await fetchUser(userId);\n *     return { id: user.id, name: user.name, email: user.email };\n *   },\n * });\n * ```\n *\n * @template TInputSchema - JSON Schema defining input parameter types (use `as const` for inference)\n * @template TOutputSchema - JSON Schema defining output structure (object schemas enable structuredContent)\n *\n * @param config - Configuration object for the tool\n * @param deps - Optional dependency array that triggers tool re-registration when values change.\n *\n * @returns Object containing execution state and control methods\n *\n * @public\n */\nexport function useWebMCP<\n  TInputSchema extends ReactWebMCPInputSchema = InputSchema,\n  TOutputSchema extends ReactWebMCPOutputSchema | undefined = undefined,\n>(\n  config: WebMCPConfig<TInputSchema, TOutputSchema>,\n  deps?: DependencyList\n): WebMCPReturn<TOutputSchema, TInputSchema> {\n  type TOutput = InferOutput<TOutputSchema>;\n  type TInput = InferToolInput<TInputSchema>;\n  const {\n    name,\n    description,\n    inputSchema,\n    outputSchema,\n    annotations,\n    handler,\n    formatOutput = defaultFormatOutput,\n    onSuccess,\n    onError,\n  } = config;\n\n  const [state, setState] = useState<ToolExecutionState<TOutput>>({\n    isExecuting: false,\n    lastResult: null,\n    error: null,\n    executionCount: 0,\n  });\n\n  const handlerRef = useRef(handler);\n  const onSuccessRef = useRef(onSuccess);\n  const onErrorRef = useRef(onError);\n  const formatOutputRef = useRef(formatOutput);\n  const isMountedRef = useRef(true);\n  // Update refs when callbacks change (doesn't trigger re-registration)\n  useIsomorphicLayoutEffect(() => {\n    handlerRef.current = handler;\n    onSuccessRef.current = onSuccess;\n    onErrorRef.current = onError;\n    formatOutputRef.current = formatOutput;\n  }, [handler, onSuccess, onError, formatOutput]);\n\n  // Cleanup: mark component as unmounted\n  useEffect(() => {\n    isMountedRef.current = true;\n    return () => {\n      isMountedRef.current = false;\n    };\n  }, []);\n\n  /**\n   * Executes the tool handler with input validation and state management.\n   *\n   * @param input - The input parameters to validate and pass to the handler\n   * @returns Promise resolving to the handler's output\n   * @throws Error if validation fails or the handler throws\n   */\n  const execute = useCallback(async (input: TInput): Promise<TOutput> => {\n    setState((prev) => ({\n      ...prev,\n      isExecuting: true,\n      error: null,\n    }));\n\n    try {\n      const result = await handlerRef.current(input);\n\n      // Only update state if component is still mounted\n      if (isMountedRef.current) {\n        setState((prev) => ({\n          isExecuting: false,\n          lastResult: result,\n          error: null,\n          executionCount: prev.executionCount + 1,\n        }));\n      }\n\n      if (onSuccessRef.current) {\n        onSuccessRef.current(result, input);\n      }\n\n      return result;\n    } catch (error) {\n      const err = error instanceof Error ? error : new Error(String(error));\n\n      // Only update state if component is still mounted\n      if (isMountedRef.current) {\n        setState((prev) => ({\n          ...prev,\n          isExecuting: false,\n          error: err,\n        }));\n      }\n\n      if (onErrorRef.current) {\n        onErrorRef.current(err, input);\n      }\n\n      throw err;\n    }\n  }, []);\n  const executeRef = useRef(execute);\n\n  useEffect(() => {\n    executeRef.current = execute;\n  }, [execute]);\n\n  const stableExecute = useCallback(\n    (input: TInput): Promise<TOutput> => executeRef.current(input),\n    []\n  );\n\n  /**\n   * Resets the execution state to initial values.\n   */\n  const reset = useCallback(() => {\n    setState({\n      isExecuting: false,\n      lastResult: null,\n      error: null,\n      executionCount: 0,\n    });\n  }, []);\n\n  useEffect(() => {\n    if (typeof window === 'undefined' || !window.navigator?.modelContext) {\n      console.warn(\n        '[ReactWebMCP:useWebMCP]',\n        `Tool \"${name}\" skipped: modelContext is not available`\n      );\n      return;\n    }\n    const modelContext = window.navigator.modelContext;\n\n    /**\n     * Handles MCP tool execution by running the handler and formatting the response.\n     *\n     * @param input - The input parameters from the MCP client\n     * @returns CallToolResult with text content and optional structuredContent\n     */\n    const mcpHandler = async (input: unknown): Promise<CallToolResult> => {\n      try {\n        const result = await Reflect.apply(executeRef.current, undefined, [input]);\n        const formattedOutput = formatOutputRef.current(result);\n\n        const response: CallToolResult = {\n          content: [\n            {\n              type: 'text',\n              text: formattedOutput,\n            },\n          ],\n        };\n\n        if (isObjectOutputSchema(outputSchema)) {\n          const structuredContent = toStructuredContent(result);\n          if (!structuredContent) {\n            throw new Error(\n              `Tool \"${name}\" outputSchema requires the handler to return a JSON object result`\n            );\n          }\n          response.structuredContent = structuredContent;\n        }\n\n        return response;\n      } catch (error) {\n        const errorMessage = error instanceof Error ? error.message : String(error);\n\n        return {\n          content: [\n            {\n              type: 'text',\n              text: `Error: ${errorMessage}`,\n            },\n          ],\n          isError: true,\n        };\n      }\n    };\n\n    const resolvedInputSchema = toRegisteredInputSchema(inputSchema);\n    const resolvedOutputSchema = toRegisteredOutputSchema(outputSchema);\n\n    const ownerToken = Symbol(name);\n    const toolDescriptor: ToolDescriptor = {\n      name,\n      description,\n      ...(resolvedInputSchema && { inputSchema: resolvedInputSchema }),\n      ...(resolvedOutputSchema && { outputSchema: resolvedOutputSchema }),\n      ...(annotations && { annotations }),\n      execute: mcpHandler,\n    };\n    const controller = registerToolWithCleanup(modelContext, toolDescriptor);\n    TOOL_OWNER_BY_NAME.set(name, ownerToken);\n\n    return () => {\n      const currentOwner = TOOL_OWNER_BY_NAME.get(name);\n      if (currentOwner !== ownerToken) {\n        return;\n      }\n\n      TOOL_OWNER_BY_NAME.delete(name);\n      controller.abort();\n    };\n    // Spread operator in dependencies intentionally allows consumers to trigger\n    // re-registration with custom reactive inputs.\n  }, [name, description, inputSchema, outputSchema, annotations, ...(deps ?? [])]);\n\n  return {\n    state,\n    execute: stableExecute,\n    reset,\n  };\n}\n","import { useMemo, useRef } from 'react';\nimport type { WebMCPReturn } from './types.js';\nimport { useWebMCP } from './useWebMCP.js';\n\n/**\n * Convenience hook for exposing read-only context data to AI assistants.\n *\n * This is a simplified wrapper around {@link useWebMCP} specifically designed for\n * context tools that expose data without performing actions. The hook automatically\n * configures appropriate annotations (read-only, idempotent) and handles value\n * serialization.\n *\n * Note: This hook does not use an output schema, so the result will not include\n * `structuredContent` in the MCP response. Use {@link useWebMCP} directly with\n * `outputSchema` if you need structured output for MCP compliance.\n *\n * @template T - The type of context data to expose\n *\n * @param name - Unique identifier for the context tool (e.g., 'context_current_post')\n * @param description - Human-readable description of the context for AI assistants\n * @param getValue - Function that returns the current context value\n * @returns Tool execution state and control methods\n *\n * @public\n *\n * @example\n * Expose current post context:\n * ```tsx\n * function PostDetailPage() {\n *   const { postId } = useParams();\n *   const { data: post } = useQuery(['post', postId], () => fetchPost(postId));\n *\n *   useWebMCPContext(\n *     'context_current_post',\n *     'Get the currently viewed post ID and metadata',\n *     () => ({\n *       postId,\n *       title: post?.title,\n *       author: post?.author,\n *       tags: post?.tags,\n *       createdAt: post?.createdAt,\n *     })\n *   );\n *\n *   return <PostContent post={post} />;\n * }\n * ```\n *\n * @example\n * Expose user session context:\n * ```tsx\n * function AppRoot() {\n *   const { user, isAuthenticated } = useAuth();\n *\n *   useWebMCPContext(\n *     'context_user_session',\n *     'Get the current user session information',\n *     () => ({\n *       isAuthenticated,\n *       userId: user?.id,\n *       email: user?.email,\n *       permissions: user?.permissions,\n *     })\n *   );\n *\n *   return <App />;\n * }\n * ```\n */\nexport function useWebMCPContext<T>(\n  name: string,\n  description: string,\n  getValue: () => T\n): WebMCPReturn {\n  const getValueRef = useRef(getValue);\n  getValueRef.current = getValue;\n  const annotations = useMemo(\n    () => ({\n      title: `Context: ${name}`,\n      readOnlyHint: true,\n      idempotentHint: true,\n      destructiveHint: false,\n      openWorldHint: false,\n    }),\n    [name]\n  );\n\n  // Use default generics (no input/output schema) since context tools\n  // don't define structured schemas. The handler returns T but it's\n  // treated as `unknown` in the return type since no outputSchema is defined.\n  return useWebMCP({\n    name,\n    description,\n    annotations,\n    // Cast to unknown since context tools return arbitrary types\n    // that don't need to conform to a specific schema\n    handler: async (_input: Record<string, unknown>) => {\n      return getValueRef.current() as Record<string, unknown>;\n    },\n    formatOutput: (output) => {\n      if (typeof output === 'string') {\n        return output as string;\n      }\n      return JSON.stringify(output, null, 2);\n    },\n  });\n}\n","import type { InputSchema } from '@mcp-b/webmcp-types';\nimport { useEffect, useRef, useState } from 'react';\nimport type {\n  PromptMessage,\n  ReactWebMCPInputSchema,\n  WebMCPPromptConfig,\n  WebMCPPromptReturn,\n} from './types.js';\nimport { isZodSchema, zodToJsonSchema } from './zod-utils.js';\n\ntype PromptModelContext = Navigator['modelContext'] & {\n  registerPrompt: (descriptor: {\n    name: string;\n    description?: string;\n    argsSchema?: InputSchema;\n    get: (args: Record<string, unknown>) => Promise<{ messages: PromptMessage[] }>;\n  }) => { unregister: () => void } | undefined;\n};\n\n/**\n * React hook for registering Model Context Protocol (MCP) prompts.\n *\n * This hook handles the complete lifecycle of an MCP prompt:\n * - Registers the prompt with `window.navigator.modelContext`\n * - Converts Zod schemas to JSON Schema for argument validation\n * - Automatically unregisters on component unmount\n *\n * @template TArgsSchema - Zod schema object defining argument types\n *\n * @param config - Configuration object for the prompt\n * @returns Object indicating registration status\n *\n * @public\n *\n * @example\n * Simple prompt without arguments:\n * ```tsx\n * function HelpPrompt() {\n *   const { isRegistered } = useWebMCPPrompt({\n *     name: 'help',\n *     description: 'Get help with using the application',\n *     get: async () => ({\n *       messages: [{\n *         role: 'user',\n *         content: { type: 'text', text: 'How do I use this application?' }\n *       }]\n *     }),\n *   });\n *\n *   return <div>Help prompt {isRegistered ? 'ready' : 'loading'}</div>;\n * }\n * ```\n *\n * @example\n * Prompt with typed arguments:\n * ```tsx\n * function CodeReviewPrompt() {\n *   const { isRegistered } = useWebMCPPrompt({\n *     name: 'review_code',\n *     description: 'Review code for best practices',\n *     argsSchema: {\n *       type: 'object',\n *       properties: {\n *         code: { type: 'string', description: 'The code to review' },\n *         language: { type: 'string', description: 'Programming language' },\n *       },\n *       required: ['code'],\n *     } as const,\n *     get: async ({ code, language }) => ({\n *       messages: [{\n *         role: 'user',\n *         content: {\n *           type: 'text',\n *           text: `Please review this ${language ?? ''} code:\\n\\n${code}`\n *         }\n *       }]\n *     }),\n *   });\n *\n *   return <div>Code review prompt {isRegistered ? 'ready' : 'loading'}</div>;\n * }\n * ```\n */\nexport function useWebMCPPrompt<TArgsSchema extends ReactWebMCPInputSchema = InputSchema>(\n  config: WebMCPPromptConfig<TArgsSchema>\n): WebMCPPromptReturn {\n  const { name, description, argsSchema, get } = config;\n\n  const [isRegistered, setIsRegistered] = useState(false);\n\n  const getRef = useRef(get);\n\n  useEffect(() => {\n    getRef.current = get;\n  }, [get]);\n\n  useEffect(() => {\n    if (typeof window === 'undefined' || !window.navigator?.modelContext) {\n      console.warn(\n        `[ReactWebMCP] window.navigator.modelContext is not available. Prompt \"${name}\" will not be registered.`\n      );\n      return;\n    }\n    const modelContext = window.navigator.modelContext as PromptModelContext;\n\n    const promptHandler = async (\n      args: Record<string, unknown>\n    ): Promise<{ messages: PromptMessage[] }> => {\n      return getRef.current(args as never);\n    };\n\n    const resolvedArgsSchema = argsSchema\n      ? isZodSchema(argsSchema)\n        ? zodToJsonSchema(argsSchema)\n        : (argsSchema as InputSchema)\n      : undefined;\n\n    let registration: { unregister: () => void } | undefined;\n    try {\n      registration = modelContext.registerPrompt({\n        name,\n        ...(description !== undefined && { description }),\n        ...(resolvedArgsSchema && { argsSchema: resolvedArgsSchema }),\n        get: promptHandler,\n      });\n    } catch (error) {\n      setIsRegistered(false);\n      throw error;\n    }\n\n    if (!registration) {\n      console.warn(`[ReactWebMCP] Prompt \"${name}\" did not return a registration handle.`);\n      setIsRegistered(false);\n      return;\n    }\n\n    setIsRegistered(true);\n\n    return () => {\n      registration.unregister();\n      setIsRegistered(false);\n    };\n  }, [name, description, argsSchema]);\n\n  return {\n    isRegistered,\n  };\n}\n","import { useEffect, useRef, useState } from 'react';\nimport type { ResourceContents, WebMCPResourceConfig, WebMCPResourceReturn } from './types.js';\n\ntype ResourceModelContext = Navigator['modelContext'] & {\n  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 } | undefined;\n};\n\n/**\n * React hook for registering Model Context Protocol (MCP) resources.\n *\n * This hook handles the complete lifecycle of an MCP resource:\n * - Registers the resource with `window.navigator.modelContext`\n * - Supports both static URIs and URI templates with parameters\n * - Automatically unregisters on component unmount\n *\n * @param config - Configuration object for the resource\n * @returns Object indicating registration status\n *\n * @public\n *\n * @example\n * Static resource:\n * ```tsx\n * function AppSettingsResource() {\n *   const { isRegistered } = useWebMCPResource({\n *     uri: 'config://app-settings',\n *     name: 'App Settings',\n *     description: 'Application configuration',\n *     mimeType: 'application/json',\n *     read: async (uri) => ({\n *       contents: [{\n *         uri: uri.href,\n *         text: JSON.stringify({ theme: 'dark', language: 'en' })\n *       }]\n *     }),\n *   });\n *\n *   return <div>Settings resource {isRegistered ? 'ready' : 'loading'}</div>;\n * }\n * ```\n *\n * @example\n * Dynamic resource with URI template:\n * ```tsx\n * function UserProfileResource() {\n *   const { isRegistered } = useWebMCPResource({\n *     uri: 'user://{userId}/profile',\n *     name: 'User Profile',\n *     description: 'User profile data by ID',\n *     mimeType: 'application/json',\n *     read: async (uri, params) => {\n *       const userId = params?.userId ?? '';\n *       const profile = await fetchUserProfile(userId);\n *       return {\n *         contents: [{\n *           uri: uri.href,\n *           text: JSON.stringify(profile)\n *         }]\n *       };\n *     },\n *   });\n *\n *   return <div>User profile resource {isRegistered ? 'ready' : 'loading'}</div>;\n * }\n * ```\n */\nexport function useWebMCPResource(config: WebMCPResourceConfig): WebMCPResourceReturn {\n  const { uri, name, description, mimeType, read } = config;\n\n  const [isRegistered, setIsRegistered] = useState(false);\n\n  const readRef = useRef(read);\n\n  useEffect(() => {\n    readRef.current = read;\n  }, [read]);\n\n  useEffect(() => {\n    if (typeof window === 'undefined' || !window.navigator?.modelContext) {\n      console.warn(\n        `[ReactWebMCP] window.navigator.modelContext is not available. Resource \"${uri}\" will not be registered.`\n      );\n      return;\n    }\n    const modelContext = window.navigator.modelContext as ResourceModelContext;\n\n    const resourceHandler = async (\n      resolvedUri: URL,\n      params?: Record<string, string>\n    ): Promise<{ contents: ResourceContents[] }> => {\n      return readRef.current(resolvedUri, params);\n    };\n\n    let registration: { unregister: () => void } | undefined;\n    try {\n      registration = modelContext.registerResource({\n        uri,\n        name,\n        ...(description !== undefined && { description }),\n        ...(mimeType !== undefined && { mimeType }),\n        read: resourceHandler,\n      });\n    } catch (error) {\n      setIsRegistered(false);\n      throw error;\n    }\n\n    if (!registration) {\n      console.warn(`[ReactWebMCP] Resource \"${uri}\" did not return a registration handle.`);\n      setIsRegistered(false);\n      return;\n    }\n\n    setIsRegistered(true);\n\n    return () => {\n      registration.unregister();\n      setIsRegistered(false);\n    };\n  }, [uri, name, description, mimeType]);\n\n  return {\n    isRegistered,\n  };\n}\n","import type { ElicitationParams, ElicitationResult } from '@mcp-b/webmcp-types';\nimport { useCallback, useState } from 'react';\n\ntype ElicitationModelContext = Navigator['modelContext'] & {\n  elicitInput: (params: ElicitationParams) => Promise<ElicitationResult>;\n};\n\n/**\n * State for elicitation requests, tracking the current request and results.\n */\nexport interface ElicitationState {\n  /** Whether an elicitation request is currently in progress */\n  isLoading: boolean;\n  /** The last elicitation result received */\n  result: ElicitationResult | null;\n  /** Any error that occurred during the last request */\n  error: Error | null;\n  /** Total number of requests made */\n  requestCount: number;\n}\n\n/**\n * Configuration options for the useElicitation hook.\n */\nexport interface UseElicitationConfig {\n  /**\n   * Optional callback invoked when an elicitation request completes successfully.\n   */\n  onSuccess?: (result: ElicitationResult) => void;\n\n  /**\n   * Optional callback invoked when an elicitation request fails.\n   */\n  onError?: (error: Error) => void;\n}\n\n/**\n * Return value from the useElicitation hook.\n */\nexport interface UseElicitationReturn {\n  /** Current state of elicitation */\n  state: ElicitationState;\n  /** Function to request user input from the connected client */\n  elicitInput: (params: ElicitationParams) => Promise<ElicitationResult>;\n  /** Reset the state */\n  reset: () => void;\n}\n\n/**\n * React hook for requesting user input from the connected MCP client.\n *\n * Elicitation allows the server (webpage) to request user input from the\n * connected client. This is useful when the page needs additional information\n * from the user, such as API keys, configuration options, or confirmations.\n *\n * There are two modes:\n * 1. **Form mode**: For non-sensitive data collection using a schema-driven form.\n * 2. **URL mode**: For sensitive data collection via a web URL (API keys, OAuth, etc.).\n *\n * @param config - Optional configuration including callbacks\n * @returns Object containing state and the elicitInput function\n *\n * @example Form elicitation:\n * ```tsx\n * function ConfigForm() {\n *   const { state, elicitInput } = useElicitation({\n *     onSuccess: (result) => console.log('Got input:', result),\n *     onError: (error) => console.error('Elicitation failed:', error),\n *   });\n *\n *   const handleConfigure = async () => {\n *     const result = await elicitInput({\n *       message: 'Please provide your configuration',\n *       requestedSchema: {\n *         type: 'object',\n *         properties: {\n *           apiKey: { type: 'string', title: 'API Key', description: 'Your API key' },\n *           model: { type: 'string', enum: ['gpt-4', 'gpt-3.5'], title: 'Model' }\n *         },\n *         required: ['apiKey']\n *       }\n *     });\n *\n *     if (result.action === 'accept') {\n *       console.log('Config:', result.content);\n *     }\n *   };\n *\n *   return (\n *     <button onClick={handleConfigure} disabled={state.isLoading}>\n *       Configure\n *     </button>\n *   );\n * }\n * ```\n *\n * @example URL elicitation (for sensitive data):\n * ```tsx\n * const { elicitInput } = useElicitation();\n *\n * const handleOAuth = async () => {\n *   const result = await elicitInput({\n *     mode: 'url',\n *     message: 'Please authenticate with GitHub',\n *     elicitationId: 'github-oauth-123',\n *     url: 'https://github.com/login/oauth/authorize?client_id=...'\n *   });\n *\n *   if (result.action === 'accept') {\n *     console.log('OAuth completed');\n *   }\n * };\n * ```\n */\nexport function useElicitation(config: UseElicitationConfig = {}): UseElicitationReturn {\n  const { onSuccess, onError } = config;\n\n  const [state, setState] = useState<ElicitationState>({\n    isLoading: false,\n    result: null,\n    error: null,\n    requestCount: 0,\n  });\n\n  const reset = useCallback(() => {\n    setState({\n      isLoading: false,\n      result: null,\n      error: null,\n      requestCount: 0,\n    });\n  }, []);\n\n  const elicitInput = useCallback(\n    async (params: ElicitationParams): Promise<ElicitationResult> => {\n      if (typeof window === 'undefined' || !window.navigator?.modelContext) {\n        throw new Error('navigator.modelContext is not available');\n      }\n      const mc = window.navigator.modelContext as ElicitationModelContext;\n\n      setState((prev) => ({\n        ...prev,\n        isLoading: true,\n        error: null,\n      }));\n\n      try {\n        const result: ElicitationResult = await mc.elicitInput(params);\n\n        setState((prev) => ({\n          isLoading: false,\n          result,\n          error: null,\n          requestCount: prev.requestCount + 1,\n        }));\n\n        onSuccess?.(result);\n        return result;\n      } catch (err) {\n        const error = err instanceof Error ? err : new Error(String(err));\n\n        setState((prev) => ({\n          ...prev,\n          isLoading: false,\n          error,\n        }));\n\n        onError?.(error);\n        throw error;\n      }\n    },\n    [onSuccess, onError]\n  );\n\n  return {\n    state,\n    elicitInput,\n    reset,\n  };\n}\n\n// Also export with the old name for backwards compatibility during migration\nexport { useElicitation as useElicitationHandler };\nexport type { ElicitationState as ElicitationHandlerState };\nexport type { UseElicitationConfig as UseElicitationHandlerConfig };\nexport type { UseElicitationReturn as UseElicitationHandlerReturn };\n","import type { SamplingRequestParams, SamplingResult } from '@mcp-b/webmcp-ts-sdk';\nimport { useCallback, useState } from 'react';\n\ntype SamplingModelContext = Navigator['modelContext'] & {\n  createMessage: (params: SamplingRequestParams) => Promise<SamplingResult>;\n};\n\n/**\n * State for sampling requests, tracking the current request and results.\n */\nexport interface SamplingState {\n  /** Whether a sampling request is currently in progress */\n  isLoading: boolean;\n  /** The last sampling result received */\n  result: SamplingResult | null;\n  /** Any error that occurred during the last request */\n  error: Error | null;\n  /** Total number of requests made */\n  requestCount: number;\n}\n\n/**\n * Configuration options for the useSampling hook.\n */\nexport interface UseSamplingConfig {\n  /**\n   * Optional callback invoked when a sampling request completes successfully.\n   */\n  onSuccess?: (result: SamplingResult) => void;\n\n  /**\n   * Optional callback invoked when a sampling request fails.\n   */\n  onError?: (error: Error) => void;\n}\n\n/**\n * Return value from the useSampling hook.\n */\nexport interface UseSamplingReturn {\n  /** Current state of sampling */\n  state: SamplingState;\n  /** Function to request LLM completion from the connected client */\n  createMessage: (params: SamplingRequestParams) => Promise<SamplingResult>;\n  /** Reset the state */\n  reset: () => void;\n}\n\n/**\n * React hook for requesting LLM completions from the connected MCP client.\n *\n * Sampling allows the server (webpage) to request LLM completions from the\n * connected client. This is useful when the page needs AI capabilities like\n * summarization, generation, or analysis.\n *\n * @param config - Optional configuration including callbacks\n * @returns Object containing state and the createMessage function\n *\n * @example Basic usage:\n * ```tsx\n * function AIAssistant() {\n *   const { state, createMessage } = useSampling({\n *     onSuccess: (result) => console.log('Got response:', result),\n *     onError: (error) => console.error('Sampling failed:', error),\n *   });\n *\n *   const handleAsk = async () => {\n *     const result = await createMessage({\n *       messages: [\n *         { role: 'user', content: { type: 'text', text: 'What is 2+2?' } }\n *       ],\n *       maxTokens: 100,\n *     });\n *     console.log(result.content);\n *   };\n *\n *   return (\n *     <div>\n *       <button onClick={handleAsk} disabled={state.isLoading}>\n *         Ask AI\n *       </button>\n *       {state.result && <p>{JSON.stringify(state.result.content)}</p>}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useSampling(config: UseSamplingConfig = {}): UseSamplingReturn {\n  const { onSuccess, onError } = config;\n\n  const [state, setState] = useState<SamplingState>({\n    isLoading: false,\n    result: null,\n    error: null,\n    requestCount: 0,\n  });\n\n  const reset = useCallback(() => {\n    setState({\n      isLoading: false,\n      result: null,\n      error: null,\n      requestCount: 0,\n    });\n  }, []);\n\n  const createMessage = useCallback(\n    async (params: SamplingRequestParams): Promise<SamplingResult> => {\n      if (typeof window === 'undefined' || !window.navigator?.modelContext) {\n        throw new Error('navigator.modelContext is not available');\n      }\n      const modelContext = window.navigator.modelContext as SamplingModelContext;\n\n      setState((prev) => ({\n        ...prev,\n        isLoading: true,\n        error: null,\n      }));\n\n      try {\n        const result = await modelContext.createMessage(params);\n\n        setState((prev) => ({\n          isLoading: false,\n          result,\n          error: null,\n          requestCount: prev.requestCount + 1,\n        }));\n\n        onSuccess?.(result);\n        return result;\n      } catch (err) {\n        const error = err instanceof Error ? err : new Error(String(err));\n\n        setState((prev) => ({\n          ...prev,\n          isLoading: false,\n          error,\n        }));\n\n        onError?.(error);\n        throw error;\n      }\n    },\n    [onSuccess, onError]\n  );\n\n  return {\n    state,\n    createMessage,\n    reset,\n  };\n}\n\n// Also export with the old name for backwards compatibility during migration\nexport { useSampling as useSamplingHandler };\nexport type { SamplingState as SamplingHandlerState };\nexport type { UseSamplingConfig as UseSamplingHandlerConfig };\nexport type { UseSamplingReturn as UseSamplingHandlerReturn };\n","import {\n  type Client,\n  type Tool as McpTool,\n  type RequestOptions,\n  type Resource,\n  ResourceListChangedNotificationSchema,\n  type ServerCapabilities,\n  ToolListChangedNotificationSchema,\n  type Transport,\n} from '@mcp-b/webmcp-ts-sdk';\nimport {\n  createContext,\n  type ReactElement,\n  type ReactNode,\n  useCallback,\n  useContext,\n  useEffect,\n  useRef,\n  useState,\n} from 'react';\n\n/**\n * Context value provided by McpClientProvider.\n *\n * @internal\n */\ninterface McpClientContextValue {\n  client: Client;\n  tools: McpTool[];\n  resources: Resource[];\n  isConnected: boolean;\n  isLoading: boolean;\n  error: Error | null;\n  capabilities: ServerCapabilities | null;\n  reconnect: () => Promise<void>;\n}\n\nconst McpClientContext = createContext<McpClientContextValue | null>(null);\nconst EMPTY_REQUEST_OPTS: RequestOptions = {};\nconst TOOL_FLOW_TRACE_KEY = 'WEBMCP_TRACE_TOOL_FLOW';\n\nfunction emitForcedToolFlowTrace(event: string, details: Record<string, unknown>): void {\n  const consoleRef = globalThis.console;\n  if (!consoleRef) {\n    return;\n  }\n\n  const method = consoleRef.debug ?? consoleRef.log;\n  if (typeof method !== 'function') {\n    return;\n  }\n\n  method.call(consoleRef, '[ReactWebMCP:McpClientProvider:ToolFlow]', event, details);\n}\n\nfunction isToolFlowTraceEnabled(): boolean {\n  if (typeof window === 'undefined') {\n    return false;\n  }\n\n  try {\n    return window.localStorage.getItem(TOOL_FLOW_TRACE_KEY) === '1';\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Props for the McpClientProvider component.\n *\n * @public\n */\nexport interface McpClientProviderProps {\n  /**\n   * React children to render within the provider.\n   */\n  children: ReactNode;\n\n  /**\n   * MCP Client instance to use for communication.\n   */\n  client: Client;\n\n  /**\n   * Transport instance for the client to connect through.\n   */\n  transport: Transport;\n\n  /**\n   * Optional request options for the connection.\n   */\n  opts?: RequestOptions;\n}\n\n/**\n * Provider component that manages an MCP client connection and exposes\n * tools, resources, and connection state to child components.\n *\n * This provider handles:\n * - Establishing and maintaining the MCP client connection\n * - Fetching available tools and resources from the server\n * - Listening for server notifications about tool/resource changes\n * - Managing connection state and errors\n * - Automatic cleanup on unmount\n *\n * @param props - Component props\n * @returns Provider component wrapping children\n *\n * @public\n *\n * @example\n * Connect to an MCP server via tab transport:\n * ```tsx\n * import { Client } from '@modelcontextprotocol/sdk/client/index.js';\n * import { TabClientTransport } from '@mcp-b/transports';\n * import { McpClientProvider } from '@mcp-b/react-webmcp';\n *\n * const client = new Client(\n *   { name: 'my-app', version: '1.0.0' },\n *   { capabilities: {} }\n * );\n *\n * const transport = new TabClientTransport('mcp', {\n *   clientInstanceId: 'my-app-instance',\n * });\n *\n * function App() {\n *   return (\n *     <McpClientProvider client={client} transport={transport}>\n *       <MyAppContent />\n *     </McpClientProvider>\n *   );\n * }\n * ```\n *\n * @example\n * Access tools from child components:\n * ```tsx\n * function MyAppContent() {\n *   const { tools, isConnected, isLoading } = useMcpClient();\n *\n *   if (isLoading) {\n *     return <div>Connecting to MCP server...</div>;\n *   }\n *\n *   if (!isConnected) {\n *     return <div>Failed to connect to MCP server</div>;\n *   }\n *\n *   return (\n *     <div>\n *       <h2>Available Tools:</h2>\n *       <ul>\n *         {tools.map(tool => (\n *           <li key={tool.name}>{tool.description}</li>\n *         ))}\n *       </ul>\n *     </div>\n *   );\n * }\n * ```\n */\nexport function McpClientProvider({\n  children,\n  client,\n  transport,\n  opts,\n}: McpClientProviderProps): ReactElement {\n  const [resources, setResources] = useState<Resource[]>([]);\n  const [tools, setTools] = useState<McpTool[]>([]);\n  const [isLoading, setIsLoading] = useState<boolean>(false);\n  const [error, setError] = useState<Error | null>(null);\n  const [isConnected, setIsConnected] = useState<boolean>(false);\n  const [capabilities, setCapabilities] = useState<ServerCapabilities | null>(null);\n  const requestOpts = opts ?? EMPTY_REQUEST_OPTS;\n\n  const connectionStateRef = useRef<'disconnected' | 'connecting' | 'connected'>('disconnected');\n  const toolFlowSequenceRef = useRef(0);\n  const logToolFlow = useCallback((event: string, details: Record<string, unknown> = {}) => {\n    const sequence = ++toolFlowSequenceRef.current;\n    const message = `[${sequence}] ${event}`;\n\n    if (isToolFlowTraceEnabled()) {\n      emitForcedToolFlowTrace(message, details);\n    }\n  }, []);\n\n  /**\n   * Fetches available resources from the MCP server.\n   * Only fetches if the server supports the resources capability.\n   */\n  const fetchResourcesInternal = useCallback(async () => {\n    if (!client) return;\n\n    const serverCapabilities = client.getServerCapabilities();\n    if (!serverCapabilities?.resources) {\n      setResources([]);\n      return;\n    }\n\n    try {\n      const response = await client.listResources();\n      setResources(response.resources);\n    } catch (e) {\n      console.error('[ReactWebMCP:McpClientProvider]', 'Error fetching resources:', e);\n      throw e;\n    }\n  }, [client]);\n\n  /**\n   * Fetches available tools from the MCP server.\n   * Only fetches if the server supports the tools capability.\n   */\n  const fetchToolsInternal = useCallback(async () => {\n    if (!client) return;\n\n    const serverCapabilities = client.getServerCapabilities();\n    if (!serverCapabilities?.tools) {\n      logToolFlow('listTools:capability_missing', {});\n      setTools([]);\n      return;\n    }\n\n    const startedAt = Date.now();\n    logToolFlow('listTools:start', {\n      hasToolsCapability: Boolean(serverCapabilities.tools),\n    });\n    try {\n      const response = await client.listTools();\n      setTools(response.tools);\n      logToolFlow('listTools:success', {\n        durationMs: Date.now() - startedAt,\n        toolCount: response.tools.length,\n      });\n    } catch (e) {\n      logToolFlow('listTools:error', {\n        durationMs: Date.now() - startedAt,\n        errorMessage: e instanceof Error ? e.message : String(e),\n      });\n      console.error('[ReactWebMCP:McpClientProvider]', 'Error fetching tools:', e);\n      throw e;\n    }\n  }, [client, logToolFlow]);\n\n  /**\n   * Establishes connection to the MCP server.\n   * Safe to call multiple times - will no-op if already connected or connecting.\n   */\n  const reconnect = useCallback(async () => {\n    if (!client || !transport) {\n      throw new Error('Client or transport not available');\n    }\n\n    if (connectionStateRef.current !== 'disconnected') {\n      return;\n    }\n\n    connectionStateRef.current = 'connecting';\n    setIsLoading(true);\n    setError(null);\n\n    try {\n      await client.connect(transport, requestOpts);\n      const caps = client.getServerCapabilities();\n      setIsConnected(true);\n      setCapabilities(caps || null);\n      connectionStateRef.current = 'connected';\n      logToolFlow('reconnect:connected', {\n        hasToolsListChanged: Boolean(caps?.tools?.listChanged),\n      });\n\n      await Promise.all([fetchResourcesInternal(), fetchToolsInternal()]);\n    } catch (e) {\n      const err = e instanceof Error ? e : new Error(String(e));\n      connectionStateRef.current = 'disconnected';\n      setError(err);\n      throw err;\n    } finally {\n      setIsLoading(false);\n    }\n  }, [client, transport, requestOpts, fetchResourcesInternal, fetchToolsInternal, logToolFlow]);\n\n  useEffect(() => {\n    if (!isConnected || !client) {\n      return;\n    }\n\n    const serverCapabilities = client.getServerCapabilities();\n\n    const handleResourcesChanged = () => {\n      fetchResourcesInternal().catch((error) => {\n        console.error(\n          '[ReactWebMCP:McpClientProvider]',\n          'Failed to refresh resources after list_changed:',\n          error\n        );\n      });\n    };\n\n    const handleToolsChanged = () => {\n      logToolFlow('notification:tools/list_changed', {});\n      fetchToolsInternal().catch((error) => {\n        console.error(\n          '[ReactWebMCP:McpClientProvider]',\n          'Failed to refresh tools after list_changed:',\n          error\n        );\n      });\n    };\n\n    if (serverCapabilities?.resources?.listChanged) {\n      client.setNotificationHandler(ResourceListChangedNotificationSchema, handleResourcesChanged);\n    }\n\n    if (serverCapabilities?.tools?.listChanged) {\n      client.setNotificationHandler(ToolListChangedNotificationSchema, handleToolsChanged);\n    }\n\n    // Re-fetch after setting up handlers to catch any changes that occurred\n    // during the gap between initial fetch and handler setup\n    Promise.all([fetchResourcesInternal(), fetchToolsInternal()]).catch((error) => {\n      console.error(\n        '[ReactWebMCP:McpClientProvider]',\n        'Failed to refresh tools/resources after handler registration:',\n        error\n      );\n    });\n\n    return () => {\n      if (serverCapabilities?.resources?.listChanged) {\n        client.removeNotificationHandler('notifications/resources/list_changed');\n      }\n\n      if (serverCapabilities?.tools?.listChanged) {\n        client.removeNotificationHandler('notifications/tools/list_changed');\n      }\n    };\n  }, [client, isConnected, fetchResourcesInternal, fetchToolsInternal, logToolFlow]);\n\n  // biome-ignore lint/correctness/useExhaustiveDependencies: intentional - reconnect when client/transport props change\n  useEffect(() => {\n    // Initial connection - reconnect() has its own guard to prevent concurrent connections\n    reconnect().catch((err) => {\n      console.error('[ReactWebMCP:McpClientProvider]', 'Failed to connect MCP client:', err);\n    });\n\n    // Cleanup: mark as disconnected so next mount will reconnect\n    return () => {\n      connectionStateRef.current = 'disconnected';\n      setIsConnected(false);\n    };\n  }, [client, transport, reconnect]);\n\n  return (\n    <McpClientContext.Provider\n      value={{\n        client,\n        tools,\n        resources,\n        isConnected,\n        isLoading,\n        error,\n        capabilities,\n        reconnect,\n      }}\n    >\n      {children}\n    </McpClientContext.Provider>\n  );\n}\n\n/**\n * Hook to access the MCP client context.\n * Must be used within an {@link McpClientProvider}.\n *\n * @returns The MCP client context including client instance, tools, resources, and connection state\n * @throws Error if used outside of McpClientProvider\n *\n * @public\n *\n * @example\n * ```tsx\n * function ToolsList() {\n *   const { tools, isConnected, error, reconnect } = useMcpClient();\n *\n *   if (error) {\n *     return (\n *       <div>\n *         Error: {error.message}\n *         <button onClick={reconnect}>Retry</button>\n *       </div>\n *     );\n *   }\n *\n *   if (!isConnected) {\n *     return <div>Not connected</div>;\n *   }\n *\n *   return (\n *     <ul>\n *       {tools.map(tool => (\n *         <li key={tool.name}>{tool.description}</li>\n *       ))}\n *     </ul>\n *   );\n * }\n * ```\n */\nexport function useMcpClient() {\n  const context = useContext(McpClientContext);\n  if (!context) {\n    throw new Error('useMcpClient must be used within an McpClientProvider');\n  }\n  return context;\n}\n"],"mappings":"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"}

package/package.json

@@ -1,77 +1,79 @@
 {
   "name": "@mcp-b/react-webmcp",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "React hooks for Model Context Protocol (MCP) - expose React components as AI tools for Claude, ChatGPT, Cursor, and Copilot with Zod validation",
   "keywords": [
-    "mcp",
-    "model-context-protocol",
-    "react",
-    "hooks",
-    "react-hooks",
-    "browser",
     "ai",
-    "ai-tools",
     "ai-agents",
-    "llm",
-    "claude",
-    "chatgpt",
-    "openai",
+    "ai-assistant",
+    "ai-integration",
+    "ai-tools",
     "anthropic",
-    "cursor",
+    "browser",
+    "chatgpt",
+    "claude",
     "copilot",
+    "cursor",
     "gemini",
-    "typescript",
-    "webmcp",
-    "navigator-modelcontext",
-    "tool-registration",
-    "ai-assistant",
-    "react-ai",
-    "ai-integration",
+    "hooks",
+    "llm",
+    "mcp",
     "mcp-client",
     "mcp-server",
-    "web-ai"
+    "model-context-protocol",
+    "navigator-modelcontext",
+    "openai",
+    "react",
+    "react-ai",
+    "react-hooks",
+    "tool-registration",
+    "typescript",
+    "web-ai",
+    "webmcp"
   ],
   "homepage": "https://docs.mcp-b.ai/packages/react-webmcp",
   "bugs": {
     "url": "https://github.com/WebMCP-org/npm-packages/issues"
   },
+  "license": "MIT",
+  "author": "WebMCP Team",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/WebMCP-org/npm-packages.git",
     "directory": "packages/react-webmcp"
   },
-  "license": "MIT",
-  "author": "WebMCP Team",
+  "files": [
+    "dist"
+  ],
   "type": "module",
+  "main": "./dist/index.js",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     }
   },
-  "main": "./dist/index.js",
-  "files": [
-    "dist"
-  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "dependencies": {
-    "@mcp-b/transports": "2.1.0",
-    "@mcp-b/global": "2.1.0",
-    "@mcp-b/webmcp-polyfill": "2.1.0",
-    "@mcp-b/webmcp-ts-sdk": "2.1.0",
-    "@mcp-b/webmcp-types": "2.1.0"
+    "@mcp-b/transports": "2.3.0",
+    "@mcp-b/webmcp-polyfill": "2.3.0",
+    "@mcp-b/global": "2.3.0",
+    "@mcp-b/webmcp-ts-sdk": "2.3.0",
+    "@mcp-b/webmcp-types": "2.3.0"
   },
   "devDependencies": {
     "@types/node": "22.17.2",
     "@types/react": "^19.2.9",
-    "@vitest/browser": "^4.0.18",
-    "@vitest/browser-playwright": "^4.0.18",
-    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/coverage-v8": "^4.1.0",
     "playwright": "^1.58.0",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
-    "tsdown": "^0.15.10",
     "typescript": "^5.8.3",
-    "vitest": "^4.0.18",
+    "vite-plus": "latest",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@latest",
     "vitest-browser-react": "^2.0.4"
   },
   "peerDependencies": {
@@ -87,22 +89,18 @@
       "optional": true
     }
   },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
   "scripts": {
-    "build": "tsdown",
-    "build:prod": "NODE_ENV=prod tsdown",
-    "check": "biome check --write .",
-    "clean": "rm -rf dist .turbo",
-    "format": "biome format --write .",
-    "lint": "biome lint --write .",
+    "build": "vp pack",
+    "build:prod": "NODE_ENV=prod vp pack",
+    "check": "vp check --fix",
+    "clean": "rm -rf dist",
+    "format": "vp fmt --write",
+    "lint": "vp lint --fix",
     "publish:dry": "pnpm publish --access public --dry-run",
     "publish:npm": "pnpm publish --access public",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "typecheck": "tsc --noEmit && tsc -p tsconfig.strict-null-checks-false.json --noEmit && vitest run --typecheck --silent",
+    "test": "vp test run",
+    "test:watch": "vp test",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.strict-null-checks-false.json --noEmit && vp test run --typecheck --silent",
     "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"