@mcp-fe/react-tools 0.1.2 → 0.1.4

package/index.mjs

@@ -1,855 +1,180 @@
-import { useState as R, useRef as v, useEffect as w, useCallback as C, createContext as x, useContext as U } from "react";
-import { jsx as z } from "react/jsx-runtime";
-const N = typeof process < "u" && process.env?.NODE_ENV === "production", I = typeof process < "u" && process.env?.MCP_DEBUG, m = I === "true" || !N && I !== "false", i = {
-  log: (...c) => {
-    m && console.log(...c);
-  },
-  debug: (...c) => {
-    m && console.debug(...c);
-  },
-  info: (...c) => {
-    console.info(...c);
-  },
-  error: (...c) => {
-    console.error(...c);
-  },
-  warn: (...c) => {
-    m && console.warn(...c);
-  }
-};
-class _ {
-  // Configurable worker script URLs (defaults kept for backward compatibility)
-  sharedWorkerUrl = "/mcp-shared-worker.js";
-  serviceWorkerUrl = "/mcp-service-worker.js";
-  // Backend websocket URL to pass into the worker(s)
-  backendWsUrl = "ws://localhost:3001";
-  serviceWorkerRegistration = null;
-  sharedWorker = null;
-  sharedWorkerPort = null;
-  workerType = null;
-  pendingAuthToken = null;
-  // connection status subscribers
-  connectionStatusCallbacks = /* @__PURE__ */ new Set();
-  // Mutex/promise to prevent concurrent init runs
-  initPromise = null;
-  // Initialization state
-  isInitialized = !1;
-  initResolvers = [];
-  // Queue for operations that need to wait for initialization
-  pendingRegistrations = [];
-  // Map to store tool handlers in main thread
-  toolHandlers = /* @__PURE__ */ new Map();
-  // Tool registry for tracking registrations and reference counting
-  toolRegistry = /* @__PURE__ */ new Map();
-  // Subscribers for tool changes (for React hooks reactivity)
-  toolChangeListeners = /* @__PURE__ */ new Map();
-  // Initialize and choose worker implementation (prefer SharedWorker)
-  // Accept either a ServiceWorkerRegistration OR WorkerInitOptions to configure URLs
-  async init(e) {
-    i.log("[WorkerClient] init() called", {
-      hasOptions: !!e,
-      currentWorkerType: this.workerType,
-      initInProgress: !!this.initPromise,
-      timestamp: Date.now()
-    });
-    let r;
-    const t = e;
-    if (t && typeof t.scope == "string")
-      r = e, i.log("[WorkerClient] Using explicit ServiceWorker registration");
-    else if (e) {
-      const o = e;
-      i.log("[WorkerClient] Using WorkerClientInitOptions:", o), o.sharedWorkerUrl && (this.sharedWorkerUrl = o.sharedWorkerUrl), o.serviceWorkerUrl && (this.serviceWorkerUrl = o.serviceWorkerUrl), o.backendWsUrl && (this.backendWsUrl = o.backendWsUrl);
-    }
-    return this.initPromise ? this.initPromise.then(async () => {
-      r && this.workerType !== "service" && await this.init(r);
-    }) : (this.initPromise = (async () => {
-      try {
-        if (r) {
-          this.serviceWorkerRegistration = r, this.workerType = "service", i.info(
-            "[WorkerClient] Using ServiceWorker (explicit registration)"
-          );
-          try {
-            const s = {
-              type: "INIT",
-              backendUrl: this.backendWsUrl
-            };
-            this.pendingAuthToken && (s.token = this.pendingAuthToken), this.serviceWorkerRegistration.active ? this.serviceWorkerRegistration.active.postMessage(s) : "serviceWorker" in navigator && navigator.serviceWorker.controller && navigator.serviceWorker.controller.postMessage(s);
-          } catch {
-          }
-          return;
-        }
-        if (await this.initSharedWorker()) {
-          this.markAsInitialized();
-          return;
-        }
-        await this.initServiceWorkerFallback(), this.markAsInitialized();
-      } finally {
-        this.initPromise = null;
-      }
-    })(), this.initPromise);
-  }
-  /**
-   * Mark worker as initialized and process pending registrations
-   * @private
-   */
-  markAsInitialized() {
-    this.isInitialized = !0, i.log(
-      "[WorkerClient] Worker initialized, processing pending operations"
-    ), this.initResolvers.forEach((r) => r()), this.initResolvers = [];
-    const e = [...this.pendingRegistrations];
-    this.pendingRegistrations = [], e.forEach(
-      async ({ name: r, description: t, inputSchema: o, handler: s, resolve: a, reject: h }) => {
-        try {
-          await this.registerToolInternal(
-            r,
-            t,
-            o,
-            s
-          ), a();
-        } catch (u) {
-          h(u instanceof Error ? u : new Error(String(u)));
-        }
-      }
-    );
-  }
-  /**
-   * Wait for worker initialization
-   * @returns Promise that resolves when worker is initialized
-   */
-  async waitForInit() {
-    if (this.isInitialized)
-      return Promise.resolve();
-    if (this.initPromise) {
-      await this.initPromise;
-      return;
-    }
-    return new Promise((e) => {
-      this.initResolvers.push(e);
-    });
-  }
-  /**
-   * Check if worker is initialized
-   */
-  get initialized() {
-    return this.isInitialized;
-  }
-  async initSharedWorker() {
-    if (typeof SharedWorker > "u")
-      return Promise.resolve(!1);
-    try {
-      this.sharedWorker = new SharedWorker(this.sharedWorkerUrl, {
-        type: "module"
-      }), this.sharedWorkerPort = this.sharedWorker.port, this.sharedWorkerPort.start(), await new Promise((r, t) => {
-        let o = !1;
-        const s = setTimeout(() => {
-          if (!o) {
-            const h = this.sharedWorkerPort;
-            h && (h.onmessage = null), t(new Error("SharedWorker initialization timeout"));
-          }
-        }, 2e3), a = this.sharedWorkerPort;
-        if (!a)
-          return clearTimeout(s), t(new Error("SharedWorker port not available"));
-        a.onmessage = (h) => {
-          try {
-            const u = h.data;
-            u && u.type === "CONNECTION_STATUS" && (clearTimeout(s), o = !0, this.workerType = "shared", a.onmessage = null, r(!0));
-          } catch {
-          }
-        };
-      });
-      const e = this.sharedWorkerPort;
-      if (e) {
-        try {
-          const r = {
-            type: "INIT",
-            backendUrl: this.backendWsUrl
-          };
-          this.pendingAuthToken && (r.token = this.pendingAuthToken), e.postMessage(r), this.pendingAuthToken = null;
-        } catch (r) {
-          i.warn(
-            "[WorkerClient] Failed to send INIT to SharedWorker port:",
-            r
-          );
-        }
-        e.onmessage = (r) => {
-          try {
-            const t = r.data;
-            if (t && t.type === "CONNECTION_STATUS") {
-              const o = !!t.connected;
-              this.connectionStatusCallbacks.forEach((s) => {
-                try {
-                  s(o);
-                } catch {
-                }
-              });
-            } else t && t.type === "CALL_TOOL" && this.handleToolCall(t.toolName, t.args, t.callId).catch(
-              (o) => {
-                i.error(
-                  "[WorkerClient] Failed to handle tool call:",
-                  o
-                );
-              }
-            );
-          } catch {
-          }
-        };
-      }
-      return i.info("[WorkerClient] Using SharedWorker"), !0;
-    } catch (e) {
-      return i.warn(
-        "[WorkerClient] SharedWorker not available, falling back to ServiceWorker:",
-        e
-      ), !1;
-    }
-  }
-  async initServiceWorkerFallback() {
-    if ("serviceWorker" in navigator)
-      try {
-        const e = await navigator.serviceWorker.getRegistration();
-        if (e) {
-          this.serviceWorkerRegistration = e, this.workerType = "service", i.info(
-            "[WorkerClient] Using existing ServiceWorker registration"
-          );
-          return;
-        }
-        this.serviceWorkerRegistration = await navigator.serviceWorker.register(
-          this.serviceWorkerUrl
-        ), this.workerType = "service", "serviceWorker" in navigator && navigator.serviceWorker.addEventListener(
-          "message",
-          (r) => {
-            try {
-              const t = r.data;
-              t && t.type === "CALL_TOOL" && this.handleToolCall(
-                t.toolName,
-                t.args,
-                t.callId
-              ).catch((o) => {
-                i.error(
-                  "[WorkerClient] Failed to handle tool call:",
-                  o
-                );
-              });
-            } catch (t) {
-              i.error(
-                "[WorkerClient] Error processing ServiceWorker message:",
-                t
-              );
-            }
-          }
-        ), i.info("[WorkerClient] Using MCP ServiceWorker (fallback)");
-        try {
-          const r = {
-            type: "INIT",
-            backendUrl: this.backendWsUrl
-          };
-          this.pendingAuthToken && (r.token = this.pendingAuthToken), this.serviceWorkerRegistration.active ? this.serviceWorkerRegistration.active.postMessage(r) : "serviceWorker" in navigator && navigator.serviceWorker.controller && navigator.serviceWorker.controller.postMessage(r), this.pendingAuthToken = null;
-        } catch {
-        }
-      } catch (e) {
-        throw i.error("[WorkerClient] Failed to register ServiceWorker:", e), e;
-      }
-    else
-      throw new Error("Neither SharedWorker nor ServiceWorker is supported");
-  }
-  // Low-level request that expects a reply via MessageChannel
-  async request(e, r, t = 5e3) {
-    if (i.log("[WorkerClient] Request started:", {
-      type: e,
-      payload: r,
-      timeoutMs: t,
-      workerType: this.workerType,
-      hasSharedWorkerPort: !!this.sharedWorkerPort,
-      hasServiceWorkerReg: !!this.serviceWorkerRegistration
-    }), this.workerType === "shared" && this.sharedWorkerPort)
-      return new Promise((o, s) => {
-        const a = new MessageChannel(), h = Math.random().toString(36).substring(7), u = Date.now(), g = setTimeout(() => {
-          const l = Date.now() - u;
-          i.error("[WorkerClient] Request timeout:", {
-            type: e,
-            requestId: h,
-            elapsed: l,
-            timeoutMs: t
-          }), a.port1.onmessage = null, s(new Error("Request timeout"));
-        }, t);
-        a.port1.onmessage = (l) => {
-          try {
-            const n = Date.now() - u;
-            i.log("[WorkerClient] Request response received:", {
-              type: e,
-              requestId: h,
-              elapsed: n,
-              success: l.data?.success
-            }), clearTimeout(g), l.data && l.data.success ? o(l.data) : l.data && l.data.success === !1 ? s(new Error(l.data.error || "Worker error")) : o(l.data);
-          } catch (n) {
-            clearTimeout(g), a.port1.onmessage = null, s(
-              n instanceof Error ? n : new Error(String(n))
-            );
-          }
-        };
-        try {
-          const l = this.sharedWorkerPort;
-          if (!l)
-            return clearTimeout(g), i.error("[WorkerClient] SharedWorker port not available"), s(new Error("SharedWorker port not available"));
-          i.log("[WorkerClient] Posting message to SharedWorker:", {
-            type: e,
-            requestId: h
-          }), l.postMessage({ type: e, ...r || {} }, [a.port2]);
-        } catch (l) {
-          clearTimeout(g), i.error("[WorkerClient] Failed to post message:", l), s(l instanceof Error ? l : new Error(String(l)));
-        }
-      });
-    if (this.workerType === "service" && this.serviceWorkerRegistration) {
-      const o = this.serviceWorkerRegistration;
-      if (!o) throw new Error("Service worker registration missing");
-      if (!o.active && (i.log("[WorkerClient] ServiceWorker not active, waiting..."), await navigator.serviceWorker.ready, !o.active))
-        throw new Error("Service worker not active");
-      return new Promise((s, a) => {
-        const h = new MessageChannel(), u = Math.random().toString(36).substring(7), g = Date.now(), l = setTimeout(() => {
-          const n = Date.now() - g;
-          i.error("[WorkerClient] ServiceWorker request timeout:", {
-            type: e,
-            requestId: u,
-            elapsed: n,
-            timeoutMs: t
-          }), h.port1.onmessage = null, a(new Error("Request timeout"));
-        }, t);
-        h.port1.onmessage = (n) => {
-          try {
-            const W = Date.now() - g;
-            i.log("[WorkerClient] ServiceWorker response received:", {
-              type: e,
-              requestId: u,
-              elapsed: W,
-              success: n.data?.success
-            }), clearTimeout(l), n.data && n.data.success ? s(n.data) : n.data && n.data.success === !1 ? a(new Error(n.data.error || "Worker error")) : s(n.data);
-          } catch (W) {
-            clearTimeout(l), h.port1.onmessage = null, a(
-              W instanceof Error ? W : new Error(String(W))
-            );
-          }
-        };
-        try {
-          const n = o.active;
-          if (!n)
-            return clearTimeout(l), i.error(
-              "[WorkerClient] ServiceWorker active instance not available"
-            ), a(
-              new Error("Service worker active instance not available")
-            );
-          i.log("[WorkerClient] Posting message to ServiceWorker:", {
-            type: e,
-            requestId: u
-          }), n.postMessage({ type: e, ...r || {} }, [h.port2]);
-        } catch (n) {
-          clearTimeout(l), i.error(
-            "[WorkerClient] Failed to post message to ServiceWorker:",
-            n
-          ), a(n instanceof Error ? n : new Error(String(n)));
-        }
-      });
-    }
-    throw new Error("No worker registered");
-  }
-  // Fire-and-forget postMessage (no response expected)
-  async post(e, r) {
-    if (this.workerType === "shared" && this.sharedWorkerPort) {
-      try {
-        this.sharedWorkerPort.postMessage({ type: e, ...r || {} });
-      } catch (t) {
-        i.error("[WorkerClient] Failed to post to SharedWorker:", t);
-      }
-      return;
-    }
-    if (this.workerType === "service" && this.serviceWorkerRegistration?.active) {
-      try {
-        this.serviceWorkerRegistration.active.postMessage({
-          type: e,
-          ...r || {}
-        });
-      } catch (t) {
-        i.error(
-          "[WorkerClient] Failed to post to ServiceWorker (active):",
-          t
-        );
-      }
-      return;
-    }
-    if ("serviceWorker" in navigator && navigator.serviceWorker.controller) {
-      try {
-        navigator.serviceWorker.controller.postMessage({
-          type: e,
-          ...r || {}
-        });
-      } catch (t) {
-        i.error(
-          "[WorkerClient] Failed to post to ServiceWorker.controller:",
-          t
-        );
-      }
-      return;
-    }
-    if (e === "SET_AUTH_TOKEN" && r) {
-      const t = r.token;
-      typeof t == "string" && (this.pendingAuthToken = t);
-    }
-  }
-  sendAuthTokenToServiceWorker(e) {
-    if (this.serviceWorkerRegistration?.active)
-      try {
-        this.serviceWorkerRegistration.active.postMessage({
-          type: "SET_AUTH_TOKEN",
-          token: e
-        });
-      } catch (r) {
-        console.error(
-          "[WorkerClient] Failed to send auth token to ServiceWorker:",
-          r
-        );
-      }
-    else if ("serviceWorker" in navigator && navigator.serviceWorker.controller)
-      try {
-        navigator.serviceWorker.controller.postMessage({
-          type: "SET_AUTH_TOKEN",
-          token: e
-        });
-      } catch (r) {
-        console.error(
-          "[WorkerClient] Failed to send auth token to ServiceWorker.controller:",
-          r
-        );
-      }
-    else
-      this.pendingAuthToken = e;
-  }
-  // Subscription API for consumers to listen for connection status updates
-  onConnectionStatus(e) {
-    this.connectionStatusCallbacks.add(e);
-  }
-  offConnectionStatus(e) {
-    this.connectionStatusCallbacks.delete(e);
-  }
-  async getConnectionStatus() {
-    try {
-      const e = await this.request(
-        "GET_CONNECTION_STATUS",
-        void 0,
-        2e3
-      );
-      return e && typeof e == "object" && "connected" in e ? !!e.connected : !!e?.connected;
-    } catch {
-      return !1;
-    }
-  }
-  setAuthToken(e) {
-    if (this.pendingAuthToken = e, this.workerType === "shared" && this.sharedWorkerPort)
-      try {
-        this.sharedWorkerPort.postMessage({ type: "SET_AUTH_TOKEN", token: e }), this.pendingAuthToken = null;
-      } catch (r) {
-        i.error(
-          "[WorkerClient] Failed to set auth token on SharedWorker:",
-          r
-        );
-      }
-    else this.workerType === "service" && (this.sendAuthTokenToServiceWorker(e), this.pendingAuthToken = null);
-  }
-  /**
-   * Register a custom MCP tool dynamically
-   *
-   * The handler function runs in the MAIN THREAD (browser context), not in the worker.
-   * This means you have full access to:
-   * - React context, hooks, Redux store
-   * - DOM API, window, localStorage
-   * - All your imports and dependencies
-   * - Closures and external variables
-   *
-   * The worker acts as a proxy - it receives MCP tool calls and forwards them
-   * to your handler via MessageChannel.
-   *
-   * @param name - Tool name
-   * @param description - Tool description
-   * @param inputSchema - JSON Schema for tool inputs
-   * @param handler - Async function that handles the tool execution (runs in main thread)
-   * @returns Promise that resolves when tool is registered
-   *
-   * @example With full access to imports and context:
-   * ```typescript
-   * import { z } from 'zod';
-   * import { useMyStore } from './store';
-   *
-   * const store = useMyStore();
-   *
-   * await client.registerTool(
-   *   'validate_user',
-   *   'Validate user data',
-   *   { type: 'object', properties: { username: { type: 'string' } } },
-   *   async (args: any) => {
-   *     // Full access to everything!
-   *     const schema = z.object({ username: z.string().min(3) });
-   *     const validated = schema.parse(args);
-   *
-   *     // Can access store, context, etc.
-   *     const currentUser = store.getState().user;
-   *
-   *     return {
-   *       content: [{
-   *         type: 'text',
-   *         text: JSON.stringify({ validated, currentUser })
-   *       }]
-   *     };
-   *   }
-   * );
-   * ```
-   */
-  async registerTool(e, r, t, o) {
-    return this.isInitialized ? this.registerToolInternal(e, r, t, o) : (i.log(
-      `[WorkerClient] Queueing tool registration '${e}' (worker not initialized yet)`
-    ), new Promise((s, a) => {
-      this.pendingRegistrations.push({
-        name: e,
-        description: r,
-        inputSchema: t,
-        handler: o,
-        resolve: s,
-        reject: a
-      });
-    }));
-  }
-  /**
-   * Internal method to register tool (assumes worker is initialized)
-   * @private
-   */
-  async registerToolInternal(e, r, t, o) {
-    const s = this.toolRegistry.get(e);
-    if (s) {
-      s.refCount++, i.log(
-        `[WorkerClient] Incremented ref count for '${e}': ${s.refCount}`
-      ), this.toolHandlers.set(e, o), this.notifyToolChange(e);
-      return;
-    }
-    this.toolHandlers.set(e, o), await this.request("REGISTER_TOOL", {
-      name: e,
-      description: r,
-      inputSchema: t,
-      handlerType: "proxy"
-      // Tell worker this is a proxy handler
-    }), this.toolRegistry.set(e, {
-      refCount: 1,
-      description: r,
-      inputSchema: t,
-      isRegistered: !0
-    }), i.log(
-      `[WorkerClient] Registered tool '${e}' with main-thread handler`
-    ), this.notifyToolChange(e);
-  }
-  /**
-   * Unregister a previously registered MCP tool
-   * @param name - Tool name to unregister
-   * @returns Promise that resolves to true if tool was found and removed
-   */
-  async unregisterTool(e) {
-    const r = this.toolRegistry.get(e);
-    if (!r)
-      return i.warn(`[WorkerClient] Cannot unregister '${e}': not found`), !1;
-    if (r.refCount--, i.log(
-      `[WorkerClient] Decremented ref count for '${e}': ${r.refCount}`
-    ), r.refCount <= 0) {
-      this.toolHandlers.delete(e);
-      const t = await this.request(
-        "UNREGISTER_TOOL",
-        { name: e }
-      );
-      return this.toolRegistry.delete(e), i.log(`[WorkerClient] Unregistered tool '${e}'`), this.notifyToolChange(e), t?.success ?? !1;
-    }
-    return this.notifyToolChange(e), !0;
-  }
-  /**
-   * Subscribe to tool changes for a specific tool
-   * Returns unsubscribe function
-   */
-  onToolChange(e, r) {
-    this.toolChangeListeners.has(e) || this.toolChangeListeners.set(e, /* @__PURE__ */ new Set());
-    const t = this.toolChangeListeners.get(e);
-    t.add(r);
-    const o = this.toolRegistry.get(e);
-    return r(o ? {
-      refCount: o.refCount,
-      isRegistered: o.isRegistered
-    } : null), () => {
-      t.delete(r), t.size === 0 && this.toolChangeListeners.delete(e);
-    };
-  }
-  /**
-   * Notify all listeners about tool changes
-   * @private
-   */
-  notifyToolChange(e) {
-    const r = this.toolChangeListeners.get(e);
-    if (!r || r.size === 0) return;
-    const t = this.toolRegistry.get(e), o = t ? {
-      refCount: t.refCount,
-      isRegistered: t.isRegistered
-    } : null;
-    r.forEach((s) => {
-      try {
-        s(o);
-      } catch (a) {
-        i.error("[WorkerClient] Error in tool change listener:", a);
-      }
-    });
-  }
-  /**
-   * Get tool info from registry
-   */
-  getToolInfo(e) {
-    const r = this.toolRegistry.get(e);
-    return r ? {
-      refCount: r.refCount,
-      isRegistered: r.isRegistered
-    } : null;
-  }
-  /**
-   * Get all registered tool names
-   */
-  getRegisteredTools() {
-    return Array.from(this.toolRegistry.keys()).filter(
-      (e) => this.toolRegistry.get(e)?.isRegistered
-    );
-  }
-  /**
-   * Check if a tool is registered
-   */
-  isToolRegistered(e) {
-    return this.toolRegistry.get(e)?.isRegistered ?? !1;
-  }
-  /**
-   * Handle tool call from worker - execute handler in main thread and return result
-   * @private
-   */
-  async handleToolCall(e, r, t) {
-    i.log(`[WorkerClient] Handling tool call: ${e}`, {
-      callId: t,
-      args: r
-    });
-    try {
-      const o = this.toolHandlers.get(e);
-      if (!o)
-        throw new Error(`Tool handler not found: ${e}`);
-      const s = await o(r);
-      this.sendToolCallResult(t, { success: !0, result: s });
-    } catch (o) {
-      i.error(`[WorkerClient] Tool call failed: ${e}`, o), this.sendToolCallResult(t, {
-        success: !1,
-        error: o instanceof Error ? o.message : "Unknown error"
-      });
-    }
-  }
-  /**
-   * Send tool call result back to worker
-   * @private
-   */
-  sendToolCallResult(e, r) {
-    const t = {
-      type: "TOOL_CALL_RESULT",
-      callId: e,
-      success: r.success,
-      result: r.result,
-      error: r.error
-    };
-    if (this.workerType === "shared" && this.sharedWorkerPort)
-      try {
-        this.sharedWorkerPort.postMessage(t);
-      } catch (o) {
-        i.error(
-          "[WorkerClient] Failed to send result to SharedWorker:",
-          o
-        );
-      }
-    else if (this.workerType === "service" && this.serviceWorkerRegistration?.active)
-      try {
-        this.serviceWorkerRegistration.active.postMessage(t);
-      } catch (o) {
-        i.error(
-          "[WorkerClient] Failed to send result to ServiceWorker:",
-          o
-        );
-      }
-  }
-}
-const T = new _();
-function b(c) {
+import { useState as m, useRef as P, useEffect as M, useCallback as f, createContext as $, useContext as I } from "react";
+import { workerClient as u } from "@mcp-fe/mcp-worker";
+import { jsx as A } from "react/jsx-runtime";
+function b(t) {
   const {
     name: e,
-    description: r,
-    inputSchema: t,
-    handler: o,
-    autoRegister: s = !0,
-    autoUnregister: a = !0
-  } = c, [h, u] = R(null), g = v(o), l = v(e), n = v(r), W = v(t), P = v(!0), k = v(!1);
-  w(() => {
-    g.current = o, l.current = e, n.current = r, W.current = t;
-  }, [o, e, r, t]);
-  const f = C(async (d) => g.current(d), []), y = C(async () => {
-    const d = l.current, p = n.current, A = W.current;
+    description: s,
+    inputSchema: i,
+    handler: r,
+    autoRegister: a = !0,
+    autoUnregister: l = !0
+  } = t, [d, p] = m(null), g = P(r), T = P(e), C = P(s), w = P(i), v = P(!0), n = P(!1);
+  M(() => {
+    g.current = r, T.current = e, C.current = s, w.current = i;
+  }, [r, e, s, i]);
+  const c = f(async (o) => g.current(o), []), y = f(async () => {
+    const o = T.current, h = C.current, z = w.current;
     try {
-      await T.registerTool(
-        d,
-        p,
-        A,
-        f
-      ), k.current = !0, console.log(`[useMCPTool] Registered tool '${d}'`);
-    } catch (M) {
+      await u.registerTool(
+        o,
+        h,
+        z,
+        c
+      ), n.current = !0, console.log(`[useMCPTool] Registered tool '${o}'`);
+    } catch (S) {
       throw console.error(
-        `[useMCPTool] Failed to register tool '${d}':`,
-        M
-      ), M;
+        `[useMCPTool] Failed to register tool '${o}':`,
+        S
+      ), S;
     }
-  }, [f]), S = C(async () => {
-    const d = l.current;
+  }, [c]), R = f(async () => {
+    const o = T.current;
     try {
-      await T.unregisterTool(d), k.current = !1, console.log(`[useMCPTool] Unregistered tool '${d}'`);
-    } catch (p) {
+      await u.unregisterTool(o), n.current = !1, console.log(`[useMCPTool] Unregistered tool '${o}'`);
+    } catch (h) {
       console.error(
-        `[useMCPTool] Failed to unregister tool '${d}':`,
-        p
+        `[useMCPTool] Failed to unregister tool '${o}':`,
+        h
       );
     }
   }, []);
-  return w(() => T.onToolChange(e, (p) => {
-    u(p);
-  }), [e]), w(() => (s && y().catch((d) => {
+  return M(() => u.onToolChange(e, (h) => {
+    p(h);
+  }), [e]), M(() => (a && y().catch((o) => {
     console.error(
       `[useMCPTool] Auto-register failed for '${e}':`,
-      d
+      o
     );
   }), () => {
-    P.current = !1, a && k.current && S().catch((d) => {
+    v.current = !1, l && n.current && R().catch((o) => {
       console.error(
         `[useMCPTool] Auto-unregister failed for '${e}':`,
-        d
+        o
       );
     });
   }), [e]), {
-    isRegistered: h?.isRegistered ?? !1,
-    refCount: h?.refCount ?? 0,
+    isRegistered: d?.isRegistered ?? !1,
+    refCount: d?.refCount ?? 0,
     register: y,
-    unregister: S
+    unregister: R
   };
 }
-function O(c) {
-  return T.isToolRegistered(c);
+function k(t) {
+  return u.isToolRegistered(t);
 }
-function $() {
-  return T.getRegisteredTools();
+function q() {
+  return u.getRegisteredTools();
 }
-function q(c) {
-  return T.getToolInfo(c);
+function U(t) {
+  return u.getToolInfo(t);
 }
-function D(c, e, r, t) {
-  const o = C(async () => {
-    const s = await r();
+function F(t, e, s, i) {
+  const r = f(async () => {
+    const a = await s();
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify(s, null, 2)
+          text: JSON.stringify(a, null, 2)
         }
       ]
     };
-  }, [r]);
+  }, [s]);
   return b({
-    name: c,
+    name: t,
     description: e,
     inputSchema: {
       type: "object",
       properties: {}
     },
-    handler: o,
-    ...t
+    handler: r,
+    ...i
   });
 }
-function H(c, e, r, t, o) {
-  const s = C(
-    async (a) => {
-      const h = await t(a);
+function H(t, e, s, i, r) {
+  const a = f(
+    async (l) => {
+      const d = await i(l);
       return {
         content: [
           {
             type: "text",
-            text: JSON.stringify(h, null, 2)
+            text: JSON.stringify(d, null, 2)
           }
         ]
       };
     },
-    [t]
+    [i]
   );
   return b({
-    name: c,
+    name: t,
     description: e,
     inputSchema: {
       type: "object",
-      properties: r,
-      ...o?.required && { required: o.required }
+      properties: s,
+      ...r?.required && { required: r.required }
     },
-    handler: s,
-    autoRegister: o?.autoRegister,
-    autoUnregister: o?.autoUnregister
+    handler: a,
+    autoRegister: r?.autoRegister,
+    autoUnregister: r?.autoUnregister
   });
 }
-const E = x(null);
-function G({
-  children: c,
+const x = $(null);
+function J({
+  children: t,
   autoInit: e = !0,
-  backendWsUrl: r = "ws://localhost:3001",
-  initOptions: t,
-  onInitialized: o,
-  onInitError: s
+  backendWsUrl: s = "ws://localhost:3001",
+  initOptions: i,
+  onInitialized: r,
+  onInitError: a
 }) {
-  const [a, h] = R(!1), [u, g] = R(!1), [l] = R([]), n = C(
-    async (k) => {
-      if (a) {
+  const [l, d] = m(!1), [p, g] = m(!1), [T] = m([]), C = f(
+    async (n) => {
+      if (l) {
         console.log("[MCPToolsProvider] Already initialized");
         return;
       }
       try {
-        const f = k || t || { backendWsUrl: r };
-        console.log("[MCPToolsProvider] Initializing worker client...", f), await T.init(f), h(!0);
-        const y = await T.getConnectionStatus();
-        g(y), T.onConnectionStatus((S) => {
-          g(S);
-        }), console.log("[MCPToolsProvider] Worker client initialized"), o?.();
-      } catch (f) {
-        throw console.error("[MCPToolsProvider] Initialization failed:", f), s?.(
-          f instanceof Error ? f : new Error(String(f))
-        ), f;
+        const c = n || i || { backendWsUrl: s };
+        console.log("[MCPToolsProvider] Initializing worker client...", c), await u.init(c), d(!0);
+        const y = await u.getConnectionStatus();
+        g(y), u.onConnectionStatus((R) => {
+          g(R);
+        }), console.log("[MCPToolsProvider] Worker client initialized"), r?.();
+      } catch (c) {
+        throw console.error("[MCPToolsProvider] Initialization failed:", c), a?.(
+          c instanceof Error ? c : new Error(String(c))
+        ), c;
       }
     },
-    [a, t, r, o, s]
-  ), W = C(async () => {
-    const k = await T.getConnectionStatus();
-    return g(k), k;
+    [l, i, s, r, a]
+  ), w = f(async () => {
+    const n = await u.getConnectionStatus();
+    return g(n), n;
   }, []);
-  w(() => {
-    e && n().catch((k) => {
-      console.error("[MCPToolsProvider] Auto-init failed:", k);
+  M(() => {
+    e && C().catch((n) => {
+      console.error("[MCPToolsProvider] Auto-init failed:", n);
     });
-  }, [e, n]), w(() => {
-    if (!a) return;
-    const k = setInterval(() => {
+  }, [e, C]), M(() => {
+    if (!l) return;
+    const n = setInterval(() => {
     }, 5e3);
-    return () => clearInterval(k);
-  }, [a]);
-  const P = {
-    isInitialized: a,
-    isConnected: u,
-    registeredTools: l,
-    initialize: n,
-    getConnectionStatus: W
+    return () => clearInterval(n);
+  }, [l]);
+  const v = {
+    isInitialized: l,
+    isConnected: p,
+    registeredTools: T,
+    initialize: C,
+    getConnectionStatus: w
   };
-  return /* @__PURE__ */ z(E.Provider, { value: P, children: c });
+  return /* @__PURE__ */ A(x.Provider, { value: v, children: t });
 }
-function K(c = !1) {
-  const e = U(E);
-  if (!e && c)
+function D(t = !1) {
+  const e = I(x);
+  if (!e && t)
     throw new Error(
       "useMCPToolsContext must be used within MCPToolsProvider. Either wrap your component tree with <MCPToolsProvider> or set strict=false."
     );
@@ -863,17 +188,17 @@ function K(c = !1) {
     getConnectionStatus: async () => !1
   };
 }
-function J() {
-  return U(E) !== null;
+function G() {
+  return I(x) !== null;
 }
 export {
-  G as MCPToolsProvider,
-  $ as getRegisteredTools,
-  q as getToolInfo,
-  O as isToolRegistered,
-  J as useHasMCPProvider,
+  J as MCPToolsProvider,
+  q as getRegisteredTools,
+  U as getToolInfo,
+  k as isToolRegistered,
+  G as useHasMCPProvider,
   H as useMCPAction,
-  D as useMCPGetter,
+  F as useMCPGetter,
   b as useMCPTool,
-  K as useMCPToolsContext
+  D as useMCPToolsContext
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-fe/react-tools",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "license": "Apache-2.0",
   "homepage": "https://mcp-fe.ai",
   "repository": {
@@ -18,10 +18,8 @@
       "default": "./index.mjs"
     }
   },
-  "dependencies": {
-    "@mcp-fe/mcp-worker": "0.1.2"
-  },
   "peerDependencies": {
+    "@mcp-fe/mcp-worker": "^0.1.4",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },