simple-webmcp 0.1.0 → 0.3.0

package/dist/react.js

@@ -1,19 +1,1156 @@
-import { useState, useMemo, useRef, useEffect } from 'react';
-import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
+import { createContext, useContext, useMemo, useState, useRef, useEffect } from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 
 // src/internal/utils.ts
+function toSnakeCase(name) {
+  if (!name) return "anonymous_tool";
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || "anonymous_tool";
+}
+function getFunctionName(fn) {
+  return fn.displayName || fn.name || "";
+}
 function isWebMCPSupported() {
   if (typeof document === "undefined") return false;
   const docAny = document;
   return !!docAny.modelContext && typeof docAny.modelContext.registerTool === "function";
 }
+function getModelContext() {
+  if (typeof document === "undefined") return null;
+  const docAny = document;
+  if (docAny.modelContext && typeof docAny.modelContext.registerTool === "function") {
+    return docAny.modelContext;
+  }
+  return null;
+}
+function looksLikeJsonSchema(value) {
+  if (!value || typeof value !== "object") return false;
+  const obj = value;
+  if ("~standard" in obj) return false;
+  return "type" in obj || "properties" in obj || "$ref" in obj || "anyOf" in obj || "oneOf" in obj || "allOf" in obj || "enum" in obj;
+}
+function isStandardSchema(value) {
+  return !!value && typeof value === "object" && "~standard" in value && value["~standard"]?.validate != null && typeof value["~standard"].validate === "function";
+}
+var warnedNoDesc = false;
+function warnNoDescription(fn) {
+  if (warnedNoDesc) return;
+  warnedNoDesc = true;
+  if (typeof console !== "undefined" && typeof process !== "undefined" && process.env?.NODE_ENV !== "production") {
+    console.warn(
+      `[simple-webmcp] tool "${getFunctionName(fn) || "anonymous"}" has no description. Add \`description:"..."\` or JSDoc. See https://github.com/emingure/simple-webmcp`
+    );
+  } else if (typeof console !== "undefined") {
+    console.warn(`[simple-webmcp] tool "${getFunctionName(fn) || "anonymous"}" has no description.`);
+  }
+}
+
+// src/errors.ts
+var SimpleWebMCPError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = this.constructor.name;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      cause: this.cause
+    };
+  }
+};
+var NotSupportedError = class extends SimpleWebMCPError {
+  constructor(message = "WebMCP is not supported in this environment", opts) {
+    super(message, "NOT_SUPPORTED", opts?.cause);
+  }
+};
+var NotAllowedError = class extends SimpleWebMCPError {
+  constructor(message = "WebMCP tools are blocked by Permissions Policy", opts) {
+    super(message, "NOT_ALLOWED", opts?.cause);
+  }
+};
+var RegistrationError = class extends SimpleWebMCPError {
+  constructor(message, opts) {
+    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);
+  }
+};
+
+// src/internal/inferRuntime.ts
+function parseFunctionSource(fn) {
+  try {
+    return Function.prototype.toString.call(fn);
+  } catch {
+    return "";
+  }
+}
+function parseParamNames(fn) {
+  const src = parseFunctionSource(fn);
+  const clean = src.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, "").replace(/\n/g, " ");
+  let paramBlock = "";
+  const arrowIdx = clean.indexOf("=>");
+  const firstParen = clean.indexOf("(");
+  clean.indexOf("{");
+  if (firstParen !== -1) {
+    let depth = 0;
+    let start = firstParen;
+    let end = -1;
+    for (let i = start; i < clean.length; i++) {
+      const ch = clean[i];
+      if (ch === "(") depth++;
+      else if (ch === ")") {
+        depth--;
+        if (depth === 0) {
+          end = i;
+          break;
+        }
+      }
+    }
+    if (end !== -1) {
+      paramBlock = clean.slice(start + 1, end);
+    }
+  } else if (arrowIdx !== -1) {
+    const beforeArrow = clean.slice(0, arrowIdx).trim();
+    const single = beforeArrow.split(/\s+/).pop() || "";
+    if (single && !single.includes(" ")) {
+      paramBlock = single.replace(/^async\s+/, "");
+    }
+  }
+  if (!paramBlock.trim()) return [];
+  const params = [];
+  let current = "";
+  let depthCurly = 0;
+  let depthBracket = 0;
+  let depthParen = 0;
+  for (let i = 0; i < paramBlock.length; i++) {
+    const ch = paramBlock[i];
+    if (ch === "{") depthCurly++;
+    else if (ch === "}") depthCurly--;
+    else if (ch === "[") depthBracket++;
+    else if (ch === "]") depthBracket--;
+    else if (ch === "(") depthParen++;
+    else if (ch === ")") depthParen--;
+    if (ch === "," && depthCurly === 0 && depthBracket === 0 && depthParen === 0) {
+      const p = current.trim();
+      if (p) params.push(parseSingleParam(p));
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  const last = current.trim();
+  if (last) params.push(parseSingleParam(last));
+  return params;
+}
+function parseSingleParam(raw) {
+  let s = raw.trim();
+  if (s.startsWith("...")) s = s.slice(3).trim();
+  let hasDefault = false;
+  let defaultValue = void 0;
+  let eqIdx = -1;
+  let depth = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === "{" || ch === "(" || ch === "[") depth++;
+    else if (ch === "}" || ch === ")" || ch === "]") depth--;
+    else if (ch === "=" && depth === 0) {
+      eqIdx = i;
+      break;
+    }
+  }
+  let namePart = s;
+  if (eqIdx !== -1) {
+    hasDefault = true;
+    namePart = s.slice(0, eqIdx).trim();
+    const defStr = s.slice(eqIdx + 1).trim();
+    defaultValue = parseDefaultLiteral(defStr);
+  }
+  let name = namePart;
+  if (name.startsWith("{") && name.endsWith("}")) {
+    name = name;
+  } else if (name.startsWith("[")) {
+    name = name;
+  }
+  return { name, hasDefault, defaultValue };
+}
+function parseDefaultLiteral(str) {
+  const t = str.trim().replace(/,$/, "");
+  if (t === "true") return true;
+  if (t === "false") return false;
+  if (t === "null") return null;
+  if (t === "undefined") return void 0;
+  if (/^-?\d+(\.\d+)?$/.test(t)) return Number(t);
+  if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'") || t.startsWith("`") && t.endsWith("`")) {
+    return t.slice(1, -1);
+  }
+  if (t.startsWith("{") || t.startsWith("[")) return void 0;
+  return void 0;
+}
+function inferRuntime(fn) {
+  const params = parseParamNames(fn);
+  const src = parseFunctionSource(fn);
+  const isAsync = /^\s*async\b/.test(src);
+  let isObjectParam = false;
+  let objectKeys = [];
+  if (params.length === 1 && params[0].name.startsWith("{")) {
+    isObjectParam = true;
+    const inner = params[0].name.slice(1, -1);
+    const keys = [];
+    let cur = "";
+    let d = 0;
+    for (let i = 0; i < inner.length; i++) {
+      const ch = inner[i];
+      if (ch === "{" || ch === "[" || ch === "(") d++;
+      else if (ch === "}" || ch === "]" || ch === ")") d--;
+      if (ch === "," && d === 0) {
+        const k = cur.trim();
+        if (k) keys.push(extractKey(k));
+        cur = "";
+      } else cur += ch;
+    }
+    const last = cur.trim();
+    if (last) keys.push(extractKey(last));
+    objectKeys = keys.filter(Boolean);
+  }
+  const inference = {
+    params,
+    isAsync,
+    isObjectParam,
+    objectKeys,
+    confidence: "low"
+  };
+  const schema = {
+    type: "object",
+    properties: {},
+    required: [],
+    additionalProperties: false
+  };
+  if (isObjectParam && objectKeys.length > 0) {
+    const props = {};
+    const required = [];
+    const innerRaw = params[0].name.slice(1, -1);
+    const entries = splitObjectEntries(innerRaw);
+    for (const entry of entries) {
+      const { key, hasDefault, defaultValue } = entry;
+      const prop = {};
+      if (typeof defaultValue === "number") prop.type = "number";
+      else if (typeof defaultValue === "boolean") prop.type = "boolean";
+      if (hasDefault && defaultValue !== void 0) prop.default = defaultValue;
+      props[key] = prop;
+      if (!hasDefault) required.push(key);
+    }
+    schema.properties = props;
+    schema.required = required;
+  } else if (params.length > 0) {
+    const props = {};
+    const required = [];
+    for (const p of params) {
+      let key = p.name;
+      if (key.includes(":")) key = key.split(":")[0].trim();
+      if (key.includes("=")) key = key.split("=")[0].trim();
+      if (key.startsWith("{") || key.startsWith("[")) continue;
+      if (!key) continue;
+      const prop = {};
+      if (typeof p.defaultValue === "number") prop.type = "number";
+      else if (typeof p.defaultValue === "boolean") prop.type = "boolean";
+      if (p.hasDefault && p.defaultValue !== void 0) prop.default = p.defaultValue;
+      props[key] = prop;
+      if (!p.hasDefault) required.push(key);
+    }
+    schema.properties = props;
+    schema.required = required;
+  }
+  return { inference, schema };
+}
+function extractKey(raw) {
+  let s = raw.trim();
+  const eq = s.indexOf("=");
+  if (eq !== -1) s = s.slice(0, eq).trim();
+  const colon = s.indexOf(":");
+  if (colon !== -1) s = s.slice(0, colon).trim();
+  if (s.startsWith("...")) s = s.slice(3).trim();
+  s = s.replace(/^{|}$/g, "").trim();
+  return s.split(/\s+/)[0] || "";
+}
+function splitObjectEntries(inner) {
+  const res = [];
+  let cur = "";
+  let d = 0;
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (ch === "{" || ch === "[" || ch === "(") d++;
+    else if (ch === "}" || ch === "]" || ch === ")") d--;
+    if (ch === "," && d === 0) {
+      if (cur.trim()) res.push(parseObjectEntry(cur.trim()));
+      cur = "";
+    } else cur += ch;
+  }
+  if (cur.trim()) res.push(parseObjectEntry(cur.trim()));
+  return res;
+}
+function parseObjectEntry(raw) {
+  let s = raw.trim();
+  let hasDefault = false;
+  let defaultValue;
+  let eqIdx = s.indexOf("=");
+  if (eqIdx !== -1) {
+    hasDefault = true;
+    const def = s.slice(eqIdx + 1).trim();
+    defaultValue = parseDefaultLiteral(def);
+    s = s.slice(0, eqIdx).trim();
+  }
+  const colon = s.indexOf(":");
+  if (colon !== -1) s = s.slice(0, colon).trim();
+  const key = extractKey(s);
+  return { key, hasDefault, defaultValue };
+}
+
+// src/internal/schema.ts
+var ZOD_CONVERTER_KEY = "__simpleWebmcp_zodConverter";
+function getZodConverter() {
+  return globalThis[ZOD_CONVERTER_KEY] ?? null;
+}
+function zodLikeToJsonSchema(schema) {
+  const conv = getZodConverter();
+  if (conv) {
+    try {
+      return conv(schema);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function standardSchemaToJsonSchema(schema) {
+  const zodJson = zodLikeToJsonSchema(schema);
+  if (zodJson) return zodJson;
+  return null;
+}
+function normalizeSchemaInput(schema) {
+  if (!schema) return { json: null, standard: null };
+  if (looksLikeJsonSchema(schema)) {
+    return { json: schema, standard: null };
+  }
+  if (isStandardSchema(schema)) {
+    const std = schema;
+    const json = standardSchemaToJsonSchema(std);
+    return { json, standard: std };
+  }
+  const maybeZodJson = zodLikeToJsonSchema(schema);
+  if (maybeZodJson) return { json: maybeZodJson, standard: isStandardSchema(schema) ? schema : null };
+  if (typeof schema === "object" && schema !== null) {
+    return { json: schema, standard: null };
+  }
+  return { json: null, standard: null };
+}
+function applyFieldsPatch(base, fields) {
+  if (!fields || Object.keys(fields).length === 0) return base;
+  const result = {
+    ...base,
+    properties: { ...base.properties || {} },
+    required: [...base.required || []]
+  };
+  if (!result.properties) result.properties = {};
+  if (!result.required) result.required = [];
+  for (const [key, field] of Object.entries(fields)) {
+    const isStd = isStandardSchema(field);
+    if (isStd) {
+      const json = standardSchemaToJsonSchema(field);
+      const fragment = json ?? { type: "string" };
+      result.properties[key] = fragment;
+      const anyField = field;
+      const isOpt = anyField?._def?.typeName === "ZodOptional" || anyField?.isOptional?.() === true;
+      if (!isOpt) {
+        if (!result.required.includes(key)) result.required.push(key);
+      } else {
+        result.required = result.required.filter((k) => k !== key);
+      }
+      const desc = anyField?.description ?? anyField?._def?.description;
+      if (desc && !result.properties[key].description) result.properties[key].description = desc;
+    } else {
+      const patch = field;
+      const existing = result.properties[key] || {};
+      const merged = { ...existing, ...patch };
+      result.properties[key] = merged;
+      if ("required" in patch) {
+        const req = patch.required;
+        if (req === false) {
+          result.required = result.required.filter((k) => k !== key);
+          delete merged.required;
+        } else if (req === true) {
+          if (!result.required.includes(key)) result.required.push(key);
+          delete merged.required;
+        }
+      } else {
+        if (!(key in (base.properties || {})) && !patch.required) {
+          const hasDefault = "default" in patch;
+          if (!hasDefault && !result.required.includes(key)) result.required.push(key);
+        }
+      }
+    }
+  }
+  if (result.required && result.required.length === 0) delete result.required;
+  return result;
+}
+function buildFinalInputSchema(opts) {
+  const wholeNorm = normalizeSchemaInput(opts.wholeSchema);
+  let baseJson;
+  let standard = wholeNorm.standard;
+  if (wholeNorm.json) {
+    baseJson = wholeNorm.json;
+  } else if (wholeNorm.standard && !wholeNorm.json) {
+    baseJson = opts.inferred;
+  } else {
+    baseJson = opts.inferred;
+  }
+  if (!baseJson.type) baseJson.type = "object";
+  if (!baseJson.properties) baseJson.properties = {};
+  if (baseJson.additionalProperties == null) baseJson.additionalProperties = false;
+  const patched = applyFieldsPatch(baseJson, opts.fields);
+  return { json: patched, standard };
+}
+function normalizeOutputSchema(schema) {
+  if (!schema) return {};
+  const norm = normalizeSchemaInput(schema);
+  if (norm.json) return { json: norm.json, standard: norm.standard ?? void 0 };
+  if (norm.standard) return { standard: norm.standard };
+  return {};
+}
+
+// src/internal/registry.ts
+var Registry = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  // expose for devtools/tests — now includes contract for inspect
+  list() {
+    return Array.from(this.entries.values()).map((e) => ({ name: e.name, status: e.status, contract: e.contract }));
+  }
+  get(name) {
+    return this.entries.get(name);
+  }
+  getContract(name) {
+    return this.entries.get(name)?.contract;
+  }
+  clear() {
+    for (const e of this.entries.values()) {
+      try {
+        e.controller.abort();
+      } catch {
+      }
+    }
+    this.entries.clear();
+  }
+  isRegistered(name) {
+    return this.entries.get(name)?.status === "registered";
+  }
+  getStatus(name) {
+    return this.entries.get(name)?.status ?? "unregistered";
+  }
+  async register(contract, opts) {
+    const name = contract.name;
+    const existing = this.entries.get(name);
+    if (existing && (existing.status === "registered" || existing.status === "registering")) {
+      return existing.unregister;
+    }
+    if (!isWebMCPSupported()) {
+      if (opts?.signal?.aborted) return () => {
+      };
+      return () => {
+      };
+    }
+    const modelContext = getModelContext();
+    if (!modelContext) throw new NotSupportedError();
+    const controller = new AbortController();
+    if (opts?.signal) {
+      if (opts.signal.aborted) {
+        controller.abort();
+      } else {
+        opts.signal.addEventListener(
+          "abort",
+          () => {
+            try {
+              controller.abort();
+            } catch {
+            }
+          },
+          { once: true }
+        );
+      }
+    }
+    const entry = {
+      name,
+      controller,
+      status: "registering",
+      promise: null,
+      unregister: () => {
+        if (entry.status === "registered" || entry.status === "registering") {
+          entry.status = "unregistering";
+          try {
+            controller.abort();
+          } catch {
+          }
+          entry.status = "unregistered";
+          this.entries.delete(name);
+        }
+      },
+      contract,
+      execute: opts?.execute
+    };
+    this.entries.set(name, entry);
+    const wrappedExecute = opts?.execute ?? (async (args) => ({ content: [{ type: "text", text: `no execute for ${name}` }] }));
+    try {
+      const regPromise = modelContext.registerTool(
+        {
+          name: contract.name,
+          description: contract.description,
+          inputSchema: contract.inputSchema,
+          outputSchema: contract.outputSchema,
+          annotations: contract.annotations,
+          execute: wrappedExecute
+        },
+        { signal: controller.signal }
+      );
+      entry.promise = regPromise;
+      await regPromise;
+      if (controller.signal.aborted) {
+        entry.status = "unregistered";
+        this.entries.delete(name);
+      } else {
+        entry.status = "registered";
+      }
+      controller.signal.addEventListener("abort", () => {
+        entry.status = "unregistered";
+        this.entries.delete(name);
+      }, { once: true });
+      return entry.unregister;
+    } catch (err) {
+      entry.status = "error";
+      this.entries.delete(name);
+      const msg = err?.message || String(err);
+      if (err?.name === "NotAllowedError" || /NotAllowedError|Permissions Policy|blocked/i.test(msg)) {
+        throw new NotAllowedError(msg, { cause: err });
+      }
+      throw new RegistrationError(`Failed to register tool "${name}": ${msg}`, { cause: err });
+    }
+  }
+  unregister(name) {
+    const entry = this.entries.get(name);
+    if (!entry) return;
+    try {
+      entry.controller.abort();
+    } catch {
+    }
+    this.entries.delete(name);
+  }
+};
+var REGISTRY_KEY = "__simpleWebmcpRegistry";
+var globalAny = globalThis;
+var registry = globalAny[REGISTRY_KEY] ?? new Registry();
+if (!globalAny[REGISTRY_KEY]) {
+  globalAny[REGISTRY_KEY] = registry;
+}
+
+// src/internal/normalize.ts
+function normalizeResult(value) {
+  if (value == null) {
+    return { content: [{ type: "text", text: "" }] };
+  }
+  if (typeof value === "string") {
+    return { content: [{ type: "text", text: value }] };
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return { content: [{ type: "text", text: String(value) }] };
+  }
+  if (typeof value === "object" && value !== null && "content" in value && Array.isArray(value.content)) {
+    return value;
+  }
+  if (typeof value === "object" && value !== null && "isError" in value) {
+    if ("content" in value) return value;
+  }
+  try {
+    const text = JSON.stringify(value, null, 2);
+    return { content: [{ type: "text", text }] };
+  } catch {
+    return { content: [{ type: "text", text: String(value) }] };
+  }
+}
+function normalizeError(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 {
+      return String(err);
+    }
+  })();
+  return {
+    content: [{ type: "text", text: `Error: ${message}` }],
+    isError: true
+  };
+}
+
+// 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 {
+      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(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) {
+  if (opts?.scope) return opts.scope;
+  if (opts?.global) return "global";
+  return "scoped";
+}
+function webmcp(fn, options) {
+  if (typeof fn !== "function") {
+    throw new ConfigurationError("webmcp(fn, opts) \u2014 first argument must be a function");
+  }
+  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, mergedOpts);
+  }
+  const name = options?.name ?? toSnakeCase(getFunctionName(fn));
+  if (!name) throw new ConfigurationError('Tool name could not be inferred \u2014 pass {name:"my_tool"}');
+  let description = options?.description ?? anyFn.__webmcpDescription ?? "";
+  if (!description) {
+    warnNoDescription(fn);
+    description = "";
+  }
+  const hasSchema = !!options?.schema;
+  const hasFields = !!options?.fields && Object.keys(options.fields).length > 0;
+  if (options?.strict && !hasSchema && !hasFields) {
+    const { schema: inferred } = inferRuntime(fn);
+    const props = inferred.properties || {};
+    const propKeys = Object.keys(props);
+    const hasTypedProps = propKeys.length > 0 && propKeys.some((k) => !!props[k]?.type);
+    if (!hasTypedProps) {
+      throw new ConfigurationError(
+        `webmcp strict: could not infer schema for "${name}" \u2014 add TypeScript types, JSDoc, {schema} or {fields}`
+      );
+    }
+  }
+  const { schema: inferredSchema } = inferRuntime(fn);
+  const { json: finalInput, standard } = buildFinalInputSchema({
+    wholeSchema: options?.schema,
+    inferred: inferredSchema,
+    fields: options?.fields
+  });
+  const outNorm = normalizeOutputSchema(options?.outputSchema);
+  const annotations = options?.annotations;
+  const contract = {
+    name,
+    description,
+    inputSchema: finalInput,
+    outputSchema: outNorm.json,
+    annotations
+  };
+  const enabled = options?.enabled ?? true;
+  const wrapper = function(...args) {
+    return fn.apply(this, args);
+  };
+  try {
+    Object.defineProperty(wrapper, "name", { value: fn.name || name, configurable: true });
+  } catch {
+  }
+  try {
+    Object.defineProperty(wrapper, "length", { value: fn.length, configurable: true });
+  } catch {
+  }
+  let status = "unregistered";
+  let registrationPromise = null;
+  let unregisterFn = null;
+  let activeController = null;
+  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;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(toolWrapper, "registration", {
+    get() {
+      return registrationPromise;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  toolWrapper.isRegistered = () => status === "registered";
+  toolWrapper.register = async (opts) => {
+    if (status === "registered" || status === "registering") {
+      return unregisterFn ?? (() => toolWrapper.unregister());
+    }
+    if (enabled === false) {
+      return () => {
+      };
+    }
+    if (!isWebMCPSupported()) {
+      status = "unsupported";
+      return () => {
+        status = "unregistered";
+      };
+    }
+    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 () => {
+        };
+      }
+      opts.signal.addEventListener("abort", () => {
+        try {
+          controller.abort();
+        } catch {
+        }
+        toolWrapper.unregister();
+      }, { once: true });
+    }
+    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: hookedExec
+      });
+      unregisterFn = unregister;
+      registrationPromise = Promise.resolve();
+      if (controller.signal.aborted) {
+        status = "unregistered";
+      } else if (!isWebMCPSupported()) {
+        status = "unsupported";
+      } else {
+        status = "registered";
+      }
+      return () => {
+        try {
+          unregister();
+        } catch {
+        }
+        status = "unregistered";
+        activeController = null;
+        try {
+          delete toolWrapper.__activeSignal;
+        } catch {
+        }
+        unregisterFn = null;
+      };
+    } catch (err) {
+      if (err instanceof NotSupportedError || err?.code === "NOT_SUPPORTED" || err?.name === "NotSupportedError") {
+        status = "unsupported";
+      } else {
+        status = "error";
+      }
+      activeController = null;
+      try {
+        delete toolWrapper.__activeSignal;
+      } catch {
+      }
+      registrationPromise = Promise.reject(err);
+      if (err instanceof SimpleWebMCPError) throw err;
+      throw err;
+    }
+  };
+  toolWrapper.unregister = () => {
+    if (status === "unregistered") return;
+    status = "unregistering";
+    try {
+      registry.unregister(contract.name);
+    } catch {
+    }
+    try {
+      activeController?.abort();
+    } catch {
+    }
+    status = "unregistered";
+    activeController = null;
+    try {
+      delete toolWrapper.__activeSignal;
+    } catch {
+    }
+    unregisterFn = null;
+    registrationPromise = null;
+  };
+  const scope = resolveScope(options);
+  if (scope === "global" && enabled !== false) {
+    if (typeof document !== "undefined") {
+      queueMicrotask(() => {
+        toolWrapper.register().catch(() => {
+        });
+      });
+    }
+  }
+  toolWrapper.toString = fn.toString.bind(fn);
+  return toolWrapper;
+}
+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 = createContext({});
+function WebMCPProvider({ hooks, children }) {
+  const parent = useContext(WebMCPHooksContext);
+  const merged = 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__ */ jsx(WebMCPHooksContext.Provider, { value: merged, children });
+}
+function useWebMCPHooksContext() {
+  return useContext(WebMCPHooksContext);
+}
 
 // src/react/useWebMCP.ts
 function isTool(v) {
   return !!v?.__webmcpBrand;
 }
