usewebmcp 0.3.0 → 0.3.2

package/README.md

@@ -7,6 +7,14 @@ Standalone React hooks for strict core WebMCP tool registration via `navigator.m
 - Use `usewebmcp` for strict core WebMCP workflows.
 - Use `@mcp-b/react-webmcp` for full MCP-B runtime features (resources, prompts, client/provider flows, etc.).
 
+## Type Safety First
+
+`usewebmcp` is built for schema-driven types:
+
+- `config.execute`/`config.handler` input is inferred from `inputSchema`
+- Tool result type is inferred from `outputSchema`
+- `state.lastResult` and returned `execute(input)` are typed from that same inferred output
+
 ## Package Selection
 
 | Package | Use When |
@@ -70,7 +78,7 @@ export function CounterTool() {
     description: 'Get current count',
     inputSchema: COUNTER_INPUT_SCHEMA,
     outputSchema: COUNTER_OUTPUT_SCHEMA,
-    handler: async () => ({ count: 42 }),
+    execute: async () => ({ count: 42 }),
   });
 
   return (
@@ -78,6 +86,13 @@ export function CounterTool() {
       <p>Executions: {counterTool.state.executionCount}</p>
       <p>Last count: {counterTool.state.lastResult?.count ?? 'none'}</p>
       {counterTool.state.error && <p>Error: {counterTool.state.error.message}</p>}
+      <button
+        onClick={async () => {
+          await counterTool.execute({});
+        }}
+      >
+        Run Tool Locally
+      </button>
     </div>
   );
 }
@@ -94,7 +109,17 @@ export function CounterTool() {
   - `state.executionCount`
 - Returns `execute(input)` for manual in-app invocation and `reset()` for state reset.
 
-`handler` can be synchronous or asynchronous.
+Your tool implementation (`config.execute` or `config.handler`) can be synchronous or asynchronous.
+
+## `config.execute` vs returned `execute(...)`
+
+- `config.execute`: preferred config field for tool logic.
+- `config.handler`: backward-compatible alias for `config.execute`.
+- returned `execute(input)`: hook return function for local manual invocation from your UI/tests.
+
+If both `config.execute` and `config.handler` are provided, `config.execute` is used.
+
+Both paths run the same underlying tool logic and update the hook state.
 
 ## Type Inference
 
@@ -120,7 +145,7 @@ useWebMCP({
   name: 'search',
   description: 'Search docs',
   inputSchema: INPUT_SCHEMA,
-  handler(input) {
+  execute(input) {
     // input is inferred as { query: string; limit?: number }
     return { total: 1 };
   },
@@ -131,7 +156,7 @@ useWebMCP({
 
 When `outputSchema` is provided as a literal JSON object schema:
 
-- `handler` return type is inferred from `outputSchema`
+- implementation return type is inferred from `outputSchema`
 - `state.lastResult` is inferred to the same type
 - MCP response includes `structuredContent`
 
@@ -149,7 +174,7 @@ const tool = useWebMCP({
   name: 'count_items',
   description: 'Count items',
   outputSchema: OUTPUT_SCHEMA,
-  handler: () => ({ total: 3 }),
+  execute: () => ({ total: 3 }),
 });
 
 // tool.state.lastResult is inferred as { total: number } | null
@@ -170,7 +195,7 @@ function SearchToolPanel() {
       required: ['query'],
       additionalProperties: false,
     } as const,
-    handler: async ({ query }) => ({ query, total: query.length }),
+    execute: async ({ query }) => ({ query, total: query.length }),
   });
 
   return (
@@ -187,7 +212,7 @@ function SearchToolPanel() {
 
 ## Output Schema Contract
 
-If `outputSchema` is defined, the handler must return a JSON-serializable object result.
+If `outputSchema` is defined, your tool implementation must return a JSON-serializable object result.
 
 Returning a non-object value (`string`, `null`, array, etc.) causes an error response from the registered MCP tool.
 
@@ -204,6 +229,7 @@ The tool re-registers when any of these change:
 
 The hook avoids re-registration when only callback references change:
 
+- `execute`
 - `handler`
 - `onSuccess`
 - `onError`
@@ -227,7 +253,8 @@ Recommendation:
 - `inputSchema?`
 - `outputSchema?`
 - `annotations?`
-- `handler(input)`
+- `execute(input)` (preferred)
+- `handler(input)` (backward-compatible alias)
 - `formatOutput?(output)` (deprecated)
 - `onSuccess?(result, input)`
 - `onError?(error, input)`
@@ -238,14 +265,14 @@ Return value:
 - `execute(input)`
 - `reset()`
 
-`execute(input)` is a local direct call to your handler for in-app control/testing.
+`execute(input)` is a local direct call to your configured tool implementation for in-app control/testing.
 Tool calls coming from MCP clients still go through `navigator.modelContext`.
 
 ## Important Notes
 
 - This is a client-side hook package (`'use client'`).
 - `formatOutput` is deprecated; prefer `outputSchema` + structured output.
-- When handler output is not a string, default text content is pretty-printed JSON.
+- When tool output is not a string, default text content is pretty-printed JSON.
 
 ## License
 

package/dist/index.d.ts

@@ -5,7 +5,7 @@ import { InferArgsFromInputSchema, InferJsonSchema, InputSchema, JsonSchemaObjec
 //#region src/types.d.ts
 
 /**
- * Infers handler input type from either a Standard Schema or JSON Schema.
+ * Infers tool input type from either a Standard Schema or JSON Schema.
  *
  * - **Standard Schema** (Zod v4, Valibot, ArkType): extracts `~standard.types.input`
  * - **JSON Schema** (`as const`): uses `InferArgsFromInputSchema` for structural inference
@@ -37,7 +37,7 @@ type InferOutput<TOutputSchema extends JsonSchemaObject | undefined = undefined,
  * Represents the current execution state of a tool, including loading status,
  * results, errors, and execution history.
  *
- * @template TOutput - The type of data returned by the tool handler
+ * @template TOutput - The type of data returned by the tool implementation
  * @public
  */
 interface ToolExecutionState<TOutput = unknown> {
@@ -63,9 +63,20 @@ interface ToolExecutionState<TOutput = unknown> {
   executionCount: number;
 }
 /**
- * Configuration options for the `useWebMCP` hook.
+ * Tool implementation function used by `useWebMCP`.
+ *
+ * Supports sync or async implementations.
+ *
+ * @template TInputSchema - Schema defining input parameters
+ * @template TOutputSchema - Optional JSON Schema object defining output structure
+ *
+ * @public
+ */
+type ToolExecuteFunction<TInputSchema extends ToolInputSchema = InputSchema, TOutputSchema extends JsonSchemaObject | undefined = undefined> = (input: InferToolInput<TInputSchema>) => Promise<InferOutput<TOutputSchema>> | InferOutput<TOutputSchema>;
+/**
+ * Shared configuration fields for the `useWebMCP` hook.
  *
- * Defines a tool's metadata, schema, handler, and lifecycle callbacks.
+ * Defines a tool's metadata, schema, and lifecycle callbacks.
  * Uses JSON Schema for type inference via `as const`.
  *
  * @template TInputSchema - JSON Schema defining input parameters
@@ -83,7 +94,7 @@ interface ToolExecutionState<TOutput = unknown> {
  *     properties: { postId: { type: 'string' } },
  *     required: ['postId'],
  *   } as const,
- *   handler: async ({ postId }) => {
+ *   execute: async ({ postId }) => {
  *     await api.likePost(postId);
  *     return { success: true };
  *   },
@@ -107,14 +118,14 @@ interface ToolExecutionState<TOutput = unknown> {
  *       likedAt: { type: 'string', description: 'ISO timestamp of the like' },
  *     },
  *   } as const,
- *   handler: async ({ postId }) => {
+ *   execute: async ({ postId }) => {
  *     const result = await api.likePost(postId);
  *     return { likes: result.likes, likedAt: new Date().toISOString() };
  *   },
  * });
  * ```
  */
