auto-webmcp 0.2.10 → 0.3.1

package/dist/auto-webmcp.esm.js

@@ -28,22 +28,21 @@ async function registerFormTool(form, metadata, execute) {
   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({
-      name: metadata.name,
-      description: metadata.description,
-      inputSchema: metadata.inputSchema,
-      execute
-    });
+    await navigator.modelContext.registerTool(toolDef);
   } catch {
     try {
       await navigator.modelContext.unregisterTool(metadata.name);
-      await navigator.modelContext.registerTool({
-        name: metadata.name,
-        description: metadata.description,
-        inputSchema: metadata.inputSchema,
-        execute
-      });
+      await navigator.modelContext.registerTool(toolDef);
     } catch {
     }
   }
@@ -321,7 +320,8 @@ function analyzeForm(form, override) {
   const name = override?.name ?? inferToolName(form);
   const description = override?.description ?? inferToolDescription(form);
   const { schema: inputSchema, fieldElements } = buildSchema(form);
-  return { name, description, inputSchema, fieldElements };
+  const annotations = inferAnnotations(form);
+  return { name, description, inputSchema, annotations, fieldElements };
 }
 function inferToolName(form) {
   const nativeName = form.getAttribute("toolname");
@@ -418,17 +418,105 @@ function inferToolDescription(form) {
     return pageTitle;
   return "Submit form";
 }
+var READONLY_BUTTON_PATTERNS = /^(search|find|look|filter|browse|view|show|check|preview|get|fetch|retrieve|load)\b/i;
+var DESTRUCTIVE_BUTTON_PATTERNS = /^(delete|remove|cancel|terminate|destroy|purge|revoke|unsubscribe|deactivate)\b/i;
+var DESTRUCTIVE_URL_PATTERNS = /\/(delete|remove|cancel|destroy)\b/i;
+function inferAnnotations(form) {
+  const annotations = {};
+  if (form.dataset["webmcpReadonly"] !== void 0) {
+    annotations.readOnlyHint = form.dataset["webmcpReadonly"] !== "false";
+  }
+  if (form.dataset["webmcpDestructive"] !== void 0) {
+    annotations.destructiveHint = form.dataset["webmcpDestructive"] !== "false";
+  }
+  if (form.dataset["webmcpIdempotent"] !== void 0) {
+    annotations.idempotentHint = form.dataset["webmcpIdempotent"] !== "false";
+  }
+  if (form.dataset["webmcpOpenworld"] !== void 0) {
+    annotations.openWorldHint = form.dataset["webmcpOpenworld"] !== "false";
+  }
+  if (annotations.readOnlyHint === void 0) {
+    const isGet = form.method.toLowerCase() === "get";
+    const submitText = getSubmitButtonText(form);
+    const isReadLabel = submitText ? READONLY_BUTTON_PATTERNS.test(submitText.trim()) : false;
+    if (isGet || isReadLabel)
+      annotations.readOnlyHint = true;
+  }
+  if (annotations.destructiveHint === void 0) {
+    const submitText = getSubmitButtonText(form);
+    const isDestructiveLabel = submitText ? DESTRUCTIVE_BUTTON_PATTERNS.test(submitText.trim()) : false;
+    const isDestructiveUrl = form.action ? DESTRUCTIVE_URL_PATTERNS.test(form.action) : false;
+    if (isDestructiveLabel || isDestructiveUrl)
+      annotations.destructiveHint = true;
+  }
+  if (annotations.idempotentHint === void 0) {
+    if (annotations.readOnlyHint === true || form.method.toLowerCase() === "get") {
+      annotations.idempotentHint = true;
+    }
+  }
+  if (annotations.openWorldHint === void 0) {
+    annotations.openWorldHint = annotations.readOnlyHint !== true;
+  }
+  const hasNonDefault = annotations.readOnlyHint === true || annotations.destructiveHint === true || annotations.idempotentHint === true || annotations.openWorldHint === false;
+  return hasNonDefault ? annotations : {};
+}
+function extractDefaultValue(control) {
+  if (control instanceof HTMLInputElement) {
+    const type = control.type.toLowerCase();
+    if (type === "checkbox")
+      return control.checked ? true : void 0;
+    if (type === "radio")
+      return void 0;
+    if (type === "number" || type === "range") {
+      return control.value !== "" ? parseFloat(control.value) : void 0;
+    }
+    return control.value !== "" ? control.value : void 0;
+  }
+  if (control instanceof HTMLTextAreaElement) {
+    return control.value !== "" ? control.value : void 0;
+  }
+  if (control instanceof HTMLSelectElement) {
+    if (control.multiple) {
+      const selected = Array.from(control.options).filter((o) => o.selected).map((o) => o.value);
+      return selected.length > 0 ? selected : void 0;
+    }
+    return control.value !== "" ? control.value : void 0;
+  }
+  return void 0;
+}
+function collectShadowControls(root, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(root))
+    return [];
+  visited.add(root);
+  const results = [];
+  for (const el of Array.from(root.querySelectorAll("*"))) {
+    if (el.shadowRoot) {
+      results.push(
+        ...Array.from(
+          el.shadowRoot.querySelectorAll(
+            "input, textarea, select"
+          )
+        ),
+        ...collectShadowControls(el.shadowRoot, visited)
+      );
+    }
+  }
+  return results;
+}
 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"
