auto-webmcp 0.3.15 → 0.3.17

package/dist/auto-webmcp.esm.js

@@ -1,88 +1,18 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/registry.ts
-var registry_exports = {};
-__export(registry_exports, {
-  getAllRegisteredTools: () => getAllRegisteredTools,
-  getRegisteredToolName: () => getRegisteredToolName,
-  isWebMCPSupported: () => isWebMCPSupported,
-  registerFormTool: () => registerFormTool,
-  unregisterAll: () => unregisterAll,
-  unregisterFormTool: () => unregisterFormTool
-});
-function isWebMCPSupported() {
-  return typeof navigator !== "undefined" && typeof navigator.modelContext !== "undefined";
-}
-async function registerFormTool(form, metadata, execute) {
-  if (!isWebMCPSupported())
-    return;
-  const existing = registeredTools.get(form);
-  if (existing) {
-    await unregisterFormTool(form);
-  }
-  const toolDef = {
-    name: metadata.name,
-    description: metadata.description,
-    inputSchema: metadata.inputSchema,
-    execute
-  };
-  if (metadata.annotations && Object.keys(metadata.annotations).length > 0) {
-    toolDef.annotations = metadata.annotations;
-  }
-  try {
-    await navigator.modelContext.registerTool(toolDef);
-  } catch {
-    try {
-      await navigator.modelContext.unregisterTool(metadata.name);
-      await navigator.modelContext.registerTool(toolDef);
-    } catch {
-    }
-  }
-  registeredTools.set(form, metadata.name);
-}
-async function unregisterFormTool(form) {
-  if (!isWebMCPSupported())
-    return;
-  const name = registeredTools.get(form);
-  if (!name)
-    return;
-  try {
-    await navigator.modelContext.unregisterTool(name);
-  } catch {
-  }
-  registeredTools.delete(form);
-}
-function getRegisteredToolName(form) {
-  return registeredTools.get(form);
-}
-function getAllRegisteredTools() {
-  return Array.from(registeredTools.entries()).map(([form, name]) => ({ form, name }));
-}
-async function unregisterAll() {
-  const entries = Array.from(registeredTools.entries());
-  await Promise.all(entries.map(([form]) => unregisterFormTool(form)));
-}
-var registeredTools;
-var init_registry = __esm({
-  "src/registry.ts"() {
-    "use strict";
-    registeredTools = /* @__PURE__ */ new Map();
-  }
-});
-
 // src/config.ts
 function resolveConfig(userConfig) {
+  const strict = userConfig?.paramBinding?.strict ?? false;
+  const enableAliasResolution = strict ? false : userConfig?.paramBinding?.enableAliasResolution ?? true;
   return {
     exclude: userConfig?.exclude ?? [],
     autoSubmit: userConfig?.autoSubmit ?? false,
+    declarativeMode: userConfig?.declarativeMode ?? "skip",
+    paramBinding: {
+      strict,
+      enableAliasResolution
+    },
+    execution: {
+      timeoutMs: Math.max(100, userConfig?.execution?.timeoutMs ?? 15e3)
+    },
     overrides: userConfig?.overrides ?? {},
     debug: userConfig?.debug ?? false
   };
@@ -231,19 +161,19 @@ function mapSelectElement(select) {
   return { type: "string", enum: enumValues, oneOf };
 }
 function collectCheckboxEnum(form, name) {
-  return Array.from(
-    form.querySelectorAll(`input[type="checkbox"][name="${CSS.escape(name)}"]`)
+  return Array.from(form.elements).filter(
+    (el) => el instanceof HTMLInputElement && el.type === "checkbox" && el.name === name
   ).map((cb) => cb.value).filter((v) => v !== "" && v !== "on");
 }
 function collectRadioEnum(form, name) {
-  const radios = Array.from(
-    form.querySelectorAll(`input[type="radio"][name="${CSS.escape(name)}"]`)
+  const radios = Array.from(form.elements).filter(
+    (el) => el instanceof HTMLInputElement && el.type === "radio" && el.name === name
   );
   return radios.map((r) => r.value).filter((v) => v !== "");
 }
 function collectRadioOneOf(form, name) {
-  const radios = Array.from(
-    form.querySelectorAll(`input[type="radio"][name="${CSS.escape(name)}"]`)
+  const radios = Array.from(form.elements).filter(
+    (el) => el instanceof HTMLInputElement && el.type === "radio" && el.name === name
   ).filter((r) => r.value !== "");
   return radios.map((r) => {
     const title = getRadioLabelText(r);
@@ -503,20 +433,26 @@ function collectShadowControls(root, visited = /* @__PURE__ */ new Set()) {
   }
   return results;
 }
+function collectFormAssociatedControls(form) {
+  const controls = Array.from(form.elements).filter(
+    (el) => el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement
+  );
+  const seen = new Set(controls);
+  for (const shadowControl of collectShadowControls(form)) {
+    if (!seen.has(shadowControl)) {
+      controls.push(shadowControl);
+      seen.add(shadowControl);
+    }
+  }
+  return controls;
+}
 function buildSchema(form) {
   const properties = {};
   const required = [];
   const fieldElements = /* @__PURE__ */ new Map();
   const processedRadioGroups = /* @__PURE__ */ new Set();
   const processedCheckboxGroups = /* @__PURE__ */ new Set();
-  const controls = [
-    ...Array.from(
-      form.querySelectorAll(
-        "input, textarea, select"
-      )
-    ),
-    ...collectShadowControls(form)
-  ];
+  const controls = collectFormAssociatedControls(form);
   for (const control of controls) {
     const name = control.name;
     const fieldKey = name || resolveNativeControlFallbackKey(control);
@@ -549,8 +485,8 @@ function buildSchema(form) {
       const radioOneOf = collectRadioOneOf(form, fieldKey);
       if (radioOneOf.length > 0)
         schemaProp.oneOf = radioOneOf;
-      const checkedRadio = form.querySelector(
-        `input[type="radio"][name="${CSS.escape(fieldKey)}"]:checked`
+      const checkedRadio = Array.from(form.elements).find(
+        (el) => el instanceof HTMLInputElement && el.type === "radio" && el.name === fieldKey && el.checked
       );
       if (checkedRadio?.value)
         schemaProp.default = checkedRadio.value;
@@ -565,10 +501,8 @@ function buildSchema(form) {
         };
         if (schemaProp.description)
           arrayProp.description = schemaProp.description;
-        const checkedBoxes = Array.from(
-          form.querySelectorAll(
-            `input[type="checkbox"][name="${CSS.escape(fieldKey)}"]:checked`
-          )
+        const checkedBoxes = Array.from(form.elements).filter(
+          (el) => el instanceof HTMLInputElement && el.type === "checkbox" && el.name === fieldKey && el.checked
         ).map((b) => b.value);
         if (checkedBoxes.length > 0)
           arrayProp.default = checkedBoxes;
@@ -1038,8 +972,68 @@ function buildSchemaFromInputs(inputs) {
   return { schema: { "$schema": "https://json-schema.org/draft/2020-12/schema", type: "object", properties, required }, fieldElements };
 }
 
-// src/discovery.ts
-init_registry();
+// src/registry.ts
+var registeredTools = /* @__PURE__ */ new Map();
+var registrationControllers = /* @__PURE__ */ new Map();
+function isWebMCPSupported() {
+  return typeof navigator !== "undefined" && typeof navigator.modelContext !== "undefined";
+}
+async function registerFormTool(form, metadata, execute) {
+  if (!isWebMCPSupported())
+    return;
+  const existing = registeredTools.get(form);
+  if (existing) {
+    await unregisterFormTool(form);
+  }
+  const toolDef = {
+    name: metadata.name,
+    description: metadata.description,
+    inputSchema: metadata.inputSchema,
+    execute
+  };
+  if (metadata.annotations && Object.keys(metadata.annotations).length > 0) {
+    toolDef.annotations = metadata.annotations;
+  }
+  const controller = new AbortController();
+  registrationControllers.set(form, controller);
+  try {
+    await navigator.modelContext.registerTool(toolDef, { signal: controller.signal });
+  } catch {
+    try {
+      await navigator.modelContext.unregisterTool?.(metadata.name);
+      await navigator.modelContext.registerTool(toolDef, { signal: controller.signal });
+    } catch {
+    }
+  }
+  registeredTools.set(form, metadata.name);
+}
+async function unregisterFormTool(form) {
+  if (!isWebMCPSupported())
+    return;
+  const name = registeredTools.get(form);
+  if (!name)
+    return;
+  const controller = registrationControllers.get(form);
+  if (controller) {
+    controller.abort();
+    registrationControllers.delete(form);
+  }
+  try {
+    await navigator.modelContext.unregisterTool?.(name);
+  } catch {
+  }
+  registeredTools.delete(form);
+}
+function getRegisteredToolName(form) {
+  return registeredTools.get(form);
+}
+function getAllRegisteredTools() {
+  return Array.from(registeredTools.entries()).map(([form, name]) => ({ form, name }));
+}
+async function unregisterAll() {
+  const entries = Array.from(registeredTools.entries());
+  await Promise.all(entries.map(([form]) => unregisterFormTool(form)));
+}
 
 // src/interceptor.ts
 var pendingExecutions = /* @__PURE__ */ new WeakMap();
@@ -1051,30 +1045,169 @@ var lastFilledSnapshot = /* @__PURE__ */ new WeakMap();
 var _inputValueSetter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value")?.set;
 var _textareaValueSetter = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, "value")?.set;
 var _checkedSetter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "checked")?.set;
+function normalizeAliasKey(raw) {
+  return raw.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function addAlias(index, alias, schemaKey) {
+  if (!alias)
+    return;
+  const normalized = normalizeAliasKey(alias);
+  if (!normalized)
+    return;
+  if (!index.has(normalized))
+    index.set(normalized, /* @__PURE__ */ new Set());
+  index.get(normalized).add(schemaKey);
+}
+function buildAliasIndex(form, metadata) {
+  const index = /* @__PURE__ */ new Map();
+  const properties = metadata?.inputSchema?.properties ?? {};
+  for (const [schemaKey, prop] of Object.entries(properties)) {
+    addAlias(index, schemaKey, schemaKey);
+    addAlias(index, schemaKey.replace(/_/g, " "), schemaKey);
+    addAlias(index, prop.title, schemaKey);
+    const nativeEl = findNativeField(form, schemaKey);
+    const mappedEl = metadata?.fieldElements?.get(schemaKey);
+    const el = nativeEl ?? mappedEl ?? null;
+    if (!el)
+      continue;
+    const htmlEl = el;
+    addAlias(index, htmlEl.getAttribute("id"), schemaKey);
+    addAlias(index, htmlEl.getAttribute("name"), schemaKey);
+    addAlias(index, htmlEl.getAttribute("aria-label"), schemaKey);
+    addAlias(index, htmlEl.getAttribute("placeholder"), schemaKey);
+    if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+      for (const label of Array.from(el.labels ?? [])) {
+        addAlias(index, label.textContent?.trim(), schemaKey);
+      }
+    }
+  }
+  return index;
+}
+function resolveParamsForSchema(form, params, metadata, config) {
+  const resolved = {};
+  const warnings = [];
+  const properties = metadata?.inputSchema?.properties ?? {};
+  const aliasEnabled = config.paramBinding.enableAliasResolution;
+  for (const [key, value] of Object.entries(params)) {
+    if (key in properties)
+      resolved[key] = value;
+  }
+  if (!aliasEnabled)
+    return { resolved, warnings };
+  const aliasIndex = buildAliasIndex(form, metadata);
+  for (const [rawKey, value] of Object.entries(params)) {
+    if (rawKey in properties)
+      continue;
+    const candidates = aliasIndex.get(normalizeAliasKey(rawKey));
+    if (!candidates || candidates.size !== 1)
+      continue;
+    const target = Array.from(candidates)[0];
+    if (!target || target in resolved)
+      continue;
+    resolved[target] = value;
+    warnings.push({
+      field: target,
+      type: "alias_resolved",
+      original: rawKey,
+      message: `resolved "${rawKey}" to schema field "${target}"`
+    });
+  }
+  return { resolved, warnings };
+}
+function collectInvalidFieldWarnings(form) {
+  const warnings = [];
+  const controls = Array.from(form.elements).filter(
+    (el) => el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement
+  );
+  for (const control of controls) {
+    if (!control.willValidate)
+      continue;
+    if (control.checkValidity())
+      continue;
+    const field = control.name || control.id || control.getAttribute("aria-label") || "unknown_field";
+    warnings.push({
+      field,
+      type: "blocked_submit",
+      message: control.validationMessage || `field "${field}" failed validation`
+    });
+  }
+  return warnings;
+}
 function buildExecuteHandler(form, config, toolName, metadata) {
   if (metadata?.fieldElements) {
     formFieldElements.set(form, metadata.fieldElements);
   }
   attachSubmitInterceptor(form, toolName);
-  return async (params) => {
+  return async (params, client) => {
+    const modelContextClient = client;
+    if (config.autoSubmit && metadata?.annotations?.destructiveHint === true && typeof modelContextClient?.requestUserInteraction === "function") {
+      const approved = await modelContextClient.requestUserInteraction(async () => {
+        return new Promise((resolve) => {
+          const ok = window.confirm(`Agent requested a destructive action via "${toolName}". Continue?`);
+          resolve(ok);
+        });
+      });
+      if (!approved) {
+        window.dispatchEvent(new CustomEvent("toolcancel", { detail: { toolName } }));
+        return { content: [{ type: "text", text: `Cancelled "${toolName}" by user.` }] };
+      }
+    }
     pendingFillWarnings.set(form, []);
     pendingWarnings.delete(form);
-    fillFormFields(form, params);
-    const missingNow = getMissingRequired(metadata, params);
+    const { resolved: resolvedParams, warnings: aliasWarnings } = resolveParamsForSchema(
+      form,
+      params,
+      metadata,
+      config
+    );
+    if (aliasWarnings.length > 0) {
+      pendingFillWarnings.set(form, [...pendingFillWarnings.get(form) ?? [], ...aliasWarnings]);
+    }
+    fillFormFields(form, resolvedParams);
+    const missingNow = getMissingRequired(metadata, resolvedParams);
     if (missingNow.length > 0)
       pendingWarnings.set(form, missingNow);
     window.dispatchEvent(new CustomEvent("toolactivated", { detail: { toolName } }));
     return new Promise((resolve, reject) => {
-      pendingExecutions.set(form, { resolve, reject });
+      const timeoutMs = config.execution.timeoutMs;
+      const timeoutId = setTimeout(() => {
+        const pending = pendingExecutions.get(form);
+        if (!pending)
+          return;
+        pendingExecutions.delete(form);
+        const timedOutState = config.autoSubmit || form.hasAttribute("toolautosubmit") || form.dataset["webmcpAutosubmit"] !== void 0 ? "timed_out" : "awaiting_user_action";
+        const warn = {
+          field: "__form__",
+          type: "timeout",
+          message: timedOutState === "timed_out" ? `tool execution timed out after ${timeoutMs}ms` : `waiting for user submit (timed out after ${timeoutMs}ms)`
+        };
+        const structured = {
+          status: timedOutState,
+          filled_fields: serializeFormData(form, lastParams.get(form), formFieldElements.get(form)),
+          skipped_fields: [],
+          missing_required: pendingWarnings.get(form) ?? [],
+          warnings: [...pendingFillWarnings.get(form) ?? [], warn]
+        };
+        pendingWarnings.delete(form);
+        pendingFillWarnings.delete(form);
+        lastFilledSnapshot.delete(form);
+        resolve({
+          content: [
+            { type: "text", text: warn.message },
+            { type: "text", text: JSON.stringify(structured) }
+          ]
+        });
+      }, timeoutMs);
+      pendingExecutions.set(form, { resolve, reject, timeoutId });
       if (config.autoSubmit || form.hasAttribute("toolautosubmit") || form.dataset["webmcpAutosubmit"] !== void 0) {
         waitForDomStable(form).then(async () => {
           try {
-            fillFormFields(form, params);
+            fillFormFields(form, resolvedParams);
             for (let attempt = 0; attempt < 2; attempt++) {
-              const reset = getResetFields(form, params, formFieldElements.get(form));
+              const reset = getResetFields(form, resolvedParams, formFieldElements.get(form));
               if (reset.length === 0)
                 break;
-              fillFormFields(form, params);
+              fillFormFields(form, resolvedParams);
               await waitForDomStable(form, 400, 100);
             }
             let submitForm = form;
@@ -1085,7 +1218,9 @@ function buildExecuteHandler(form, config, toolName, metadata) {
               const found = liveBtn?.closest("form");
               if (found) {
                 submitForm = found;
-                pendingExecutions.set(submitForm, { resolve, reject });
+                const pending = pendingExecutions.get(form);
+                const nextPending = pending?.timeoutId ? { resolve, reject, timeoutId: pending.timeoutId } : { resolve, reject };
+                pendingExecutions.set(submitForm, nextPending);
                 attachSubmitInterceptor(submitForm, toolName);
               }
             }
@@ -1093,6 +1228,39 @@ function buildExecuteHandler(form, config, toolName, metadata) {
               pendingWarnings.set(submitForm, pendingWarnings.get(form));
               pendingWarnings.delete(form);
             }
+            if (!submitForm.checkValidity()) {
+              const pending = pendingExecutions.get(submitForm) ?? pendingExecutions.get(form);
+              if (pending) {
+                if (pending.timeoutId)
+                  clearTimeout(pending.timeoutId);
+                pendingExecutions.delete(submitForm);
+                pendingExecutions.delete(form);
+                const warnings = [
+                  ...pendingFillWarnings.get(submitForm) ?? pendingFillWarnings.get(form) ?? [],
+                  ...collectInvalidFieldWarnings(submitForm)
+                ];
+                pendingFillWarnings.delete(submitForm);
+                pendingFillWarnings.delete(form);
+                const structured = {
+                  status: "blocked_invalid",
+                  filled_fields: serializeFormData(submitForm, lastParams.get(submitForm) ?? lastParams.get(form), formFieldElements.get(submitForm) ?? formFieldElements.get(form)),
+                  skipped_fields: [],
+                  missing_required: pendingWarnings.get(submitForm) ?? pendingWarnings.get(form) ?? [],
+                  warnings
+                };
+                pendingWarnings.delete(submitForm);
+                pendingWarnings.delete(form);
+                lastFilledSnapshot.delete(submitForm);
+                lastFilledSnapshot.delete(form);
+                resolve({
+                  content: [
+                    { type: "text", text: "Form submission blocked by native validation." },
+                    { type: "text", text: JSON.stringify(structured) }
+                  ]
+                });
+              }
+              return;
+            }
             submitForm.requestSubmit();
           } catch (err) {
             reject(err instanceof Error ? err : new Error(String(err)));
@@ -1111,6 +1279,8 @@ function attachSubmitInterceptor(form, toolName) {
     if (!pending)
       return;
     const { resolve } = pending;
+    if (pending.timeoutId)
+      clearTimeout(pending.timeoutId);
     pendingExecutions.delete(form);
     const formData = serializeFormData(form, lastParams.get(form), formFieldElements.get(form));
     lastFilledSnapshot.delete(form);
@@ -1193,7 +1363,23 @@ function findInShadowRoots(root, selector) {
   }
   return null;
 }
+function getAssociatedInputsByName(form, type, name) {
+  return Array.from(form.elements).filter(
+    (el) => el instanceof HTMLInputElement && el.type === type && el.name === name
+  );
+}
 function findNativeField(form, key) {
+  const named = form.elements.namedItem(key);
+  if (typeof named === "object" && named !== null && (named instanceof HTMLInputElement || named instanceof HTMLTextAreaElement || named instanceof HTMLSelectElement)) {
+    return named;
+  }
+  if (named instanceof RadioNodeList) {
+    const first = named[0];
+    const firstObj = first;
+    if (firstObj instanceof HTMLInputElement || firstObj instanceof HTMLTextAreaElement || firstObj instanceof HTMLSelectElement) {
+      return firstObj;
+    }
+  }
   const esc = CSS.escape(key);
   const light = form.querySelector(`[name="${esc}"]`) ?? form.querySelector(
     `input#${esc}, textarea#${esc}, select#${esc}`
@@ -1213,10 +1399,7 @@ function fillFormFields(form, params) {
         fillInput(input, form, key, value);
         if (input.type === "checkbox") {
           if (Array.isArray(value)) {
-            const esc = CSS.escape(key);
-            snapshot[key] = Array.from(
-              form.querySelectorAll(`input[type="checkbox"][name="${esc}"]`)
-            ).filter((b) => b.checked).map((b) => b.value);
+            snapshot[key] = getAssociatedInputsByName(form, "checkbox", key).filter((b) => b.checked).map((b) => b.value);
           } else {
             snapshot[key] = input.checked;
           }
@@ -1265,8 +1448,7 @@ function fillInput(input, form, key, value) {
   const type = input.type.toLowerCase();
   if (type === "checkbox") {
     if (Array.isArray(value)) {
-      const esc = CSS.escape(key);
-      const allBoxes = form.querySelectorAll(`input[type="checkbox"][name="${esc}"]`);
+      const allBoxes = getAssociatedInputsByName(form, "checkbox", key);
       for (const box of allBoxes) {
         setReactChecked(box, value.map(String).includes(box.value));
       }
@@ -1307,10 +1489,7 @@ function fillInput(input, form, key, value) {
     return;
   }
   if (type === "radio") {
-    const esc = CSS.escape(key);
-    const radios = form.querySelectorAll(
-      `input[type="radio"][name="${esc}"]`
-    );
+    const radios = getAssociatedInputsByName(form, "radio", key);
     for (const radio of radios) {
       if (radio.value === String(value)) {
         if (_checkedSetter) {
@@ -1633,9 +1812,48 @@ function isExcluded(form, config) {
   }
   return false;
 }
+function withNumericSuffix(baseName, n) {
+  const suffix = `_${n}`;
+  return `${baseName.slice(0, Math.max(1, 64 - suffix.length))}${suffix}`;
+}
+function getUsedToolNames(excludeForm) {
+  const names = new Set(registeredOrphanToolNames);
+  for (const { form, name } of getAllRegisteredTools()) {
+    if (excludeForm && form === excludeForm)
+      continue;
+    names.add(name);
+  }
+  return names;
+}
+function ensureUniqueToolName(baseName, excludeForm) {
+  const used = getUsedToolNames(excludeForm);
+  if (!used.has(baseName))
+    return baseName;
+  let i = 2;
+  let candidate = withNumericSuffix(baseName, i);
+  while (used.has(candidate)) {
+    i++;
+    candidate = withNumericSuffix(baseName, i);
+  }
+  return candidate;
+}
+function hasNativeDeclarativeTool(form) {
+  return form.getAttribute("toolname")?.trim().length ? true : false;
+}
 async function registerForm(form, config) {
   if (isExcluded(form, config))
     return;
+  const previousName = getRegisteredToolName(form);
+  if (hasNativeDeclarativeTool(form) && config.declarativeMode !== "force") {
+    if (previousName) {
+      await unregisterFormTool(form);
+    }
+    if (config.debug) {
+      const mode = config.declarativeMode;
+      console.log(`[auto-webmcp] Skipping imperative registration for native declarative form (mode=${mode})`);
+    }
+    return;
+  }
   let override;
   for (const [selector, ovr] of Object.entries(config.overrides)) {
     try {
@@ -1647,6 +1865,11 @@ async function registerForm(form, config) {
     }
   }
   const metadata = analyzeForm(form, override);
+  const resolvedName = ensureUniqueToolName(metadata.name, form);
+  if (resolvedName !== metadata.name && config.debug) {
+    console.warn(`[auto-webmcp] tool name collision: "${metadata.name}" renamed to "${resolvedName}"`);
+  }
+  metadata.name = resolvedName;
   if (config.debug) {
     warnToolQuality(metadata.name, metadata.description);
   }
@@ -1658,6 +1881,9 @@ async function registerForm(form, config) {
     '[type="submit"], button[data-variant="primary"], button:not([type])'
   ) ?? null;
   const pendingBtns = window["__pendingSubmitBtns"] ??= {};
+  if (previousName && previousName !== metadata.name) {
+    delete pendingBtns[previousName];
+  }
   pendingBtns[metadata.name] = formSubmitBtn;
   if (config.debug) {
     console.log(`[auto-webmcp] Registered: ${metadata.name}`, metadata);
@@ -1665,12 +1891,14 @@ async function registerForm(form, config) {
   emit("form:registered", form, metadata.name);
 }
 async function unregisterForm(form, config) {
-  const { getRegisteredToolName: getRegisteredToolName2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
-  const name = getRegisteredToolName2(form);
+  const name = getRegisteredToolName(form);
   if (!name)
     return;
   await unregisterFormTool(form);
   registeredForms.delete(form);
+  const pendingBtns = window["__pendingSubmitBtns"];
+  if (pendingBtns)
+    delete pendingBtns[name];
   if (config.debug) {
     console.log(`[auto-webmcp] Unregistered: ${name}`);
   }
@@ -1719,11 +1947,47 @@ function scheduleReAnalysis(form, config) {
     }, RE_ANALYSIS_DEBOUNCE_MS)
   );
 }
+function scheduleFormReAnalysisById(formId, config) {
+  const owner = document.getElementById(formId);
+  if (owner instanceof HTMLFormElement && registeredForms.has(owner)) {
+    scheduleReAnalysis(owner, config);
+  }
+}
+function resolveOwnerForm(el) {
+  const closest = el.closest("form");
+  if (closest instanceof HTMLFormElement)
+    return closest;
+  const explicitOwner = el.form;
+  if (explicitOwner instanceof HTMLFormElement)
+    return explicitOwner;
+  const formId = el.getAttribute("form");
+  if (formId) {
+    const byId = document.getElementById(formId);
+    if (byId instanceof HTMLFormElement)
+      return byId;
+  }
+  return null;
+}
 function startObserver(config) {
   if (observer)
     return;
   observer = new MutationObserver((mutations) => {
     for (const mutation of mutations) {
+      if (mutation.type === "attributes" && mutation.target instanceof Element) {
+        const target = mutation.target;
+        const ownerForm = resolveOwnerForm(target);
+        if (ownerForm && registeredForms.has(ownerForm)) {
+          scheduleReAnalysis(ownerForm, config);
+        } else if (target instanceof HTMLFormElement) {
+          void registerForm(target, config);
+        } else if (isInterestingNode(target) && !target.closest("form")) {
+          scheduleOrphanRescan(config);
+        }
+        if (mutation.attributeName === "form" && mutation.oldValue) {
+          scheduleFormReAnalysisById(mutation.oldValue, config);
+        }
+        continue;
+      }
       for (const node of mutation.addedNodes) {
         if (!(node instanceof Element))
           continue;
@@ -1752,7 +2016,12 @@ function startObserver(config) {
       }
     }
   });
-  observer.observe(document.body, { childList: true, subtree: true });
+  observer.observe(document.body, {
+    childList: true,
+    subtree: true,
+    attributes: true,
+    attributeOldValue: true
+  });
 }
 function listenForRouteChanges(config) {
   window.addEventListener("hashchange", () => scanForms(config));
@@ -1896,6 +2165,15 @@ async function scanOrphanInputs(config) {
     }
     console.log(`[auto-webmcp] orphan: submit button for group:`, submitBtn ? `"${submitBtn.textContent?.trim()}" disabled=${submitBtn.disabled}` : "none");
     const metadata = analyzeOrphanInputGroup(container, inputs, submitBtn);
+    if (registeredOrphanToolNames.has(metadata.name)) {
+      console.log(`[auto-webmcp] orphan: "${metadata.name}" already registered, skipping`);
+      continue;
+    }
+    const orphanName = ensureUniqueToolName(metadata.name);
+    if (orphanName !== metadata.name && config.debug) {
+      console.warn(`[auto-webmcp] orphan tool name collision: "${metadata.name}" renamed to "${orphanName}"`);
+    }
+    metadata.name = orphanName;
     console.log(`[auto-webmcp] orphan: tool="${metadata.name}" schema keys:`, Object.keys(metadata.inputSchema.properties));
     const inputPairs = [];
     const schemaProps = metadata.inputSchema.properties;
@@ -1916,7 +2194,7 @@ async function scanOrphanInputs(config) {
       continue;
     }
     const toolName = metadata.name;
-    const execute = async (params) => {
+    const execute = async (params, _client) => {
       console.log(`[auto-webmcp] orphan execute: tool="${toolName}" params=`, params);
       console.log(`[auto-webmcp] orphan execute: inputPairs=`, inputPairs.map((p) => p.key));
       for (const { key, el } of inputPairs) {
@@ -1985,10 +2263,6 @@ async function scanOrphanInputs(config) {
       return { content: [{ type: "text", text: "Fields filled and form submitted." }] };
     };
     try {
-      if (registeredOrphanToolNames.has(metadata.name)) {
-        console.log(`[auto-webmcp] orphan: "${metadata.name}" already registered, skipping`);
-        continue;
-      }
       const toolDef = {
         name: metadata.name,
         description: metadata.description,
@@ -2039,7 +2313,6 @@ function stopDiscovery() {
 }
 
 // src/index.ts
-init_registry();
 async function autoWebMCP(config) {
   const resolved = resolveConfig(config);
   if (resolved.debug) {