-interface WebMCPConfig<TInputSchema extends ToolInputSchema = InputSchema, TOutputSchema extends JsonSchemaObject | undefined = undefined> {
+interface WebMCPConfigBase<TInputSchema extends ToolInputSchema = InputSchema, TOutputSchema extends JsonSchemaObject | undefined = undefined> {
   /**
    * Unique identifier for the tool (e.g., 'posts_like', 'graph_navigate').
    * Must follow naming conventions: lowercase with underscores.
@@ -151,7 +162,7 @@ interface WebMCPConfig<TInputSchema extends ToolInputSchema = InputSchema, TOutp
    * **Recommended:** JSON Schema object defining the expected output structure.
    *
    * When provided, this enables three key features:
-   * 1. **Type Safety**: The handler's return type is inferred from this schema
+   * 1. **Type Safety**: The implementation return type is inferred from this schema
    * 2. **MCP structuredContent**: The MCP response includes `structuredContent`
    *    containing the typed output per the MCP specification
    * 3. **AI Understanding**: AI models can better understand and use the tool's output
@@ -175,17 +186,6 @@ interface WebMCPConfig<TInputSchema extends ToolInputSchema = InputSchema, TOutp
    * See {@link ToolAnnotations} for available options.
    */
   annotations?: ToolAnnotations;
-  /**
-   * The function that executes when the tool is called.
-   * Can be synchronous or asynchronous.
-   *
-   * When `outputSchema` is provided, the return type is inferred from the schema.
-   * Otherwise, any return type is allowed.
-   *
-   * @param input - Validated input parameters matching the inputSchema
-   * @returns The result data or a Promise resolving to the result
-   */
-  handler: (input: InferToolInput<TInputSchema>) => Promise<InferOutput<TOutputSchema>> | InferOutput<TOutputSchema>;
   /**
    * Custom formatter for the MCP text response.
    *
@@ -193,7 +193,7 @@ interface WebMCPConfig<TInputSchema extends ToolInputSchema = InputSchema, TOutp
    * structured output via MCP's `structuredContent`, which is the recommended
    * approach for tool outputs. This property will be removed in a future version.
    *
-   * @param output - The raw output from the handler
+   * @param output - The raw output from the tool implementation
    * @returns Formatted string for the MCP response content
    */
   formatOutput?: (output: InferOutput<TOutputSchema>) => string;
@@ -201,8 +201,8 @@ interface WebMCPConfig<TInputSchema extends ToolInputSchema = InputSchema, TOutp
    * Optional callback invoked when the tool execution succeeds.
    * Useful for triggering side effects like navigation or analytics.
    *
-   * @param result - The successful result from the handler
-   * @param input - The input that was passed to the handler
+   * @param result - The successful result from the tool implementation
+   * @param input - The input that was passed to the tool implementation
    */
   onSuccess?: (result: InferOutput<TOutputSchema>, input: unknown) => void;
   /**
@@ -210,10 +210,44 @@ interface WebMCPConfig<TInputSchema extends ToolInputSchema = InputSchema, TOutp
    * Useful for error handling, logging, or showing user notifications.
    *
    * @param error - The error that occurred during execution
-   * @param input - The input that was passed to the handler
+   * @param input - The input that was passed to the tool implementation
    */
   onError?: (error: Error, input: unknown) => void;
 }
+type WebMCPConfigImplementation<TInputSchema extends ToolInputSchema = InputSchema, TOutputSchema extends JsonSchemaObject | undefined = undefined> = {
+  /**
+   * Preferred tool implementation function.
+   */
+  execute: ToolExecuteFunction<TInputSchema, TOutputSchema>;
+  /**
+   * Backward-compatible alias for `execute`.
+   */
+  handler?: ToolExecuteFunction<TInputSchema, TOutputSchema>;
+} | {
+  /**
+   * Backward-compatible alias for `execute`.
+   */
+  handler: ToolExecuteFunction<TInputSchema, TOutputSchema>;
+  /**
+   * Preferred tool implementation function.
+   */
+  execute?: ToolExecuteFunction<TInputSchema, TOutputSchema>;
+};
+/**
+ * Configuration options for the `useWebMCP` hook.
+ *
+ * You can provide tool logic with either:
+ * - `execute` (preferred), or
+ * - `handler` (backward-compatible alias).
+ *
+ * If both are provided, `execute` is used.
+ *
+ * @template TInputSchema - JSON Schema defining input parameters
+ * @template TOutputSchema - JSON Schema object defining output structure (enables structuredContent)
+ *
+ * @public
+ */
+type WebMCPConfig<TInputSchema extends ToolInputSchema = InputSchema, TOutputSchema extends JsonSchemaObject | undefined = undefined> = WebMCPConfigBase<TInputSchema, TOutputSchema> & WebMCPConfigImplementation<TInputSchema, TOutputSchema>;
 /**
  * Return value from the `useWebMCP` hook.
  * Provides access to execution state and methods for manual tool control.
@@ -233,7 +267,7 @@ interface WebMCPReturn<TOutputSchema extends JsonSchemaObject | undefined = unde
    *
    * @param input - The input parameters to pass to the tool
    * @returns Promise resolving to the tool's output
-   * @throws Error if validation fails or handler throws
+   * @throws Error if validation fails or tool implementation throws
    */
   execute: (input: unknown) => Promise<InferOutput<TOutputSchema>>;
   /**
@@ -278,7 +312,7 @@ interface WebMCPReturn<TOutputSchema extends JsonSchemaObject | undefined = unde
  *       email: { type: 'string' },
  *     },
  *   } as const,
- *   handler: async ({ userId }) => {
+ *   execute: async ({ userId }) => {
  *     const user = await fetchUser(userId);
  *     return { id: user.id, name: user.name, email: user.email };
  *   },
@@ -289,7 +323,7 @@ interface WebMCPReturn<TOutputSchema extends JsonSchemaObject | undefined = unde
  *
  * This hook is optimized to minimize unnecessary tool re-registrations:
  *
- * - **Ref-based callbacks**: `handler`, `onSuccess`, `onError`, and `formatOutput`
+ * - **Ref-based callbacks**: `execute`/`handler`, `onSuccess`, `onError`, and `formatOutput`
  *   are stored in refs, so changing these functions won't trigger re-registration.
  *
  * **IMPORTANT**: If `inputSchema`, `outputSchema`, or `annotations` are defined inline
@@ -338,7 +372,7 @@ interface WebMCPReturn<TOutputSchema extends JsonSchemaObject | undefined = unde
  *         likeCount: { type: 'number' },
  *       },
  *     } as const,
- *     handler: async ({ postId }) => {
+ *     execute: async ({ postId }) => {
  *       const result = await api.posts.like(postId);
  *       return { success: true, likeCount: result.likes };
  *     },
@@ -350,5 +384,5 @@ interface WebMCPReturn<TOutputSchema extends JsonSchemaObject | undefined = unde
  */
 declare function useWebMCP<TInputSchema extends ToolInputSchema = InputSchema, TOutputSchema extends JsonSchemaObject | undefined = undefined>(config: WebMCPConfig<TInputSchema, TOutputSchema>, deps?: DependencyList): WebMCPReturn<TOutputSchema>;
 //#endregion
-export { type InferOutput, type InferToolInput, type ToolExecutionState, type WebMCPConfig, type WebMCPReturn, useWebMCP };
+export { type InferOutput, type InferToolInput, type ToolExecuteFunction, type ToolExecutionState, type WebMCPConfig, type WebMCPReturn, useWebMCP };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/useWebMCP.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAmBA;;;;;;;AAK+B,KALnB,cAKmB,CAAA,CAAA,CAAA,GALC,CAKD,SAAA;EAAzB,SAAA,WAAA,EAAA;IACA,SAAA,KAAA,CAAA,EAAA,KAAA,MAAA;EAAM,CAAA;AAaZ,CAAA,GAlBI,KAkBQ,SAAW;EACC,SAAA,KAAA,EAAA,KAAA,EAAA;CAEpB,GApBE,CAoBF,GAnBE,MAmBF,CAAA,MAAA,EAAA,OAAA,CAAA,GAlBA,CAkBA,SAlBU,WAkBV,GAjBE,wBAiBF,CAjB2B,CAiB3B,CAAA,GAhBE,MAgBF,CAAA,MAAA,EAAA,OAAA,CAAA;;;;;;AASJ;AA8EA;;;;;AA6DiB,KAvJL,WAuJK,CAAA,sBAtJO,gBAsJP,GAAA,SAAA,GAAA,SAAA,EAAA,YAAA,OAAA,CAAA,GApJb,aAoJa,SApJS,gBAoJT,GApJ4B,eAoJ5B,CApJ4C,aAoJ5C,CAAA,GApJ6D,SAoJ7D;;;;;;;;AAoB4B,UA/J5B,kBA+J4B,CAAA,UAAA,OAAA,CAAA,CAAA;EAYP;;;;EAkBlB,WAAA,EAAA,OAAA;EAAK;AAUzB;;;EAK4B,UAAA,EAjMd,OAiMc,GAAA,IAAA;EAAnB;;;;EAU6B,KAAA,EArM7B,KAqM6B,GAAA,IAAA;;;;ACtGtC;EACuB,cAAA,EAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UDnCN,kCACM,kBAAkB,mCACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAmCR;;;;;;;;;;;;;;;;;;;;;;;iBAwBC;;;;;gBAMD;;;;;;;;;;;mBAaL,eAAe,kBACnB,QAAQ,YAAY,kBAAkB,YAAY;;;;;;;;;;;0BAY/B,YAAY;;;;;;;;uBASf,YAAY;;;;;;;;oBASf;;;;;;;;;UAUH,mCAAmC;;;;;SAK3C,mBAAmB,YAAY;;;;;;;;;+BAUT,QAAQ,YAAY;;;;;;;;;;AArPnD;;;;;;;;;;;AAmBA;;;;;;;;AAYA;AA8EA;;;;;;;;;;;;;;;;;;;;AAyHA;;;;;;;;;;;;ACvFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,+BACO,kBAAkB,mCACjB,kDAEd,aAAa,cAAc,uBAC5B,iBACN,aAAa"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/useWebMCP.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAmBA;;;;;;;AAK+B,KALnB,cAKmB,CAAA,CAAA,CAAA,GALC,CAKD,SAAA;EAAzB,SAAA,WAAA,EAAA;IACA,SAAA,KAAA,CAAA,EAAA,KAAA,MAAA;EAAM,CAAA;AAaZ,CAAA,GAlBI,KAkBQ,SAAW;EACC,SAAA,KAAA,EAAA,KAAA,EAAA;CAEpB,GApBE,CAoBF,GAnBE,MAmBF,CAAA,MAAA,EAAA,OAAA,CAAA,GAlBA,CAkBA,SAlBU,WAkBV,GAjBE,wBAiBF,CAjB2B,CAiB3B,CAAA,GAhBE,MAgBF,CAAA,MAAA,EAAA,OAAA,CAAA;;;;;;AASJ;AAoCA;;;;;AAIS,KApDG,WAoDH,CAAA,sBAnDe,gBAmDf,GAAA,SAAA,GAAA,SAAA,EAAA,YAAA,OAAA,CAAA,GAjDL,aAiDK,SAjDiB,gBAiDjB,GAjDoC,eAiDpC,CAjDoD,aAiDpD,CAAA,GAjDqE,SAiDrE;;;;;;;AAC6D;AAuD/C,UAhGN,kBAgGM,CAAA,UAAA,OAAA,CAAA,CAAA;EAAkB;;;;EAkEzB,WAAA,EAAA,OAAA;EAYsB;;;;EAkBlB,UAAA,EArLN,OAqLM,GAAA,IAAA;EAAK;AAAA;;;EAKD,KAAA,EApLf,KAoLe,GAAA,IAAA;EAMW;;;;EAIe,cAAA,EAAA,MAAA;;;;;;;;;AA2BlD;;;AAEwB,KAxMZ,mBAwMY,CAAA,qBAvMD,eAuMC,GAvMiB,WAuMjB,EAAA,sBAtMA,gBAsMA,GAAA,SAAA,GAAA,SAAA,CAAA,GAAA,CAAA,KAAA,EApMf,cAoMe,CApMA,YAoMA,CAAA,EAAA,GAnMnB,OAmMmB,CAnMX,WAmMW,CAnMC,aAmMD,CAAA,CAAA,GAnMmB,WAmMnB,CAnM+B,aAmM/B,CAAA;;;;;;;;AAWxB;;;;;;;;;;;;ACvIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UDjBU,sCACa,kBAAkB,mCACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAmCR;;;;;;;;;;;;;;;;;;;;;;;iBAwBC;;;;;gBAMD;;;;;;;;;;;0BAYU,YAAY;;;;;;;;uBASf,YAAY;;;;;;;;oBASf;;KAGf,gDACkB,kBAAkB,mCACjB;;;;WAMT,oBAAoB,cAAc;;;;YAIjC,oBAAoB,cAAc;;;;;WAMnC,oBAAoB,cAAc;;;;YAIjC,oBAAoB,cAAc;;;;;;;;;;;;;;;;KAiBtC,kCACW,kBAAkB,mCACjB,4CACpB,iBAAiB,cAAc,iBACjC,2BAA2B,cAAc;;;;;;;;UAS1B,mCAAmC;;;;;SAK3C,mBAAmB,YAAY;;;;;;;;;+BAUT,QAAQ,YAAY;;;;;;;;;;AArSnD;;;;;;;;;;;AAmBA;;;;;;;;AAYA;AAoCA;;;;;;;;;;;;AAKsE;;;;;;;;;;;;;AAuJ7C;;;;;;;;;;;;;;;;;AA0CzB;;;;;;;;;;;AAaA;;;;;;;;;;;;ACvIA;;;;;;;;;;;;;;;;;;iBAAgB,+BACO,kBAAkB,mCACjB,kDAEd,aAAa,cAAc,uBAC5B,iBACN,aAAa"}

