simple-webmcp 0.2.0 → 0.3.0

package/dist/react.cjs

@@ -81,6 +81,11 @@ var RegistrationError = class extends SimpleWebMCPError {
     super(message, "REGISTRATION_ERROR", opts?.cause);
   }
 };
+var ValidationError = class extends SimpleWebMCPError {
+  constructor(message, opts) {
+    super(message, "VALIDATION_ERROR", opts?.cause);
+  }
+};
 var ConfigurationError = class extends SimpleWebMCPError {
   constructor(message, opts) {
     super(message, "CONFIGURATION_ERROR", opts?.cause);
@@ -587,7 +592,12 @@ function normalizeResult(value) {
   }
 }
 function normalizeError(err) {
-  const message = err instanceof Error ? err.message : typeof err === "string" ? err : (() => {
+  const message = (() => {
+    if (err instanceof Error) return err.message;
+    if (typeof err === "string") return err;
+    if (err && typeof err === "object" && "message" in err && typeof err.message === "string") {
+      return err.message;
+    }
     try {
       return JSON.stringify(err);
     } catch {
@@ -599,20 +609,247 @@ function normalizeError(err) {
     isError: true
   };
 }
-function wrapExecute(fn, opts) {
+
+// src/hooks/engine.ts
+var fallbackCounter = 0;
+function genInvocationId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return fallbackInvocationId();
+}
+function fallbackInvocationId() {
+  fallbackCounter = (fallbackCounter + 1) % Number.MAX_SAFE_INTEGER;
+  return `webmcp_${Date.now().toString(36)}_${fallbackCounter}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function isDenyResult(r) {
+  return !!r && typeof r === "object" && r.action === "deny";
+}
+async function runErrorHooks(hooks, ctx) {
+  if (!hooks || hooks.length === 0) return;
+  for (const h of hooks) {
+    try {
+      await h(ctx);
+    } catch {
+    }
+  }
+}
+async function runDeniedHooks(hooks, ctx) {
+  if (!hooks || hooks.length === 0) return;
+  for (const h of hooks) {
+    try {
+      await h(ctx);
+    } catch {
+    }
+  }
+}
+function createHookedExecute(fn, tool, contract, options) {
   return async (args, _ctx) => {
+    const invocationId = genInvocationId();
+    const metadata = {};
+    const signal = tool.__activeSignal ?? createNeverAbortedSignal();
+    const merged = options.getHooks();
+    let currentInput = args;
+    const base = { invocationId, tool, contract, signal, metadata };
+    const beforeHooks = merged.before ?? [];
+    for (const hook of beforeHooks) {
+      if (signal.aborted) {
+        const abortErr = new DOMException("Aborted", "AbortError");
+        await runErrorHooks(merged.error, {
+          ...base,
+          input: currentInput,
+          error: abortErr
+        });
+        return normalizeError(abortErr);
+      }
+      let res;
+      try {
+        const ctx = { ...base, input: currentInput };
+        res = await hook(ctx);
+      } catch (hookErr) {
+        await runErrorHooks(merged.error, {
+          ...base,
+          input: currentInput,
+          error: hookErr
+        });
+        return normalizeError(hookErr);
+      }
+      if (res != null && typeof res === "object") {
+        if (isDenyResult(res)) {
+          const reason = res.message;
+          const code = res.code;
+          await runDeniedHooks(merged.denied, {
+            ...base,
+            input: currentInput,
+            reason,
+            code
+          });
+          const msg = reason ?? "Tool execution denied";
+          return {
+            content: [{ type: "text", text: `Denied: ${msg}` }],
+            isError: true,
+            ...code ? { code } : {}
+          };
+        }
+        if ("input" in res && res.input !== void 0) {
+          currentInput = res.input;
+        }
+      }
+    }
+    if (signal.aborted) {
+      const abortErr = new DOMException("Aborted", "AbortError");
+      await runErrorHooks(merged.error, {
+        ...base,
+        input: currentInput,
+        error: abortErr
+      });
+      return normalizeError(abortErr);
+    }
+    if (options.validate) {
+      try {
+        options.validate(currentInput);
+      } catch (valErr) {
+        await runErrorHooks(merged.error, {
+          ...base,
+          input: currentInput,
+          error: valErr
+        });
+        return normalizeError(valErr);
+      }
+    }
+    let rawOutput;
     try {
-      let result;
-      const mode = opts?.argMode ?? "object";
-      if (mode === "spread" && args && typeof args === "object" && !Array.isArray(args)) ; else {
-        result = await fn(args);
+      rawOutput = await fn(currentInput);
+    } catch (fnErr) {
+      await runErrorHooks(merged.error, {
+        ...base,
+        input: currentInput,
+        error: fnErr
+      });
+      return normalizeError(fnErr);
+    }
+    let currentOutput = rawOutput;
+    const afterHooks = merged.after ?? [];
+    for (const hook of afterHooks) {
+      if (signal.aborted) ;
+      try {
+        const ctx = {
+          ...base,
+          input: currentInput,
+          output: currentOutput
+        };
+        const res = await hook(ctx);
+        if (res != null && typeof res === "object" && "output" in res && res.output !== void 0) {
+          currentOutput = res.output;
+        }
+      } catch (hookErr) {
+        await runErrorHooks(merged.error, {
+          ...base,
+          input: currentInput,
+          error: hookErr
+        });
+        return normalizeError(hookErr);
       }
-      return normalizeResult(result);
-    } catch (err) {
-      return normalizeError(err);
     }
+    return normalizeResult(currentOutput);
   };
 }
+function createNeverAbortedSignal() {
+  try {
+    return new AbortController().signal;
+  } catch {
+    return {
+      aborted: false,
+      addEventListener() {
+      },
+      removeEventListener() {
+      },
+      dispatchEvent() {
+        return false;
+      },
+      onabort: null,
+      reason: void 0,
+      throwIfAborted() {
+      }
+    };
+  }
+}
+
+// src/hooks/config.ts
+var GLOBAL_KEY = "__simpleWebmcp_hooks";
+function getStore() {
+  const g = globalThis;
+  if (!g[GLOBAL_KEY]) {
+    g[GLOBAL_KEY] = { hooks: {} };
+  }
+  return g[GLOBAL_KEY];
+}
+function getGlobalHooks() {
+  return getStore().hooks ?? {};
+}
+function configureWebMCP(opts) {
+  const store = getStore();
+  if (!opts.hooks) return;
+  if (opts.replace) {
+    store.hooks = normalizeHooks(opts.hooks);
+    return;
+  }
+  store.hooks = mergeHooks(store.hooks, opts.hooks);
+}
+function resetGlobalHooks() {
+  const store = getStore();
+  store.hooks = {};
+}
+function normalizeHooks(hooks) {
+  return {
+    before: hooks.before ? [...hooks.before] : void 0,
+    after: hooks.after ? [...hooks.after] : void 0,
+    error: hooks.error ? [...hooks.error] : void 0,
+    denied: hooks.denied ? [...hooks.denied] : void 0
+  };
+}
+function mergeHooks(a, b) {
+  if (!a && !b) return {};
+  if (!a) return normalizeHooks(b);
+  if (!b) return a;
+  return {
+    before: [...a.before ?? [], ...b.before ?? []],
+    after: [...a.after ?? [], ...b.after ?? []],
+    error: [...a.error ?? [], ...b.error ?? []],
+    denied: [...a.denied ?? [], ...b.denied ?? []]
+  };
+}
+function mergeHooksOrdered(opts) {
+  const globalHooks = opts.globalHooks ?? {};
+  const scopedHooks = opts.scopedHooks ?? {};
+  const toolHooks = opts.toolHooks ?? {};
+  const before = [
+    ...globalHooks.before ?? [],
+    ...scopedHooks.before ?? [],
+    ...toolHooks.before ?? []
+  ];
+  const after = [
+    ...toolHooks.after ?? [],
+    ...scopedHooks.after ?? [],
+    ...globalHooks.after ?? []
+  ];
+  const error = [
+    ...toolHooks.error ?? [],
+    ...scopedHooks.error ?? [],
+    ...globalHooks.error ?? []
+  ];
+  const denied = [
+    ...toolHooks.denied ?? [],
+    ...scopedHooks.denied ?? [],
+    ...globalHooks.denied ?? []
+  ];
+  const out = {};
+  if (before.length) out.before = before;
+  if (after.length) out.after = after;
+  if (error.length) out.error = error;
+  if (denied.length) out.denied = denied;
+  return out;
+}
 
 // src/webmcp.ts
 function resolveScope(opts) {
@@ -627,8 +864,24 @@ function webmcp(fn, options) {
   const anyFn = fn;
   if (anyFn.__webmcpBrand === true && anyFn.definition) {
     if (!options || Object.keys(options).length === 0) return anyFn;
+    const prevOpts = anyFn.__webmcpOptions || {};
+    const mergedOpts = { ...prevOpts, ...options };
+    if (prevOpts.hooks || options?.hooks) {
+      const prevHooks = prevOpts.hooks ?? {};
+      const nextHooks = options.hooks ?? {};
+      mergedOpts.hooks = {
+        before: [...prevHooks.before ?? [], ...nextHooks.before ?? []],
+        after: [...prevHooks.after ?? [], ...nextHooks.after ?? []],
+        error: [...prevHooks.error ?? [], ...nextHooks.error ?? []],
+        denied: [...prevHooks.denied ?? [], ...nextHooks.denied ?? []]
+      };
+      for (const k of ["before", "after", "error", "denied"]) {
+        if (mergedOpts.hooks[k]?.length === 0) delete mergedOpts.hooks[k];
+      }
+      if (mergedOpts.hooks && Object.keys(mergedOpts.hooks).length === 0) delete mergedOpts.hooks;
+    }
     const original = anyFn.__fn ?? fn;
-    return webmcp(original, { ...anyFn.__webmcpOptions || {}, ...options });
+    return webmcp(original, mergedOpts);
   }
   const name = options?.name ?? toSnakeCase(getFunctionName(fn));
   if (!name) throw new ConfigurationError('Tool name could not be inferred \u2014 pass {name:"my_tool"}');
@@ -681,15 +934,30 @@ function webmcp(fn, options) {
   let registrationPromise = null;
   let unregisterFn = null;
   let activeController = null;
-  const wrappedExec = wrapExecute(fn);
+  const toolHooks = options?.hooks ? { ...options.hooks } : void 0;
   const toolWrapper = wrapper;
   toolWrapper.__webmcpBrand = true;
   toolWrapper.__fn = fn;
   toolWrapper.__webmcpOptions = options;
   if (standard) toolWrapper.__standardSchema = standard;
   if (outNorm.standard) toolWrapper.__outputStandardSchema = outNorm.standard;
+  if (toolHooks) toolWrapper.__hooks = toolHooks;
   toolWrapper.tool = contract;
   toolWrapper.definition = contract;
+  const hookedExec = createHookedExecute(fn, toolWrapper, contract, {
+    getHooks: () => {
+      const globalHooks = getGlobalHooks();
+      const scopeHooks = toolWrapper.__scopeHooks;
+      return mergeHooksOrdered({ globalHooks, scopedHooks: scopeHooks, toolHooks });
+    },
+    validate: standard ? (input) => {
+      const res = standard["~standard"].validate(input);
+      if ("issues" in res && res.issues && res.issues.length > 0) {
+        const msg = res.issues.map((i) => i.message).join("; ");
+        throw new ValidationError(`Validation failed: ${msg}`);
+      }
+    } : void 0
+  });
   Object.defineProperty(toolWrapper, "status", {
     get() {
       return status;
@@ -722,11 +990,16 @@ function webmcp(fn, options) {
     status = "registering";
     const controller = new AbortController();
     activeController = controller;
+    toolWrapper.__activeSignal = controller.signal;
     if (opts?.signal) {
       if (opts.signal.aborted) {
         controller.abort();
         status = "unregistered";
         activeController = null;
+        try {
+          delete toolWrapper.__activeSignal;
+        } catch {
+        }
         return () => {
         };
       }
@@ -741,11 +1014,15 @@ function webmcp(fn, options) {
     controller.signal.addEventListener("abort", () => {
       if (status !== "unregistered") status = "unregistered";
       activeController = null;
+      try {
+        delete toolWrapper.__activeSignal;
+      } catch {
+      }
     }, { once: true });
     try {
       const unregister = await registry.register(contract, {
         signal: controller.signal,
-        execute: wrappedExec
+        execute: hookedExec
       });
       unregisterFn = unregister;
       registrationPromise = Promise.resolve();
@@ -763,6 +1040,10 @@ function webmcp(fn, options) {
         }
         status = "unregistered";
         activeController = null;
+        try {
+          delete toolWrapper.__activeSignal;
+        } catch {
+        }
         unregisterFn = null;
       };
     } catch (err) {
@@ -771,6 +1052,11 @@ function webmcp(fn, options) {
       } else {
         status = "error";
       }
+      activeController = null;
+      try {
+        delete toolWrapper.__activeSignal;
+      } catch {
+      }
       registrationPromise = Promise.reject(err);
       if (err instanceof SimpleWebMCPError) throw err;
       throw err;
@@ -789,6 +1075,10 @@ function webmcp(fn, options) {
     }
     status = "unregistered";
     activeController = null;
+    try {
+      delete toolWrapper.__activeSignal;
+    } catch {
+    }
     unregisterFn = null;
     registrationPromise = null;
   };
@@ -807,9 +1097,30 @@ function webmcp(fn, options) {
 webmcp.global = function global(fn, opts) {
   return webmcp(fn, { ...opts, global: true });
 };
+webmcp.configure = configureWebMCP;
+webmcp.getGlobalHooks = getGlobalHooks;
+webmcp.resetGlobalHooks = resetGlobalHooks;
 webmcp.isWebMCPTool = function isWebMCPTool(v) {
   return !!v?.__webmcpBrand;
 };
+var WebMCPHooksContext = react.createContext({});
+function WebMCPProvider({ hooks, children }) {
+  const parent = react.useContext(WebMCPHooksContext);
+  const merged = react.useMemo(() => {
+    if (!hooks) return parent;
+    if (!parent || Object.keys(parent).length === 0) return hooks;
+    return {
+      before: [...parent.before ?? [], ...hooks.before ?? []],
+      after: [...parent.after ?? [], ...hooks.after ?? []],
+      error: [...parent.error ?? [], ...hooks.error ?? []],
+      denied: [...parent.denied ?? [], ...hooks.denied ?? []]
+    };
+  }, [parent, hooks]);
+  return /* @__PURE__ */ jsxRuntime.jsx(WebMCPHooksContext.Provider, { value: merged, children });
+}
+function useWebMCPHooksContext() {
+  return react.useContext(WebMCPHooksContext);
+}
 
 // src/react/useWebMCP.ts
 function isTool(v) {
@@ -817,6 +1128,7 @@ function isTool(v) {
 }
 function useWebMCP(arg, opts) {
   const enabled = opts?.enabled ?? true;
+  const scopedHooks = useWebMCPHooksContext();
   const isRawFunction = react.useMemo(() => {
     return typeof arg === "function" && !isTool(arg);
   }, [arg]);
@@ -838,6 +1150,7 @@ function useWebMCP(arg, opts) {
     opts?.global,
     opts?.strict,
     opts?.outputSchema,
+    opts?.hooks,
     opts?.enabled
   ]);
   const [registered, setRegistered] = react.useState(false);
@@ -850,6 +1163,31 @@ function useWebMCP(arg, opts) {
   }, [supported]);
   const toolRef = react.useRef(tool);
   toolRef.current = tool;
+  react.useEffect(() => {
+    const t = toolRef.current;
+    const hasScoped = scopedHooks && Object.keys(scopedHooks).length > 0;
+    if (hasScoped) t.__scopeHooks = scopedHooks;
+    else if (t.__scopeHooks) delete t.__scopeHooks;
+    return () => {
+      const cur = t.__scopeHooks;
+      if (cur === scopedHooks) {
+        try {
+          delete t.__scopeHooks;
+        } catch {
+        }
+      }
+    };
+  }, [scopedHooks, tool]);
+  if (scopedHooks && Object.keys(scopedHooks).length > 0) {
+    tool.__scopeHooks = scopedHooks;
+  } else if (tool.__scopeHooks) {
+    if (!(scopedHooks && Object.keys(scopedHooks).length > 0)) {
+      try {
+        delete tool.__scopeHooks;
+      } catch {
+      }
+    }
+  }
   react.useEffect(() => {
     if (!enabled) {
       setRegistered(false);
@@ -941,8 +1279,11 @@ function Scope({ tools, enabled = true, children }) {
 var WebMCPScope = Scope;
 
 exports.Scope = Scope;
+exports.WebMCPHooksContext = WebMCPHooksContext;
+exports.WebMCPProvider = WebMCPProvider;
 exports.WebMCPScope = WebMCPScope;
 exports.useTool = useTool;
 exports.useWebMCP = useWebMCP;
+exports.useWebMCPHooksContext = useWebMCPHooksContext;
 //# sourceMappingURL=react.cjs.map
 //# sourceMappingURL=react.cjs.map