-    )
-  );
+  const controls = [
+    ...Array.from(
+      form.querySelectorAll(
+        "input, textarea, select"
+      )
+    ),
+    ...collectShadowControls(form)
+  ];
   for (const control of controls) {
     const name = control.name;
     const fieldKey = name || resolveNativeControlFallbackKey(control);
@@ -453,11 +541,19 @@ function buildSchema(form) {
     const desc = inferFieldDescription(control);
     if (desc)
       schemaProp.description = desc;
+    const defaultVal = extractDefaultValue(control);
+    if (defaultVal !== void 0)
+      schemaProp.default = defaultVal;
     if (control instanceof HTMLInputElement && control.type === "radio") {
       schemaProp.enum = collectRadioEnum(form, fieldKey);
       const radioOneOf = collectRadioOneOf(form, fieldKey);
       if (radioOneOf.length > 0)
         schemaProp.oneOf = radioOneOf;
+      const checkedRadio = form.querySelector(
+        `input[type="radio"][name="${CSS.escape(fieldKey)}"]:checked`
+      );
+      if (checkedRadio?.value)
+        schemaProp.default = checkedRadio.value;
     }
     if (control instanceof HTMLInputElement && control.type === "checkbox") {
       const checkboxValues = collectCheckboxEnum(form, fieldKey);
@@ -469,6 +565,13 @@ function buildSchema(form) {
         };
         if (schemaProp.description)
           arrayProp.description = schemaProp.description;
+        const checkedBoxes = Array.from(
+          form.querySelectorAll(
+            `input[type="checkbox"][name="${CSS.escape(fieldKey)}"]:checked`
+          )
+        ).map((b) => b.value);
+        if (checkedBoxes.length > 0)
+          arrayProp.default = checkedBoxes;
         properties[fieldKey] = arrayProp;
         if (control.required)
           required.push(fieldKey);
@@ -838,6 +941,9 @@ function buildExecuteHandler(form, config, toolName, metadata) {
   return async (params) => {
     pendingFillWarnings.set(form, []);
     fillFormFields(form, params);
+    const missingNow = getMissingRequired(metadata, params);
+    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 });
@@ -864,9 +970,10 @@ function buildExecuteHandler(form, config, toolName, metadata) {
                 attachSubmitInterceptor(submitForm, toolName);
               }
             }
-            const missing = getMissingRequired(metadata, params);
-            if (missing.length > 0)
-              pendingWarnings.set(submitForm, missing);
+            if (submitForm !== form && pendingWarnings.has(form)) {
+              pendingWarnings.set(submitForm, pendingWarnings.get(form));
+              pendingWarnings.delete(form);
+            }
             submitForm.requestSubmit();
           } catch (err) {
             reject(err instanceof Error ? err : new Error(String(err)));
@@ -888,17 +995,37 @@ function attachSubmitInterceptor(form, toolName) {
     pendingExecutions.delete(form);
     const formData = serializeFormData(form, lastParams.get(form), formFieldElements.get(form));
     lastFilledSnapshot.delete(form);
-    const missing = pendingWarnings.get(form);
+    const missingRequired = pendingWarnings.get(form) ?? [];
     pendingWarnings.delete(form);
     const fillWarnings = pendingFillWarnings.get(form) ?? [];
     pendingFillWarnings.delete(form);
-    const allWarnings = [
-      ...missing?.length ? [`required fields were not filled: ${missing.join(", ")}`] : [],
-      ...fillWarnings
+    const skippedFields = fillWarnings.filter((w) => w.type === "not_filled").map((w) => w.field);
+    const structured = {
+      status: missingRequired.length > 0 || skippedFields.length > 0 ? "partial" : "success",
+      filled_fields: formData,
+      skipped_fields: skippedFields,
+      missing_required: missingRequired,
+      warnings: [
+        ...missingRequired.map((f) => ({
+          field: f,
+          type: "missing_required",
+          message: `required field "${f}" was not provided`
+        })),
+        ...fillWarnings
+      ]
+    };
+    const allWarnMessages = [
+      ...missingRequired.length ? [`required fields were not filled: ${missingRequired.join(", ")}`] : [],
+      ...fillWarnings.map((w) => w.message)
     ];
-    const warningText = allWarnings.length ? ` Note: ${allWarnings.join("; ")}.` : "";
+    const warningText = allWarnMessages.length ? ` Note: ${allWarnMessages.join("; ")}.` : "";
     const text = `Form submitted. Fields: ${JSON.stringify(formData)}${warningText}`;
-    const result = { content: [{ type: "text", text }] };
+    const result = {
+      content: [
+        { type: "text", text },
+        { type: "text", text: JSON.stringify(structured) }
+      ]
+    };
     if (e.agentInvoked && typeof e.respondWith === "function") {
       e.preventDefault();
       e.respondWith(Promise.resolve(result));
@@ -1032,16 +1159,26 @@ function fillInput(input, form, key, value) {
     const raw = String(value ?? "");
     const num = Number(raw);
     if (raw === "" || isNaN(num)) {
-      pendingFillWarnings.get(form)?.push(`"${key}" expects a number, got: ${JSON.stringify(value)}`);
+      pendingFillWarnings.get(form)?.push({
+        field: key,
+        type: "type_mismatch",
+        message: `"${key}" expects a number, got: ${JSON.stringify(value)}`,
+        original: value
+      });
       return;
     }
     const min = input.min !== "" ? parseFloat(input.min) : -Infinity;
     const max = input.max !== "" ? parseFloat(input.max) : Infinity;
     if (num < min || num > max) {
-      pendingFillWarnings.get(form)?.push(
-        `"${key}" value ${num} is outside allowed range [${input.min || "?"}, ${input.max || "?"}]`
-      );
-      input.value = String(Math.min(Math.max(num, min), max));
+      const clamped = Math.min(Math.max(num, min), max);
+      pendingFillWarnings.get(form)?.push({
+        field: key,
+        type: "clamped",
+        message: `"${key}" value ${num} is outside allowed range [${input.min || "?"}, ${input.max || "?"}], clamped to ${clamped}`,
+        original: num,
+        actual: clamped
+      });
+      input.value = String(clamped);
     } else {
       input.value = String(num);
     }