package/dist/index.js

@@ -1,2 +1,2 @@
-"use client";import{useCallback as e,useEffect as t,useLayoutEffect as n,useRef as r,useState as i}from"react";function a(e){return typeof e==`string`?e:JSON.stringify(e,null,2)}const o=new Map;function s(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 c=typeof window<`u`?n:t;function l(){let e=globalThis.process?.env?.NODE_ENV;return e===void 0?!1:e!==`production`}function u(n,u){let{name:d,description:f,inputSchema:p,outputSchema:m,annotations:h,handler:g,formatOutput:_=a,onSuccess:v,onError:y}=n,[b,x]=i({isExecuting:!1,lastResult:null,error:null,executionCount:0}),S=r(g),C=r(v),w=r(y),T=r(_),E=r(!0),D=r(new Set),O=r({inputSchema:p,outputSchema:m,annotations:h,description:f,deps:u});c(()=>{S.current=g,C.current=v,w.current=y,T.current=_},[g,v,y,_]),t(()=>(E.current=!0,()=>{E.current=!1}),[]),t(()=>{if(!l()){O.current={inputSchema:p,outputSchema:m,annotations:h,description:f,deps:u};return}let e=(e,t)=>{D.current.has(e)||(console.warn(`[useWebMCP] ${t}`),D.current.add(e))},t=O.current;p&&t.inputSchema&&t.inputSchema!==p&&e(`inputSchema`,`Tool "${d}" inputSchema reference changed; memoize or define it outside the component to avoid re-registration.`),m&&t.outputSchema&&t.outputSchema!==m&&e(`outputSchema`,`Tool "${d}" outputSchema reference changed; memoize or define it outside the component to avoid re-registration.`),h&&t.annotations&&t.annotations!==h&&e(`annotations`,`Tool "${d}" annotations reference changed; memoize or define it outside the component to avoid re-registration.`),f!==t.description&&e(`description`,`Tool "${d}" description changed; this re-registers the tool. Memoize the description if it does not need to update.`),u?.some(e=>typeof e==`object`&&!!e||typeof e==`function`)&&e(`deps`,`Tool "${d}" deps contains non-primitive values; prefer primitives or memoize objects/functions to reduce re-registration.`),O.current={inputSchema:p,outputSchema:m,annotations:h,description:f,deps:u}},[h,u,f,p,d,m]);let k=e(async e=>{x(e=>({...e,isExecuting:!0,error:null}));try{let t=await S.current(e);return E.current&&x(e=>({isExecuting:!1,lastResult:t,error:null,executionCount:e.executionCount+1})),C.current&&C.current(t,e),t}catch(t){let n=t instanceof Error?t:Error(String(t));throw E.current&&x(e=>({...e,isExecuting:!1,error:n})),w.current&&w.current(n,e),n}},[]),A=r(k);t(()=>{A.current=k},[k]);let j=e(e=>A.current(e),[]),M=e(()=>{x({isExecuting:!1,lastResult:null,error:null,executionCount:0})},[]);return t(()=>{if(typeof window>`u`||!window.navigator?.modelContext){console.warn(`[useWebMCP] window.navigator.modelContext is not available. Tool "${d}" will not be registered.`);return}let e=async e=>{try{let t=await A.current(e),n={content:[{type:`text`,text:T.current(t)}]};if(m){let e=s(t);if(!e)throw Error(`Tool "${d}" 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}}},t=Symbol(d),n=window.navigator.modelContext;return n.registerTool({name:d,description:f,...p&&{inputSchema:p},...m&&{outputSchema:m},...h&&{annotations:h},execute:e}),o.set(d,t),()=>{if(o.get(d)===t){o.delete(d);try{n.unregisterTool(d)}catch(e){l()&&console.warn(`[useWebMCP] Failed to unregister tool "${d}" during cleanup:`,e)}}}},[d,f,p,m,h,...u??[]]),{state:b,execute:j,reset:M}}export{u as useWebMCP};
+"use client";import{useCallback as e,useEffect as t,useLayoutEffect as n,useRef as r,useState as i}from"react";function a(e){return typeof e==`string`?e:JSON.stringify(e,null,2)}const o=new Map;function s(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 c=typeof window<`u`?n:t;function l(){let e=globalThis.process?.env?.NODE_ENV;return e===void 0?!1:e!==`production`}function u(n,u){let{name:d,description:f,inputSchema:p,outputSchema:m,annotations:h,execute:g,handler:_,formatOutput:v=a,onSuccess:y,onError:b}=n,x=g??_;if(!x)throw TypeError(`[useWebMCP] Tool "${d}" must provide an implementation via config.execute or config.handler`);let[S,C]=i({isExecuting:!1,lastResult:null,error:null,executionCount:0}),w=r(x),T=r(y),E=r(b),D=r(v),O=r(!0),k=r(new Set),A=r({inputSchema:p,outputSchema:m,annotations:h,description:f,deps:u});c(()=>{w.current=x,T.current=y,E.current=b,D.current=v},[x,y,b,v]),t(()=>(O.current=!0,()=>{O.current=!1}),[]),t(()=>{if(!l()){A.current={inputSchema:p,outputSchema:m,annotations:h,description:f,deps:u};return}let e=(e,t)=>{k.current.has(e)||(console.warn(`[useWebMCP] ${t}`),k.current.add(e))},t=A.current;p&&t.inputSchema&&t.inputSchema!==p&&e(`inputSchema`,`Tool "${d}" inputSchema reference changed; memoize or define it outside the component to avoid re-registration.`),m&&t.outputSchema&&t.outputSchema!==m&&e(`outputSchema`,`Tool "${d}" outputSchema reference changed; memoize or define it outside the component to avoid re-registration.`),h&&t.annotations&&t.annotations!==h&&e(`annotations`,`Tool "${d}" annotations reference changed; memoize or define it outside the component to avoid re-registration.`),f!==t.description&&e(`description`,`Tool "${d}" description changed; this re-registers the tool. Memoize the description if it does not need to update.`),u?.some(e=>typeof e==`object`&&!!e||typeof e==`function`)&&e(`deps`,`Tool "${d}" deps contains non-primitive values; prefer primitives or memoize objects/functions to reduce re-registration.`),A.current={inputSchema:p,outputSchema:m,annotations:h,description:f,deps:u}},[h,u,f,p,d,m]);let j=e(async e=>{C(e=>({...e,isExecuting:!0,error:null}));try{let t=await w.current(e);return O.current&&C(e=>({isExecuting:!1,lastResult:t,error:null,executionCount:e.executionCount+1})),T.current&&T.current(t,e),t}catch(t){let n=t instanceof Error?t:Error(String(t));throw O.current&&C(e=>({...e,isExecuting:!1,error:n})),E.current&&E.current(n,e),n}},[]),M=r(j);t(()=>{M.current=j},[j]);let N=e(e=>M.current(e),[]),P=e(()=>{C({isExecuting:!1,lastResult:null,error:null,executionCount:0})},[]);return t(()=>{if(typeof window>`u`||!window.navigator?.modelContext){console.warn(`[useWebMCP] window.navigator.modelContext is not available. Tool "${d}" will not be registered.`);return}let e=async e=>{try{let t=await M.current(e),n={content:[{type:`text`,text:D.current(t)}]};if(m){let e=s(t);if(!e)throw Error(`Tool "${d}" outputSchema requires the tool implementation 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}}},t=Symbol(d),n=window.navigator.modelContext;return n.registerTool({name:d,description:f,...p&&{inputSchema:p},...m&&{outputSchema:m},...h&&{annotations:h},execute:e}),o.set(d,t),()=>{if(o.get(d)===t){o.delete(d);try{n.unregisterTool(d)}catch(e){l()&&console.warn(`[useWebMCP] Failed to unregister tool "${d}" during cleanup:`,e)}}}},[d,f,p,m,h,...u??[]]),{state:S,execute:N,reset:P}}export{u as useWebMCP};
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["response: CallToolResult"],"sources":["../src/useWebMCP.ts"],"sourcesContent":["import type { ToolInputSchema } from '@mcp-b/webmcp-polyfill';\nimport type {\n  CallToolResult,\n  InputSchema,\n  JsonSchemaObject,\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  ToolExecutionState,\n  WebMCPConfig,\n  WebMCPReturn,\n} from './types.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\nfunction isDev(): boolean {\n  const env = (globalThis as { process?: { env?: { NODE_ENV?: string } } }).process?.env?.NODE_ENV;\n  return env !== undefined ? env !== 'production' : false;\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 * ## Re-render Optimization\n *\n * This hook is optimized to minimize unnecessary tool re-registrations:\n *\n * - **Ref-based callbacks**: `handler`, `onSuccess`, `onError`, and `formatOutput`\n *   are stored in refs, so changing these functions won't trigger re-registration.\n *\n * **IMPORTANT**: If `inputSchema`, `outputSchema`, or `annotations` are defined inline\n * or change on every render, the tool will re-register unnecessarily. To avoid this,\n * define them outside your component with `as const`:\n *\n * ```tsx\n * // Good: Static schema defined outside component\n * const OUTPUT_SCHEMA = {\n *   type: 'object',\n *   properties: { count: { type: 'number' } },\n * } as const;\n *\n * // Bad: Inline schema (creates new object every render)\n * useWebMCP({\n *   outputSchema: { type: 'object', properties: { count: { type: 'number' } } } as const,\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 *\n * @example\n * Basic tool with outputSchema (recommended):\n * ```tsx\n * function PostActions() {\n *   const likeTool = useWebMCP({\n *     name: 'posts_like',\n *     description: 'Like a post by ID',\n *     inputSchema: {\n *       type: 'object',\n *       properties: { postId: { type: 'string', description: 'The post ID' } },\n *       required: ['postId'],\n *     } as const,\n *     outputSchema: {\n *       type: 'object',\n *       properties: {\n *         success: { type: 'boolean' },\n *         likeCount: { type: 'number' },\n *       },\n *     } as const,\n *     handler: async ({ postId }) => {\n *       const result = await api.posts.like(postId);\n *       return { success: true, likeCount: result.likes };\n *     },\n *   });\n *\n *   return <div>Likes: {likeTool.state.lastResult?.likeCount ?? 0}</div>;\n * }\n * ```\n */\nexport function useWebMCP<\n  TInputSchema extends ToolInputSchema = InputSchema,\n  TOutputSchema extends JsonSchemaObject | 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  const warnedRef = useRef(new Set<string>());\n  const prevConfigRef = useRef({\n    inputSchema,\n    outputSchema,\n    annotations,\n    description,\n    deps,\n  });\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  useEffect(() => {\n    if (!isDev()) {\n      prevConfigRef.current = { inputSchema, outputSchema, annotations, description, deps };\n      return;\n    }\n\n    const warnOnce = (key: string, message: string) => {\n      if (warnedRef.current.has(key)) {\n        return;\n      }\n      console.warn(`[useWebMCP] ${message}`);\n      warnedRef.current.add(key);\n    };\n\n    const prev = prevConfigRef.current;\n\n    if (inputSchema && prev.inputSchema && prev.inputSchema !== inputSchema) {\n      warnOnce(\n        'inputSchema',\n        `Tool \"${name}\" inputSchema reference changed; memoize or define it outside the component to avoid re-registration.`\n      );\n    }\n\n    if (outputSchema && prev.outputSchema && prev.outputSchema !== outputSchema) {\n      warnOnce(\n        'outputSchema',\n        `Tool \"${name}\" outputSchema reference changed; memoize or define it outside the component to avoid re-registration.`\n      );\n    }\n\n    if (annotations && prev.annotations && prev.annotations !== annotations) {\n      warnOnce(\n        'annotations',\n        `Tool \"${name}\" annotations reference changed; memoize or define it outside the component to avoid re-registration.`\n      );\n    }\n\n    if (description !== prev.description) {\n      warnOnce(\n        'description',\n        `Tool \"${name}\" description changed; this re-registers the tool. Memoize the description if it does not need to update.`\n      );\n    }\n\n    if (\n      deps?.some(\n        (value) => (typeof value === 'object' && value !== null) || typeof value === 'function'\n      )\n    ) {\n      warnOnce(\n        'deps',\n        `Tool \"${name}\" deps contains non-primitive values; prefer primitives or memoize objects/functions to reduce re-registration.`\n      );\n    }\n\n    prevConfigRef.current = { inputSchema, outputSchema, annotations, description, deps };\n  }, [annotations, deps, description, inputSchema, name, outputSchema]);\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        `[useWebMCP] window.navigator.modelContext is not available. Tool \"${name}\" will not be registered.`\n      );\n      return;\n    }\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 ownerToken = Symbol(name);\n    const modelContext = window.navigator.modelContext;\n\n    (modelContext.registerTool as (tool: ToolDescriptor) => void)({\n      name,\n      description,\n      ...(inputSchema && { inputSchema: inputSchema as InputSchema }),\n      ...(outputSchema && { outputSchema: outputSchema as InputSchema }),\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        if (isDev()) {\n          console.warn(`[useWebMCP] Failed to unregister tool \"${name}\" during cleanup:`, error);\n        }\n      }\n    };\n    // Spread operator in dependencies: Allows users to provide additional dependencies\n    // via the `deps` parameter. While unconventional, this pattern is intentional to support\n    // dynamic dependency injection. The spread is safe because deps is validated and warned\n    // about non-primitive values earlier in this hook.\n  }, [name, description, inputSchema, outputSchema, annotations, ...(deps ?? [])]);\n\n  return {\n    state,\n    execute: stableExecute,\n    reset,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["response: CallToolResult"],"sources":["../src/useWebMCP.ts"],"sourcesContent":["import type { ToolInputSchema } from '@mcp-b/webmcp-polyfill';\nimport type {\n  CallToolResult,\n  InputSchema,\n  JsonSchemaObject,\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  ToolExecutionState,\n  WebMCPConfig,\n  WebMCPReturn,\n} from './types.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\nfunction isDev(): boolean {\n  const env = (globalThis as { process?: { env?: { NODE_ENV?: string } } }).process?.env?.NODE_ENV;\n  return env !== undefined ? env !== 'production' : false;\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 *   execute: async ({ userId }) => {\n *     const user = await fetchUser(userId);\n *     return { id: user.id, name: user.name, email: user.email };\n *   },\n * });\n * ```\n *\n * ## Re-render Optimization\n *\n * This hook is optimized to minimize unnecessary tool re-registrations:\n *\n * - **Ref-based callbacks**: `execute`/`handler`, `onSuccess`, `onError`, and `formatOutput`\n *   are stored in refs, so changing these functions won't trigger re-registration.\n *\n * **IMPORTANT**: If `inputSchema`, `outputSchema`, or `annotations` are defined inline\n * or change on every render, the tool will re-register unnecessarily. To avoid this,\n * define them outside your component with `as const`:\n *\n * ```tsx\n * // Good: Static schema defined outside component\n * const OUTPUT_SCHEMA = {\n *   type: 'object',\n *   properties: { count: { type: 'number' } },\n * } as const;\n *\n * // Bad: Inline schema (creates new object every render)\n * useWebMCP({\n *   outputSchema: { type: 'object', properties: { count: { type: 'number' } } } as const,\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 *\n * @example\n * Basic tool with outputSchema (recommended):\n * ```tsx\n * function PostActions() {\n *   const likeTool = useWebMCP({\n *     name: 'posts_like',\n *     description: 'Like a post by ID',\n *     inputSchema: {\n *       type: 'object',\n *       properties: { postId: { type: 'string', description: 'The post ID' } },\n *       required: ['postId'],\n *     } as const,\n *     outputSchema: {\n *       type: 'object',\n *       properties: {\n *         success: { type: 'boolean' },\n *         likeCount: { type: 'number' },\n *       },\n *     } as const,\n *     execute: async ({ postId }) => {\n *       const result = await api.posts.like(postId);\n *       return { success: true, likeCount: result.likes };\n *     },\n *   });\n *\n *   return <div>Likes: {likeTool.state.lastResult?.likeCount ?? 0}</div>;\n * }\n * ```\n */\nexport function useWebMCP<\n  TInputSchema extends ToolInputSchema = InputSchema,\n  TOutputSchema extends JsonSchemaObject | 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    execute: configExecute,\n    handler: legacyHandler,\n    formatOutput = defaultFormatOutput,\n    onSuccess,\n    onError,\n  } = config;\n  const toolExecute = configExecute ?? legacyHandler;\n\n  if (!toolExecute) {\n    throw new TypeError(\n      `[useWebMCP] Tool \"${name}\" must provide an implementation via config.execute or config.handler`\n    );\n  }\n\n  const [state, setState] = useState<ToolExecutionState<TOutput>>({\n    isExecuting: false,\n    lastResult: null,\n    error: null,\n    executionCount: 0,\n  });\n\n  const toolExecuteRef = useRef(toolExecute);\n  const onSuccessRef = useRef(onSuccess);\n  const onErrorRef = useRef(onError);\n  const formatOutputRef = useRef(formatOutput);\n  const isMountedRef = useRef(true);\n  const warnedRef = useRef(new Set<string>());\n  const prevConfigRef = useRef({\n    inputSchema,\n    outputSchema,\n    annotations,\n    description,\n    deps,\n  });\n  // Update refs when callbacks change (doesn't trigger re-registration)\n  useIsomorphicLayoutEffect(() => {\n    toolExecuteRef.current = toolExecute;\n    onSuccessRef.current = onSuccess;\n    onErrorRef.current = onError;\n    formatOutputRef.current = formatOutput;\n  }, [toolExecute, 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  useEffect(() => {\n    if (!isDev()) {\n      prevConfigRef.current = { inputSchema, outputSchema, annotations, description, deps };\n      return;\n    }\n\n    const warnOnce = (key: string, message: string) => {\n      if (warnedRef.current.has(key)) {\n        return;\n      }\n      console.warn(`[useWebMCP] ${message}`);\n      warnedRef.current.add(key);\n    };\n\n    const prev = prevConfigRef.current;\n\n    if (inputSchema && prev.inputSchema && prev.inputSchema !== inputSchema) {\n      warnOnce(\n        'inputSchema',\n        `Tool \"${name}\" inputSchema reference changed; memoize or define it outside the component to avoid re-registration.`\n      );\n    }\n\n    if (outputSchema && prev.outputSchema && prev.outputSchema !== outputSchema) {\n      warnOnce(\n        'outputSchema',\n        `Tool \"${name}\" outputSchema reference changed; memoize or define it outside the component to avoid re-registration.`\n      );\n    }\n\n    if (annotations && prev.annotations && prev.annotations !== annotations) {\n      warnOnce(\n        'annotations',\n        `Tool \"${name}\" annotations reference changed; memoize or define it outside the component to avoid re-registration.`\n      );\n    }\n\n    if (description !== prev.description) {\n      warnOnce(\n        'description',\n        `Tool \"${name}\" description changed; this re-registers the tool. Memoize the description if it does not need to update.`\n      );\n    }\n\n    if (\n      deps?.some(\n        (value) => (typeof value === 'object' && value !== null) || typeof value === 'function'\n      )\n    ) {\n      warnOnce(\n        'deps',\n        `Tool \"${name}\" deps contains non-primitive values; prefer primitives or memoize objects/functions to reduce re-registration.`\n      );\n    }\n\n    prevConfigRef.current = { inputSchema, outputSchema, annotations, description, deps };\n  }, [annotations, deps, description, inputSchema, name, outputSchema]);\n\n  /**\n   * Executes the configured tool implementation with input validation and state management.\n   *\n   * @param input - The input parameters to validate and pass to the tool implementation\n   * @returns Promise resolving to the tool output\n   * @throws Error if validation fails or the tool implementation 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 toolExecuteRef.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        `[useWebMCP] window.navigator.modelContext is not available. Tool \"${name}\" will not be registered.`\n      );\n      return;\n    }\n\n    /**\n     * Handles MCP tool execution by running the tool implementation 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 tool implementation 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 ownerToken = Symbol(name);\n    const modelContext = window.navigator.modelContext;\n\n    (modelContext.registerTool as (tool: ToolDescriptor) => void)({\n      name,\n      description,\n      ...(inputSchema && { inputSchema: inputSchema as InputSchema }),\n      ...(outputSchema && { outputSchema: outputSchema as InputSchema }),\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        if (isDev()) {\n          console.warn(`[useWebMCP] Failed to unregister tool \"${name}\" during cleanup:`, error);\n        }\n      }\n    };\n    // Spread operator in dependencies: Allows users to provide additional dependencies\n    // via the `deps` parameter. While unconventional, this pattern is intentional to support\n    // dynamic dependency injection. The spread is safe because deps is validated and warned\n    // about non-primitive values earlier in this hook.\n  }, [name, description, inputSchema, outputSchema, annotations, ...(deps ?? [])]);\n\n  return {\n    state,\n    execute: stableExecute,\n    reset,\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usewebmcp",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Standalone React hooks for strict core WebMCP tool registration with navigator.modelContext",
   "keywords": [
     "mcp",
@@ -37,8 +37,8 @@
     "dist"
   ],
   "dependencies": {
-    "@mcp-b/webmcp-polyfill": "0.2.0",
-    "@mcp-b/webmcp-types": "0.2.0"
+    "@mcp-b/webmcp-types": "0.2.1",
+    "@mcp-b/webmcp-polyfill": "0.2.1"
   },
   "devDependencies": {
     "@types/node": "22.17.2",