-function useWebMCP(tool, opts) {
+function useWebMCP(arg, opts) {
   const enabled = opts?.enabled ?? true;
+  const scopedHooks = useWebMCPHooksContext();
+  const isRawFunction = useMemo(() => {
+    return typeof arg === "function" && !isTool(arg);
+  }, [arg]);
+  const tool = useMemo(() => {
+    if (isRawFunction) {
+      const { enabled: _e, ...webmcpOpts } = opts ?? {};
+      return webmcp(arg, webmcpOpts);
+    }
+    return arg;
+  }, [
+    arg,
+    isRawFunction,
+    opts?.name,
+    opts?.description,
+    opts?.schema,
+    opts?.fields,
+    opts?.annotations,
+    opts?.scope,
+    opts?.global,
+    opts?.strict,
+    opts?.outputSchema,
+    opts?.hooks,
+    opts?.enabled
+  ]);
   const [registered, setRegistered] = useState(false);
   const [error, setError] = useState(null);
   const supported = useMemo(() => isWebMCPSupported(), []);
@@ -25,21 +1162,37 @@ function useWebMCP(tool, opts) {
   const toolRef = useRef(tool);
   toolRef.current = tool;
   useEffect(() => {
-    if (!enabled) {
-      setRegistered(false);
-      setError(null);
-      return;
-    }
     const t = toolRef.current;
-    if (!isTool(t)) {
-      if (typeof console !== "undefined") {
-        console.warn("[simple-webmcp] useWebMCP expected webmcp(fn) tool, got plain function. Wrap with webmcp() first.");
+    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 {
+        }
       }
-      setError(new Error("useWebMCP: wrap fn with webmcp() first"));
+    };
+  }, [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 {
+      }
+    }
+  }
+  useEffect(() => {
+    if (!enabled) {
       setRegistered(false);
+      setError(null);
       return;
     }
-    const webTool = t;
+    const webTool = toolRef.current;
     if (webTool.status === "registered") {
       setRegistered(true);
       setError(null);
@@ -86,8 +1239,30 @@ function useWebMCP(tool, opts) {
     };
   }, [enabled, supported, tool]);
   const status = !supported ? "unsupported" : error ? "error" : registered ? "registered" : enabled ? "registering" : "unregistered";
-  return { supported: !!supported, registered, error, isPolyfilled, status };
+  const result = { supported: !!supported, registered, error, isPolyfilled, status };
+  if (isRawFunction) {
+    const augmented = (...args) => tool(...args);
+    Object.assign(augmented, tool);
+    Object.setPrototypeOf(augmented, Object.getPrototypeOf(tool));
+    for (const [k, v] of Object.entries(result)) {
+      Object.defineProperty(augmented, k, {
+        value: v,
+        writable: true,
+        configurable: true,
+        enumerable: true
+      });
+    }
+    Object.defineProperty(augmented, "__rawTool", {
+      value: tool,
+      writable: false,
+      configurable: true,
+      enumerable: false
+    });
+    return augmented;
+  }
+  return result;
 }
+var useTool = useWebMCP;
 function ToolRegistrar({ tool, enabled }) {
   useWebMCP(tool, { enabled });
   return null;
@@ -101,6 +1276,6 @@ function Scope({ tools, enabled = true, children }) {
 }
 var WebMCPScope = Scope;
 
-export { Scope, WebMCPScope, useWebMCP };
+export { Scope, WebMCPHooksContext, WebMCPProvider, WebMCPScope, useTool, useWebMCP, useWebMCPHooksContext };
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map