react-webmcp 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,407 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+
+/**
+ * WebMCP type definitions for the W3C navigator.modelContext API.
+ *
+ * Based on the WebMCP Early Preview specification (Feb 2026) and
+ * the Chrome 146+ implementation.
+ */
+interface JSONSchemaProperty {
+    type?: "string" | "number" | "integer" | "boolean" | "array" | "object";
+    description?: string;
+    enum?: Array<string | number | boolean>;
+    oneOf?: Array<{
+        const: string | number | boolean;
+        title?: string;
+    }>;
+    const?: string | number | boolean;
+    title?: string;
+    pattern?: string;
+    format?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    items?: JSONSchemaProperty;
+    properties?: Record<string, JSONSchemaProperty>;
+    required?: string[];
+    default?: unknown;
+}
+interface JSONSchema {
+    type?: "object" | "array" | "string" | "number" | "integer" | "boolean";
+    properties?: Record<string, JSONSchemaProperty>;
+    required?: string[];
+    description?: string;
+    items?: JSONSchemaProperty;
+}
+interface ToolAnnotations {
+    /** Indicates the tool only reads data and does not modify state. */
+    readOnlyHint?: "true" | "false";
+    /** Indicates the tool performs a destructive/irreversible operation. */
+    destructiveHint?: "true" | "false";
+    /** Indicates the tool is idempotent (safe to retry). */
+    idempotentHint?: "true" | "false";
+    /** Indicates results can be cached. */
+    cache?: boolean;
+}
+interface ToolContentText {
+    type: "text";
+    text: string;
+}
+interface ToolContentJSON {
+    type: "json";
+    json: unknown;
+}
+type ToolContent = ToolContentText | ToolContentJSON;
+interface WebMCPToolDefinition {
+    /** Unique tool name (e.g. "searchFlights"). */
+    name: string;
+    /** Human-readable description for agents. */
+    description: string;
+    /** JSON Schema describing the tool's input parameters. */
+    inputSchema: JSONSchema | Record<string, never>;
+    /** Optional JSON Schema describing the tool's output. */
+    outputSchema?: JSONSchema | JSONSchemaProperty;
+    /** Optional metadata hints for agents. */
+    annotations?: ToolAnnotations;
+    /** The function called when an agent invokes this tool. */
+    execute: (input: Record<string, unknown>) => unknown | Promise<unknown>;
+}
+interface UseWebMCPToolConfig {
+    /** Unique tool name. */
+    name: string;
+    /** Human-readable description for agents. */
+    description: string;
+    /** JSON Schema for the tool's input parameters. */
+    inputSchema: JSONSchema | Record<string, never>;
+    /** Optional JSON Schema for the tool's output. */
+    outputSchema?: JSONSchema | JSONSchemaProperty;
+    /** Optional metadata hints for agents. */
+    annotations?: ToolAnnotations;
+    /** The handler function called when the tool is invoked. */
+    execute: (input: Record<string, unknown>) => unknown | Promise<unknown>;
+}
+interface WebMCPContextConfig {
+    tools: WebMCPToolDefinition[];
+}
+interface WebMCPFormSubmitEvent extends Event {
+    /** True when the form submission was triggered by an AI agent. */
+    agentInvoked: boolean;
+    /** Pass a promise that resolves with the tool's result data. */
+    respondWith: (response: Promise<unknown> | unknown) => void;
+}
+interface ToolActivatedEvent extends Event {
+    /** The name of the tool that was activated. */
+    toolName: string;
+}
+interface ToolCancelEvent extends Event {
+    /** The name of the tool whose execution was cancelled. */
+    toolName: string;
+}
+interface ModelContext {
+    registerTool(tool: WebMCPToolDefinition): void;
+    unregisterTool(name: string): void;
+    provideContext(config: {
+        tools: WebMCPToolDefinition[];
+    }): void;
+    clearContext(): void;
+}
+interface ModelContextTesting {
+    listTools(): Array<{
+        name: string;
+        description: string;
+        inputSchema: JSONSchema | string;
+    }>;
+    executeTool(name: string, inputArgs: Record<string, unknown>): Promise<unknown>;
+    registerToolsChangedCallback(callback: () => void): void;
+    getCrossDocumentScriptToolResult(): Promise<unknown>;
+}
+declare global {
+    interface Navigator {
+        modelContext?: ModelContext;
+        modelContextTesting?: ModelContextTesting;
+    }
+    interface WindowEventMap {
+        toolactivated: CustomEvent & {
+            toolName: string;
+        };
+        toolcancel: CustomEvent & {
+            toolName: string;
+        };
+    }
+}
+
+/**
+ * Register a single WebMCP tool via the imperative API.
+ *
+ * The tool is registered with `navigator.modelContext.registerTool()` when
+ * the component mounts and unregistered with `unregisterTool()` on unmount.
+ * If the tool definition changes (name, description, schemas, or
+ * annotations), the previous tool is unregistered and the new one is
+ * registered.
+ *
+ * Object/array props like `inputSchema` and `annotations` are compared by
+ * value (serialised fingerprint), so passing inline literals on every render
+ * will **not** cause unnecessary re-registration.
+ *
+ * The `execute` callback is always called through a ref, so it does not
+ * need to be memoised by the consumer.
+ *
+ * @example
+ * ```tsx
+ * useWebMCPTool({
+ *   name: "searchFlights",
+ *   description: "Search for flights with the given parameters.",
+ *   inputSchema: {
+ *     type: "object",
+ *     properties: {
+ *       origin: { type: "string", description: "Origin IATA code" },
+ *       destination: { type: "string", description: "Destination IATA code" },
+ *     },
+ *     required: ["origin", "destination"],
+ *   },
+ *   execute: async ({ origin, destination }) => {
+ *     const results = await api.searchFlights(origin, destination);
+ *     return { content: [{ type: "text", text: JSON.stringify(results) }] };
+ *   },
+ * });
+ * ```
+ */
+declare function useWebMCPTool(config: UseWebMCPToolConfig): void;
+
+/**
+ * Register multiple WebMCP tools at once using `provideContext()`.
+ *
+ * Unlike `useWebMCPTool` which manages a single tool, `useWebMCPContext`
+ * replaces the entire set of registered tools. This is useful when the
+ * application state changes significantly and you want to expose a
+ * completely different set of tools.
+ *
+ * On unmount, all tools are cleared via `clearContext()`.
+ *
+ * The hook performs a deep comparison of tool definitions (name, description,
+ * inputSchema, annotations) so that passing a new array reference on every
+ * render does **not** cause unnecessary re-registration.
+ *
+ * @example
+ * ```tsx
+ * useWebMCPContext({
+ *   tools: [
+ *     {
+ *       name: "addTodo",
+ *       description: "Add a new item to the todo list",
+ *       inputSchema: { type: "object", properties: { text: { type: "string" } } },
+ *       execute: ({ text }) => ({ content: [{ type: "text", text: `Added: ${text}` }] }),
+ *     },
+ *     {
+ *       name: "markComplete",
+ *       description: "Mark a todo item as complete",
+ *       inputSchema: { type: "object", properties: { id: { type: "string" } } },
+ *       execute: ({ id }) => ({ content: [{ type: "text", text: `Completed: ${id}` }] }),
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+declare function useWebMCPContext(config: {
+    tools: WebMCPToolDefinition[];
+}): void;
+
+/**
+ * Listen for WebMCP tool lifecycle events on the window.
+ *
+ * The browser fires `toolactivated` when an AI agent invokes a declarative
+ * tool (form fields are pre-filled) and `toolcancel` when the agent or
+ * user cancels the operation.
+ *
+ * @param event - The event name: "toolactivated" or "toolcancel"
+ * @param callback - Called with the tool name when the event fires
+ * @param toolNameFilter - Optional: only fire for a specific tool name
+ *
+ * @example
+ * ```tsx
+ * useToolEvent("toolactivated", (toolName) => {
+ *   console.log(`Agent activated tool: ${toolName}`);
+ *   validateForm();
+ * }, "book_table");
+ * ```
+ */
+declare function useToolEvent(event: "toolactivated" | "toolcancel", callback: (toolName: string) => void, toolNameFilter?: string): void;
+
+interface WebMCPFormProps extends Omit<React.FormHTMLAttributes<HTMLFormElement>, "onSubmit"> {
+    /** The tool name exposed to AI agents. Maps to the `toolname` HTML attribute. */
+    toolName: string;
+    /** Description of what this tool does. Maps to `tooldescription`. */
+    toolDescription: string;
+    /** If true, the form auto-submits when filled by an agent. Maps to `toolautosubmit`. */
+    toolAutoSubmit?: boolean;
+    /**
+     * Submit handler that receives the enhanced SubmitEvent with
+     * `agentInvoked` and `respondWith` properties.
+     */
+    onSubmit?: (event: WebMCPFormSubmitEvent) => void;
+    /** Called when a tool activation event fires for this form's tool. */
+    onToolActivated?: (toolName: string) => void;
+    /** Called when a tool cancel event fires for this form's tool. */
+    onToolCancel?: (toolName: string) => void;
+    children: React.ReactNode;
+}
+/**
+ * A React wrapper for the WebMCP declarative API.
+ *
+ * Renders a `<form>` element with the appropriate WebMCP HTML attributes
+ * (`toolname`, `tooldescription`, `toolautosubmit`) so the browser
+ * automatically registers it as a WebMCP tool.
+ *
+ * @example
+ * ```tsx
+ * <WebMCPForm
+ *   toolName="book_table"
+ *   toolDescription="Book a table at the restaurant"
+ *   onSubmit={(e) => {
+ *     e.preventDefault();
+ *     if (e.agentInvoked) {
+ *       e.respondWith(Promise.resolve("Booking confirmed!"));
+ *     }
+ *   }}
+ * >
+ *   <WebMCPInput name="name" label="Full Name" />
+ *   <button type="submit">Book</button>
+ * </WebMCPForm>
+ * ```
+ */
+declare function WebMCPForm({ toolName, toolDescription, toolAutoSubmit, onSubmit, onToolActivated, onToolCancel, children, ...rest }: WebMCPFormProps): react_jsx_runtime.JSX.Element;
+
+interface WebMCPInputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    /** Maps to the `toolparamtitle` attribute (overrides the JSON Schema property key). */
+    toolParamTitle?: string;
+    /** Maps to the `toolparamdescription` attribute (describes this parameter to agents). */
+    toolParamDescription?: string;
+}
+/**
+ * An `<input>` element enhanced with WebMCP declarative attributes.
+ *
+ * Use inside a `<WebMCPForm>` to annotate individual form fields
+ * for AI agents.
+ *
+ * @example
+ * ```tsx
+ * <WebMCPInput
+ *   type="text"
+ *   name="name"
+ *   toolParamDescription="Customer's full name (min 2 chars)"
+ *   required
+ *   minLength={2}
+ * />
+ * ```
+ */
+declare const WebMCPInput: React.ForwardRefExoticComponent<WebMCPInputProps & React.RefAttributes<HTMLInputElement>>;
+
+interface WebMCPSelectProps extends React.SelectHTMLAttributes<HTMLSelectElement> {
+    /** Maps to the `toolparamtitle` attribute (overrides the JSON Schema property key). */
+    toolParamTitle?: string;
+    /** Maps to the `toolparamdescription` attribute (describes this parameter to agents). */
+    toolParamDescription?: string;
+    children: React.ReactNode;
+}
+/**
+ * A `<select>` element enhanced with WebMCP declarative attributes.
+ *
+ * Use inside a `<WebMCPForm>` to annotate select inputs for AI agents.
+ * The `<option>` values and text are automatically mapped to the tool's
+ * JSON Schema `enum` / `oneOf` definitions by the browser.
+ *
+ * @example
+ * ```tsx
+ * <WebMCPSelect
+ *   name="seating"
+ *   toolParamDescription="Preferred seating area"
+ * >
+ *   <option value="Main Dining">Main Dining Room</option>
+ *   <option value="Terrace">Terrace (Outdoor)</option>
+ * </WebMCPSelect>
+ * ```
+ */
+declare const WebMCPSelect: React.ForwardRefExoticComponent<WebMCPSelectProps & React.RefAttributes<HTMLSelectElement>>;
+
+interface WebMCPTextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    /** Maps to the `toolparamtitle` attribute (overrides the JSON Schema property key). */
+    toolParamTitle?: string;
+    /** Maps to the `toolparamdescription` attribute (describes this parameter to agents). */
+    toolParamDescription?: string;
+}
+/**
+ * A `<textarea>` element enhanced with WebMCP declarative attributes.
+ *
+ * Use inside a `<WebMCPForm>` to annotate textarea inputs for AI agents.
+ *
+ * @example
+ * ```tsx
+ * <WebMCPTextarea
+ *   name="requests"
+ *   rows={3}
+ *   toolParamDescription="Special requests (allergies, occasions, etc.)"
+ * />
+ * ```
+ */
+declare const WebMCPTextarea: React.ForwardRefExoticComponent<WebMCPTextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+interface WebMCPContextValue {
+    /** Whether navigator.modelContext is available in this browser. */
+    available: boolean;
+    /** Whether navigator.modelContextTesting is available (inspector API). */
+    testingAvailable: boolean;
+}
+/**
+ * Provides WebMCP availability information to the component tree.
+ *
+ * Wrap your application (or a subtree) with `<WebMCPProvider>` to let
+ * child components check WebMCP availability via the `useWebMCPStatus` hook.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   return (
+ *     <WebMCPProvider>
+ *       <MyComponent />
+ *     </WebMCPProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function WebMCPProvider({ children }: {
+    children: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Returns the current WebMCP availability status.
+ *
+ * Must be used within a `<WebMCPProvider>`.
+ *
+ * @example
+ * ```tsx
+ * function StatusBadge() {
+ *   const { available } = useWebMCPStatus();
+ *   return <span>{available ? "WebMCP Ready" : "WebMCP Not Available"}</span>;
+ * }
+ * ```
+ */
+declare function useWebMCPStatus(): WebMCPContextValue;
+
+/**
+ * Returns the navigator.modelContext API if available, or null.
+ */
+declare function getModelContext(): ModelContext | null;
+/**
+ * Returns true if the WebMCP API (navigator.modelContext) is available
+ * in the current browsing context.
+ */
+declare function isWebMCPAvailable(): boolean;
+/**
+ * Returns true if the WebMCP testing API (navigator.modelContextTesting)
+ * is available. This is the API used by the Model Context Tool Inspector
+ * extension and requires the "WebMCP for testing" Chrome flag.
+ */
+declare function isWebMCPTestingAvailable(): boolean;
+
+export { type JSONSchema, type JSONSchemaProperty, type ModelContext, type ModelContextTesting, type ToolActivatedEvent, type ToolAnnotations, type ToolCancelEvent, type ToolContent, type ToolContentJSON, type ToolContentText, type UseWebMCPToolConfig, type WebMCPContextConfig, WebMCPForm, type WebMCPFormProps, type WebMCPFormSubmitEvent, WebMCPInput, type WebMCPInputProps, WebMCPProvider, WebMCPSelect, type WebMCPSelectProps, WebMCPTextarea, type WebMCPTextareaProps, type WebMCPToolDefinition, getModelContext, isWebMCPAvailable, isWebMCPTestingAvailable, useToolEvent, useWebMCPContext, useWebMCPStatus, useWebMCPTool };

