simple-webmcp 0.1.0 → 0.2.0

package/dist/react.js

@@ -1,19 +1,843 @@
-import { useState, useMemo, useRef, useEffect } from 'react';
+import { useMemo, useState, useRef, useEffect } from 'react';
 import { jsxs, Fragment, jsx } 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 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 = err instanceof Error ? err.message : typeof err === "string" ? err : (() => {
+    try {
+      return JSON.stringify(err);
+    } catch {
+      return String(err);
+    }
+  })();
+  return {
+    content: [{ type: "text", text: `Error: ${message}` }],
+    isError: true
+  };
+}
+function wrapExecute(fn, opts) {
+  return async (args, _ctx) => {
+    try {
+      let result;
+      const mode = opts?.argMode ?? "object";
+      if (mode === "spread" && args && typeof args === "object" && !Array.isArray(args)) ; else {
+        result = await fn(args);
+      }
+      return normalizeResult(result);
+    } catch (err) {
+      return normalizeError(err);
+    }
+  };
+}
+
+// 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 original = anyFn.__fn ?? fn;
+    return webmcp(original, { ...anyFn.__webmcpOptions || {}, ...options });
+  }
+  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 wrappedExec = wrapExecute(fn);
+  const toolWrapper = wrapper;
+  toolWrapper.__webmcpBrand = true;
+  toolWrapper.__fn = fn;
+  toolWrapper.__webmcpOptions = options;
+  if (standard) toolWrapper.__standardSchema = standard;
+  if (outNorm.standard) toolWrapper.__outputStandardSchema = outNorm.standard;
+  toolWrapper.tool = contract;
+  toolWrapper.definition = contract;
+  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;
+    if (opts?.signal) {
+      if (opts.signal.aborted) {
+        controller.abort();
+        status = "unregistered";
+        activeController = null;
+        return () => {
+        };
+      }
+      opts.signal.addEventListener("abort", () => {
+        try {
+          controller.abort();
+        } catch {
+        }
+        toolWrapper.unregister();
+      }, { once: true });
+    }
+    controller.signal.addEventListener("abort", () => {
+      if (status !== "unregistered") status = "unregistered";
+      activeController = null;
+    }, { once: true });
+    try {
+      const unregister = await registry.register(contract, {
+        signal: controller.signal,
+        execute: wrappedExec
+      });
+      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;
+        unregisterFn = null;
+      };
+    } catch (err) {
+      if (err instanceof NotSupportedError || err?.code === "NOT_SUPPORTED" || err?.name === "NotSupportedError") {
+        status = "unsupported";
+      } else {
+        status = "error";
+      }
+      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;
+    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.isWebMCPTool = function isWebMCPTool(v) {
+  return !!v?.__webmcpBrand;
+};
 
 // src/react/useWebMCP.ts
 function isTool(v) {
   return !!v?.__webmcpBrand;
 }
-function useWebMCP(tool, opts) {
+function useWebMCP(arg, opts) {
   const enabled = opts?.enabled ?? true;
+  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?.enabled
+  ]);
   const [registered, setRegistered] = useState(false);
   const [error, setError] = useState(null);
   const supported = useMemo(() => isWebMCPSupported(), []);
@@ -30,16 +854,7 @@ function useWebMCP(tool, opts) {
       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.");
-      }
-      setError(new Error("useWebMCP: wrap fn with webmcp() first"));
-      setRegistered(false);
-      return;
-    }
-    const webTool = t;
+    const webTool = toolRef.current;
     if (webTool.status === "registered") {
       setRegistered(true);
       setError(null);
@@ -86,8 +901,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 +938,6 @@ function Scope({ tools, enabled = true, children }) {
 }
 var WebMCPScope = Scope;
 
-export { Scope, WebMCPScope, useWebMCP };
+export { Scope, WebMCPScope, useTool, useWebMCP };
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map