package/dist/index.js

@@ -0,0 +1,255 @@
+'use strict';
+
+var React2 = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React2__default = /*#__PURE__*/_interopDefault(React2);
+
+// src/hooks/useWebMCPTool.ts
+
+// src/utils/modelContext.ts
+function getModelContext() {
+  if (typeof window !== "undefined" && typeof window.navigator !== "undefined" && window.navigator.modelContext) {
+    return window.navigator.modelContext;
+  }
+  return null;
+}
+function isWebMCPAvailable() {
+  return getModelContext() !== null;
+}
+function isWebMCPTestingAvailable() {
+  return typeof window !== "undefined" && typeof window.navigator !== "undefined" && !!window.navigator.modelContextTesting;
+}
+function warnIfUnavailable(hookName) {
+  if (!isWebMCPAvailable()) {
+    console.warn(
+      `[react-webmcp] ${hookName}: navigator.modelContext is not available. Ensure you are running Chrome 146+ with the "WebMCP for testing" flag enabled.`
+    );
+  }
+}
+
+// src/hooks/useWebMCPTool.ts
+function toolFingerprint(config) {
+  return `${config.name}::${config.description}::${JSON.stringify(config.inputSchema)}::${JSON.stringify(config.outputSchema ?? {})}::${JSON.stringify(config.annotations ?? {})}`;
+}
+function useWebMCPTool(config) {
+  const registeredNameRef = React2.useRef(null);
+  const configRef = React2.useRef(config);
+  configRef.current = config;
+  const fingerprint = toolFingerprint(config);
+  React2.useEffect(() => {
+    const mc = getModelContext();
+    if (!mc) {
+      warnIfUnavailable("useWebMCPTool");
+      return;
+    }
+    if (registeredNameRef.current && registeredNameRef.current !== config.name) {
+      try {
+        mc.unregisterTool(registeredNameRef.current);
+      } catch {
+      }
+    }
+    const toolDef = {
+      name: config.name,
+      description: config.description,
+      inputSchema: config.inputSchema,
+      ...config.outputSchema ? { outputSchema: config.outputSchema } : {},
+      ...config.annotations ? { annotations: config.annotations } : {},
+      execute: (input) => {
+        return configRef.current.execute(input);
+      }
+    };
+    try {
+      mc.registerTool(toolDef);
+      registeredNameRef.current = config.name;
+    } catch (err) {
+      console.error(`[react-webmcp] Failed to register tool "${config.name}":`, err);
+    }
+    return () => {
+      try {
+        mc.unregisterTool(config.name);
+      } catch {
+      }
+      registeredNameRef.current = null;
+    };
+  }, [fingerprint, config.name]);
+}
+function toolsFingerprint(tools) {
+  return tools.map(
+    (t) => `${t.name}::${t.description}::${JSON.stringify(t.inputSchema)}::${JSON.stringify(t.annotations ?? {})}`
+  ).join("|");
+}
+function useWebMCPContext(config) {
+  const prevFingerprintRef = React2.useRef("");
+  const toolsRef = React2.useRef(config.tools);
+  toolsRef.current = config.tools;
+  const fingerprint = toolsFingerprint(config.tools);
+  React2.useEffect(() => {
+    if (fingerprint === prevFingerprintRef.current) {
+      return;
+    }
+    prevFingerprintRef.current = fingerprint;
+    const mc = getModelContext();
+    if (!mc) {
+      warnIfUnavailable("useWebMCPContext");
+      return;
+    }
+    const stableTools = toolsRef.current.map((tool, idx) => ({
+      ...tool,
+      execute: (input) => {
+        return toolsRef.current[idx].execute(input);
+      }
+    }));
+    try {
+      mc.provideContext({ tools: stableTools });
+    } catch (err) {
+      console.error("[react-webmcp] Failed to provide context:", err);
+    }
+    return () => {
+      try {
+        mc.clearContext();
+      } catch {
+      }
+    };
+  }, [fingerprint]);
+}
+function useToolEvent(event, callback, toolNameFilter) {
+  React2.useEffect(() => {
+    const handler = (e) => {
+      const toolName = e.toolName ?? e.detail?.toolName;
+      if (!toolName) return;
+      if (toolNameFilter && toolName !== toolNameFilter) return;
+      callback(toolName);
+    };
+    window.addEventListener(event, handler);
+    return () => {
+      window.removeEventListener(event, handler);
+    };
+  }, [event, callback, toolNameFilter]);
+}
+function WebMCPForm({
+  toolName,
+  toolDescription,
+  toolAutoSubmit,
+  onSubmit,
+  onToolActivated,
+  onToolCancel,
+  children,
+  ...rest
+}) {
+  const formRef = React2.useRef(null);
+  React2.useEffect(() => {
+    const handleActivated = (e) => {
+      const name = e.toolName ?? e.detail?.toolName;
+      if (name === toolName && onToolActivated) {
+        onToolActivated(name);
+      }
+    };
+    const handleCancel = (e) => {
+      const name = e.toolName ?? e.detail?.toolName;
+      if (name === toolName && onToolCancel) {
+        onToolCancel(name);
+      }
+    };
+    window.addEventListener("toolactivated", handleActivated);
+    window.addEventListener("toolcancel", handleCancel);
+    return () => {
+      window.removeEventListener("toolactivated", handleActivated);
+      window.removeEventListener("toolcancel", handleCancel);
+    };
+  }, [toolName, onToolActivated, onToolCancel]);
+  const handleSubmit = React2.useCallback(
+    (e) => {
+      if (onSubmit) {
+        onSubmit(e.nativeEvent);
+      }
+    },
+    [onSubmit]
+  );
+  const webmcpAttrs = {
+    toolname: toolName,
+    tooldescription: toolDescription
+  };
+  if (toolAutoSubmit) {
+    webmcpAttrs.toolautosubmit = "";
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "form",
+    {
+      ref: formRef,
+      onSubmit: handleSubmit,
+      ...webmcpAttrs,
+      ...rest,
+      children
+    }
+  );
+}
+var WebMCPInput = React2__default.default.forwardRef(
+  ({ toolParamTitle, toolParamDescription, ...rest }, ref) => {
+    const webmcpAttrs = {};
+    if (toolParamTitle) {
+      webmcpAttrs.toolparamtitle = toolParamTitle;
+    }
+    if (toolParamDescription) {
+      webmcpAttrs.toolparamdescription = toolParamDescription;
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx("input", { ref, ...webmcpAttrs, ...rest });
+  }
+);
+WebMCPInput.displayName = "WebMCPInput";
+var WebMCPSelect = React2__default.default.forwardRef(({ toolParamTitle, toolParamDescription, children, ...rest }, ref) => {
+  const webmcpAttrs = {};
+  if (toolParamTitle) {
+    webmcpAttrs.toolparamtitle = toolParamTitle;
+  }
+  if (toolParamDescription) {
+    webmcpAttrs.toolparamdescription = toolParamDescription;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("select", { ref, ...webmcpAttrs, ...rest, children });
+});
+WebMCPSelect.displayName = "WebMCPSelect";
+var WebMCPTextarea = React2__default.default.forwardRef(({ toolParamTitle, toolParamDescription, ...rest }, ref) => {
+  const webmcpAttrs = {};
+  if (toolParamTitle) {
+    webmcpAttrs.toolparamtitle = toolParamTitle;
+  }
+  if (toolParamDescription) {
+    webmcpAttrs.toolparamdescription = toolParamDescription;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("textarea", { ref, ...webmcpAttrs, ...rest });
+});
+WebMCPTextarea.displayName = "WebMCPTextarea";
+var WebMCPReactContext = React2.createContext({
+  available: false,
+  testingAvailable: false
+});
+function WebMCPProvider({ children }) {
+  const value = React2.useMemo(
+    () => ({
+      available: isWebMCPAvailable(),
+      testingAvailable: isWebMCPTestingAvailable()
+    }),
+    []
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(WebMCPReactContext.Provider, { value, children });
+}
+function useWebMCPStatus() {
+  return React2.useContext(WebMCPReactContext);
+}
+
+exports.WebMCPForm = WebMCPForm;
+exports.WebMCPInput = WebMCPInput;
+exports.WebMCPProvider = WebMCPProvider;
+exports.WebMCPSelect = WebMCPSelect;
+exports.WebMCPTextarea = WebMCPTextarea;
+exports.getModelContext = getModelContext;
+exports.isWebMCPAvailable = isWebMCPAvailable;
+exports.isWebMCPTestingAvailable = isWebMCPTestingAvailable;
+exports.useToolEvent = useToolEvent;
+exports.useWebMCPContext = useWebMCPContext;
+exports.useWebMCPStatus = useWebMCPStatus;
+exports.useWebMCPTool = useWebMCPTool;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map