@tooluminati/testing 0.1.1 → 0.2.0

package/dist/browser-helpers-V33B4UD5.js

@@ -0,0 +1,8 @@
+import {
+  expectWebMcpTool,
+  invokeWebMcpTool
+} from "./chunk-M554RXAL.js";
+export {
+  expectWebMcpTool,
+  invokeWebMcpTool
+};

package/dist/browser-helpers.d.ts

@@ -1,6 +1,10 @@
+export interface WebMcpInvocationOptions {
+    /** Select explicitly for browsers that require JSON string input. Never retries execution. */
+    inputFormat?: 'object' | 'json-string';
+}
 export interface WebMcpTestPage {
     evaluate<T, A>(callback: (arg: A) => T | Promise<T>, arg: A): Promise<T>;
 }
 export declare function expectWebMcpTool(page: WebMcpTestPage, name: string): Promise<void>;
-export declare function invokeWebMcpTool<T>(page: WebMcpTestPage, name: string, args: unknown): Promise<T>;
+export declare function invokeWebMcpTool<T>(page: WebMcpTestPage, name: string, args: unknown, options?: WebMcpInvocationOptions): Promise<T>;
 //# sourceMappingURL=browser-helpers.d.ts.map

package/dist/browser-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser-helpers.d.ts","sourceRoot":"","sources":["../src/browser-helpers.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,CAAC,EAAE,CAAC,EACX,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACpC,GAAG,EAAE,CAAC,GACL,OAAO,CAAC,CAAC,CAAC,CAAC;CACf;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAef;AAED,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,CAAC,CAAC,CAoBZ"}
+{"version":3,"file":"browser-helpers.d.ts","sourceRoot":"","sources":["../src/browser-helpers.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,uBAAuB;IACtC,8FAA8F;IAC9F,WAAW,CAAC,EAAE,QAAQ,GAAG,aAAa,CAAC;CACxC;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC1E;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAef;AAED,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,CAAC,CAAC,CA4BZ"}

package/dist/browser-helpers.js

@@ -9,8 +9,8 @@ export async function expectWebMcpTool(page, name) {
         throw new Error(`Expected WebMCP tool "${name}" to be registered.`);
     }
 }
-export async function invokeWebMcpTool(page, name, args) {
-    return page.evaluate(async ({ toolName, input }) => {
+export async function invokeWebMcpTool(page, name, args, options = {}) {
+    return page.evaluate(async ({ toolName, input, inputFormat }) => {
         const context = document
             .modelContext;
         const tools = (await context?.getTools?.()) ?? [];
@@ -18,6 +18,7 @@ export async function invokeWebMcpTool(page, name, args) {
         if (!tool || !context?.executeTool) {
             throw new Error(`WebMCP tool "${toolName}" cannot be invoked.`);
         }
-        return context.executeTool(tool, JSON.stringify(input));
-    }, { toolName: name, input: args });
+        const payload = input && typeof input === 'object' ? input : {};
+        return context.executeTool(tool, inputFormat === 'json-string' ? JSON.stringify(payload) : payload);
+    }, { toolName: name, input: args, inputFormat: options.inputFormat });
 }

package/dist/chunk-K6KLEZGY.js

@@ -0,0 +1,146 @@
+import {
+  invokeWebMcpTool
+} from "./chunk-M554RXAL.js";
+
+// src/dom-only-inspection.ts
+function pushUnique(target, value) {
+  const trimmed = value?.trim();
+  if (!trimmed || target.includes(trimmed)) {
+    return;
+  }
+  target.push(trimmed);
+}
+function collectDisabledActionReasonsFromDom(root, buttonLabel) {
+  const buttons = [...root.querySelectorAll("button")];
+  const button = buttons.find(
+    (candidate) => candidate.textContent?.includes(buttonLabel)
+  );
+  if (!button) {
+    return {
+      label: buttonLabel,
+      disabled: false,
+      visibleBlockerReasons: []
+    };
+  }
+  const visibleBlockerReasons = [];
+  pushUnique(visibleBlockerReasons, button.getAttribute("title"));
+  pushUnique(
+    visibleBlockerReasons,
+    button.getAttribute("aria-label")?.includes("because") ? button.getAttribute("aria-label") : null
+  );
+  const describedBy = button.getAttribute("aria-describedby");
+  if (describedBy) {
+    for (const id of describedBy.split(/\s+/)) {
+      pushUnique(
+        visibleBlockerReasons,
+        root.getElementById(id)?.textContent
+      );
+    }
+  }
+  const fieldset = button.closest("fieldset");
+  if (fieldset) {
+    pushUnique(
+      visibleBlockerReasons,
+      fieldset.querySelector("legend")?.textContent
+    );
+  }
+  const row = button.closest('[data-testid="checkout-row"]');
+  if (row) {
+    pushUnique(
+      visibleBlockerReasons,
+      row.querySelector("[data-dom-blocker-hint]")?.textContent
+    );
+  }
+  return {
+    label: buttonLabel,
+    disabled: button.disabled,
+    visibleBlockerReasons
+  };
+}
+async function inspectDisabledActionFromDom(page, buttonLabel) {
+  return page.evaluate((label) => {
+    const buttons = [...document.querySelectorAll("button")];
+    const button = buttons.find(
+      (candidate) => candidate.textContent?.includes(label)
+    );
+    if (!button) {
+      return {
+        label,
+        disabled: false,
+        visibleBlockerReasons: []
+      };
+    }
+    const visibleBlockerReasons = [];
+    const push = (value) => {
+      const trimmed = value?.trim();
+      if (trimmed && !visibleBlockerReasons.includes(trimmed)) {
+        visibleBlockerReasons.push(trimmed);
+      }
+    };
+    push(button.getAttribute("title"));
+    const ariaLabel = button.getAttribute("aria-label");
+    if (ariaLabel?.includes("because")) {
+      push(ariaLabel);
+    }
+    const describedBy = button.getAttribute("aria-describedby");
+    if (describedBy) {
+      for (const id of describedBy.split(/\s+/)) {
+        push(document.getElementById(id)?.textContent);
+      }
+    }
+    const fieldset = button.closest("fieldset");
+    if (fieldset) {
+      push(fieldset.querySelector("legend")?.textContent);
+    }
+    const row = button.closest('[data-testid="checkout-row"]');
+    if (row) {
+      push(row.querySelector("[data-dom-blocker-hint]")?.textContent);
+    }
+    return {
+      label,
+      disabled: button.disabled,
+      visibleBlockerReasons
+    };
+  }, buttonLabel);
+}
+
+// src/comparative-proof.ts
+async function diagnoseCheckoutBlockerFromDomOnly(page, buttonLabel) {
+  return inspectDisabledActionFromDom(page, buttonLabel);
+}
+async function diagnoseCheckoutBlockerFromWebMcp(page, actionId, toolName = "why_is_action_unavailable") {
+  const result = await invokeWebMcpTool(page, toolName, { actionId });
+  return {
+    actionId: result.actionId,
+    available: result.available,
+    reasons: result.reasons ?? []
+  };
+}
+async function runComparativeProof(page, options) {
+  const domOnly = await diagnoseCheckoutBlockerFromDomOnly(
+    page,
+    options.buttonLabel
+  );
+  const webMcp = await diagnoseCheckoutBlockerFromWebMcp(
+    page,
+    options.actionId,
+    options.toolName
+  );
+  const domBlockerCount = domOnly.visibleBlockerReasons.length;
+  const webMcpBlockerCount = webMcp.reasons.length;
+  return {
+    domOnly,
+    webMcp,
+    domBlockerCount,
+    webMcpBlockerCount,
+    webMcpIsStrictlyMoreInformative: domOnly.disabled && domBlockerCount === 0 && webMcpBlockerCount > 0 && !webMcp.available
+  };
+}
+
+export {
+  collectDisabledActionReasonsFromDom,
+  inspectDisabledActionFromDom,
+  diagnoseCheckoutBlockerFromDomOnly,
+  diagnoseCheckoutBlockerFromWebMcp,
+  runComparativeProof
+};

package/dist/chunk-M554RXAL.js

@@ -0,0 +1,34 @@
+// src/browser-helpers.ts
+async function expectWebMcpTool(page, name) {
+  const exists = await page.evaluate(async (toolName) => {
+    const context = document.modelContext;
+    const tools = await context?.getTools?.() ?? [];
+    return tools.some((tool) => tool.name === toolName);
+  }, name);
+  if (!exists) {
+    throw new Error(`Expected WebMCP tool "${name}" to be registered.`);
+  }
+}
+async function invokeWebMcpTool(page, name, args, options = {}) {
+  return page.evaluate(
+    async ({ toolName, input, inputFormat }) => {
+      const context = document.modelContext;
+      const tools = await context?.getTools?.() ?? [];
+      const tool = tools.find((candidate) => candidate.name === toolName);
+      if (!tool || !context?.executeTool) {
+        throw new Error(`WebMCP tool "${toolName}" cannot be invoked.`);
+      }
+      const payload = input && typeof input === "object" ? input : {};
+      return context.executeTool(
+        tool,
+        inputFormat === "json-string" ? JSON.stringify(payload) : payload
+      );
+    },
+    { toolName: name, input: args, inputFormat: options.inputFormat }
+  );
+}
+
+export {
+  expectWebMcpTool,
+  invokeWebMcpTool
+};

package/dist/comparative-proof-IVDBBIIG.js

@@ -0,0 +1,11 @@
+import {
+  diagnoseCheckoutBlockerFromDomOnly,
+  diagnoseCheckoutBlockerFromWebMcp,
+  runComparativeProof
+} from "./chunk-K6KLEZGY.js";
+import "./chunk-M554RXAL.js";
+export {
+  diagnoseCheckoutBlockerFromDomOnly,
+  diagnoseCheckoutBlockerFromWebMcp,
+  runComparativeProof
+};

package/dist/devtools-mcp-helper.d.ts

@@ -1,3 +1,4 @@
+import type { WebMcpInvocationOptions } from './browser-helpers';
 export interface WebMcpToolListing {
     name: string;
     description?: string | undefined;
@@ -5,13 +6,13 @@ export interface WebMcpToolListing {
 type ModelContextHost = Document | Navigator;
 /**
  * Lists registered WebMCP tools from the browser model context.
- * Returns an empty array when WebMCP is unavailable (e.g. CI without Chrome 149).
+ * Returns an empty array when WebMCP is unavailable.
  */
 export declare function listWebMcpTools(host?: ModelContextHost): Promise<WebMcpToolListing[]>;
 /**
  * Executes a registered WebMCP tool by name.
- * Throws when WebMCP is unavailable or the tool cannot be resolved.
+ * Uses object input by default; legacy JSON string input must be explicitly selected.
  */
-export declare function executeWebMcpTool(name: string, args?: unknown, host?: ModelContextHost): Promise<unknown>;
+export declare function executeWebMcpTool(name: string, args?: unknown, host?: ModelContextHost, options?: WebMcpInvocationOptions): Promise<unknown>;
 export {};
 //# sourceMappingURL=devtools-mcp-helper.d.ts.map

package/dist/devtools-mcp-helper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"devtools-mcp-helper.d.ts","sourceRoot":"","sources":["../src/devtools-mcp-helper.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AAED,KAAK,gBAAgB,GAAG,QAAQ,GAAG,SAAS,CAAC;AAsB7C;;;GAGG;AACH,wBAAsB,eAAe,CACnC,IAAI,GAAE,gBAA2B,GAChC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAW9B;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,OAAY,EAClB,IAAI,GAAE,gBAA2B,GAChC,OAAO,CAAC,OAAO,CAAC,CAelB"}
+{"version":3,"file":"devtools-mcp-helper.d.ts","sourceRoot":"","sources":["../src/devtools-mcp-helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAGjE,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AAED,KAAK,gBAAgB,GAAG,QAAQ,GAAG,SAAS,CAAC;AA6B7C;;;GAGG;AACH,wBAAsB,eAAe,CACnC,IAAI,GAAE,gBAA2B,GAChC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAW9B;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,OAAY,EAClB,IAAI,GAAE,gBAA2B,EACjC,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,OAAO,CAAC,CAmBlB"}

package/dist/devtools-mcp-helper.js

@@ -1,9 +1,10 @@
 function getModelContext(host = document) {
-    return host.modelContext;
+    return host
+        .modelContext;
 }
 /**
  * Lists registered WebMCP tools from the browser model context.
- * Returns an empty array when WebMCP is unavailable (e.g. CI without Chrome 149).
+ * Returns an empty array when WebMCP is unavailable.
  */
 export async function listWebMcpTools(host = document) {
     const context = getModelContext(host);
@@ -18,9 +19,9 @@ export async function listWebMcpTools(host = document) {
 }
 /**
  * Executes a registered WebMCP tool by name.
- * Throws when WebMCP is unavailable or the tool cannot be resolved.
+ * Uses object input by default; legacy JSON string input must be explicitly selected.
  */
-export async function executeWebMcpTool(name, args = {}, host = document) {
+export async function executeWebMcpTool(name, args = {}, host = document, options = {}) {
     const context = getModelContext(host);
     if (!context?.getTools || !context.executeTool) {
         throw new Error('WebMCP model context is unavailable. Use installModelContextMock() in tests.');
@@ -30,5 +31,6 @@ export async function executeWebMcpTool(name, args = {}, host = document) {
     if (!tool) {
         throw new Error(`WebMCP tool not found: ${name}`);
     }
-    return context.executeTool(tool, JSON.stringify(args));
+    const payload = args && typeof args === 'object' ? args : {};
+    return context.executeTool(tool, options.inputFormat === 'json-string' ? JSON.stringify(payload) : payload);
 }

package/dist/index.cjs

@@ -36,18 +36,22 @@ async function expectWebMcpTool(page, name) {
     throw new Error(`Expected WebMCP tool "${name}" to be registered.`);
   }
 }
-async function invokeWebMcpTool(page, name, args) {
+async function invokeWebMcpTool(page, name, args, options = {}) {
   return page.evaluate(
-    async ({ toolName, input }) => {
+    async ({ toolName, input, inputFormat }) => {
       const context = document.modelContext;
       const tools = await context?.getTools?.() ?? [];
       const tool = tools.find((candidate) => candidate.name === toolName);
       if (!tool || !context?.executeTool) {
         throw new Error(`WebMCP tool "${toolName}" cannot be invoked.`);
       }
-      return context.executeTool(tool, JSON.stringify(input));
+      const payload = input && typeof input === "object" ? input : {};
+      return context.executeTool(
+        tool,
+        inputFormat === "json-string" ? JSON.stringify(payload) : payload
+      );
     },
-    { toolName: name, input: args }
+    { toolName: name, input: args, inputFormat: options.inputFormat }
   );
 }
 var init_browser_helpers = __esm({
@@ -225,6 +229,7 @@ __export(index_exports, {
   installModelContextMock: () => installModelContextMock,
   invokeWebMcpTool: () => invokeWebMcpTool,
   listWebMcpTools: () => listWebMcpTools,
+  parseExecuteToolInput: () => parseExecuteToolInput,
   runComparativeProof: () => runComparativeProof,
   runTimelineComparativeProof: () => runTimelineComparativeProof,
   runToolSelectionSmokeTest: () => runToolSelectionSmokeTest,
@@ -249,7 +254,7 @@ async function listWebMcpTools(host = document) {
     description: tool.description
   }));
 }
-async function executeWebMcpTool(name, args = {}, host = document) {
+async function executeWebMcpTool(name, args = {}, host = document, options = {}) {
   const context = getModelContext(host);
   if (!context?.getTools || !context.executeTool) {
     throw new Error(
@@ -261,13 +266,23 @@ async function executeWebMcpTool(name, args = {}, host = document) {
   if (!tool) {
     throw new Error(`WebMCP tool not found: ${name}`);
   }
-  return context.executeTool(tool, JSON.stringify(args));
+  const payload = args && typeof args === "object" ? args : {};
+  return context.executeTool(
+    tool,
+    options.inputFormat === "json-string" ? JSON.stringify(payload) : payload
+  );
 }
 
 // src/index.ts
 init_dom_only_inspection();
 
 // src/mock-model-context.ts
+function parseExecuteToolInput(input) {
+  if (typeof input === "string") {
+    return JSON.parse(input || "{}");
+  }
+  return input ?? {};
+}
 var MockModelContext = class extends EventTarget {
   tools = /* @__PURE__ */ new Map();
   invocations = [];
@@ -292,7 +307,7 @@ var MockModelContext = class extends EventTarget {
   async getTools() {
     return [...this.tools.values()];
   }
-  async executeTool(toolOrName, argsJson = "{}") {
+  async executeTool(toolOrName, input = {}, options = {}) {
     const name = typeof toolOrName === "string" ? toolOrName : toolOrName.name;
     if (!name) {
       throw new Error("Tool name is required.");
@@ -301,10 +316,10 @@ var MockModelContext = class extends EventTarget {
     if (!tool) {
       throw new Error(`Tool not found: ${name}`);
     }
-    const args = JSON.parse(argsJson);
+    const args = parseExecuteToolInput(input);
     try {
       const result = await tool.execute(args, {
-        signal: new AbortController().signal
+        signal: options.signal ?? new AbortController().signal
       });
       this.invocations.push({ name, args, result });
       return result;
@@ -331,6 +346,13 @@ var MODEL_CONTEXT_MOCK_INIT_SCRIPT = `
 (() => {
   const tools = new Map();
 
+  function parseInput(input) {
+    if (typeof input === 'string') {
+      return JSON.parse(input || '{}');
+    }
+    return input ?? {};
+  }
+
   Object.defineProperty(document, 'modelContext', {
     configurable: true,
     value: {
@@ -351,7 +373,7 @@ var MODEL_CONTEXT_MOCK_INIT_SCRIPT = `
       async getTools() {
         return [...tools.values()];
       },
-      async executeTool(toolOrName, argsJson = '{}') {
+      async executeTool(toolOrName, input = {}, options = {}) {
         const name =
           typeof toolOrName === 'string'
             ? toolOrName
@@ -361,7 +383,9 @@ var MODEL_CONTEXT_MOCK_INIT_SCRIPT = `
           throw new Error('Tool not found: ' + name);
         }
 
-        return tool.execute(JSON.parse(argsJson));
+        return tool.execute(parseInput(input), {
+          signal: options.signal ?? new AbortController().signal,
+        });
       },
     },
   });
@@ -466,6 +490,7 @@ async function runTimelineComparativeProof(page, options) {
   installModelContextMock,
   invokeWebMcpTool,
   listWebMcpTools,
+  parseExecuteToolInput,
   runComparativeProof,
   runTimelineComparativeProof,
   runToolSelectionSmokeTest,

package/dist/index.js

@@ -4,11 +4,11 @@ import {
   diagnoseCheckoutBlockerFromWebMcp,
   inspectDisabledActionFromDom,
   runComparativeProof
-} from "./chunk-EG3BG65X.js";
+} from "./chunk-K6KLEZGY.js";
 import {
   expectWebMcpTool,
   invokeWebMcpTool
-} from "./chunk-6YAIOYYZ.js";
+} from "./chunk-M554RXAL.js";
 
 // src/devtools-mcp-helper.ts
 function getModelContext(host = document) {
@@ -25,7 +25,7 @@ async function listWebMcpTools(host = document) {
     description: tool.description
   }));
 }
-async function executeWebMcpTool(name, args = {}, host = document) {
+async function executeWebMcpTool(name, args = {}, host = document, options = {}) {
   const context = getModelContext(host);
   if (!context?.getTools || !context.executeTool) {
     throw new Error(
@@ -37,10 +37,20 @@ async function executeWebMcpTool(name, args = {}, host = document) {
   if (!tool) {
     throw new Error(`WebMCP tool not found: ${name}`);
   }
-  return context.executeTool(tool, JSON.stringify(args));
+  const payload = args && typeof args === "object" ? args : {};
+  return context.executeTool(
+    tool,
+    options.inputFormat === "json-string" ? JSON.stringify(payload) : payload
+  );
 }
 
 // src/mock-model-context.ts
+function parseExecuteToolInput(input) {
+  if (typeof input === "string") {
+    return JSON.parse(input || "{}");
+  }
+  return input ?? {};
+}
 var MockModelContext = class extends EventTarget {
   tools = /* @__PURE__ */ new Map();
   invocations = [];
@@ -65,7 +75,7 @@ var MockModelContext = class extends EventTarget {
   async getTools() {
     return [...this.tools.values()];
   }
-  async executeTool(toolOrName, argsJson = "{}") {
+  async executeTool(toolOrName, input = {}, options = {}) {
     const name = typeof toolOrName === "string" ? toolOrName : toolOrName.name;
     if (!name) {
       throw new Error("Tool name is required.");
@@ -74,10 +84,10 @@ var MockModelContext = class extends EventTarget {
     if (!tool) {
       throw new Error(`Tool not found: ${name}`);
     }
-    const args = JSON.parse(argsJson);
+    const args = parseExecuteToolInput(input);
     try {
       const result = await tool.execute(args, {
-        signal: new AbortController().signal
+        signal: options.signal ?? new AbortController().signal
       });
       this.invocations.push({ name, args, result });
       return result;
@@ -104,6 +114,13 @@ var MODEL_CONTEXT_MOCK_INIT_SCRIPT = `
 (() => {
   const tools = new Map();
 
+  function parseInput(input) {
+    if (typeof input === 'string') {
+      return JSON.parse(input || '{}');
+    }
+    return input ?? {};
+  }
+
   Object.defineProperty(document, 'modelContext', {
     configurable: true,
     value: {
@@ -124,7 +141,7 @@ var MODEL_CONTEXT_MOCK_INIT_SCRIPT = `
       async getTools() {
         return [...tools.values()];
       },
-      async executeTool(toolOrName, argsJson = '{}') {
+      async executeTool(toolOrName, input = {}, options = {}) {
         const name =
           typeof toolOrName === 'string'
             ? toolOrName
@@ -134,7 +151,9 @@ var MODEL_CONTEXT_MOCK_INIT_SCRIPT = `
           throw new Error('Tool not found: ' + name);
         }
 
-        return tool.execute(JSON.parse(argsJson));
+        return tool.execute(parseInput(input), {
+          signal: options.signal ?? new AbortController().signal,
+        });
       },
     },
   });
@@ -208,8 +227,8 @@ function runToolSelectionSmokeTest(tools, prompt, expected) {
   return haystack.includes(expected.toLowerCase()) || tools.some((t) => t.name === expected);
 }
 async function runTimelineComparativeProof(page, options) {
-  const { runComparativeProof: runComparativeProof2 } = await import("./comparative-proof-QUN7C3KM.js");
-  const { invokeWebMcpTool: invokeWebMcpTool2 } = await import("./browser-helpers-RSQLRHHZ.js");
+  const { runComparativeProof: runComparativeProof2 } = await import("./comparative-proof-IVDBBIIG.js");
+  const { invokeWebMcpTool: invokeWebMcpTool2 } = await import("./browser-helpers-V33B4UD5.js");
   const proof = await runComparativeProof2(page, {
     buttonLabel: options.buttonLabel,
     actionId: options.actionId
@@ -238,6 +257,7 @@ export {
   installModelContextMock,
   invokeWebMcpTool,
   listWebMcpTools,
+  parseExecuteToolInput,
   runComparativeProof,
   runTimelineComparativeProof,
   runToolSelectionSmokeTest,

package/dist/invocation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=invocation.test.d.ts.map

package/dist/invocation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invocation.test.d.ts","sourceRoot":"","sources":["../src/invocation.test.ts"],"names":[],"mappings":""}

package/dist/invocation.test.js

@@ -0,0 +1,95 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { expectWebMcpTool, invokeWebMcpTool, } from './browser-helpers';
+import { executeWebMcpTool, listWebMcpTools } from './devtools-mcp-helper';
+const page = {
+    evaluate: async (callback, arg) => callback(arg),
+};
+const original = Object.getOwnPropertyDescriptor(document, 'modelContext');
+afterEach(() => {
+    if (original)
+        Object.defineProperty(document, 'modelContext', original);
+    else
+        Reflect.deleteProperty(document, 'modelContext');
+});
+function install(context) {
+    Object.defineProperty(document, 'modelContext', {
+        configurable: true,
+        value: context,
+    });
+}
+const tool = { name: 'write_item', description: 'Writes an item.' };
+const callers = [
+    [
+        'DevTools',
+        (args, options) => executeWebMcpTool(tool.name, args, document, options),
+    ],
+    [
+        'Playwright',
+        (args, options) => invokeWebMcpTool(page, tool.name, args, options),
+    ],
+];
+for (const [label, invoke] of callers) {
+    describe(label, () => {
+        it('passes the discovered descriptor and object exactly once', async () => {
+            const executeTool = vi.fn().mockResolvedValue({ saved: true });
+            install({ getTools: async () => [tool], executeTool });
+            await expect(invoke({ id: 3 })).resolves.toEqual({ saved: true });
+            expect(executeTool).toHaveBeenCalledExactlyOnceWith(tool, { id: 3 });
+        });
+        it('selects legacy string encoding before executing', async () => {
+            const executeTool = vi.fn().mockResolvedValue('saved');
+            install({ getTools: async () => [tool], executeTool });
+            await expect(invoke({ id: 3 }, { inputFormat: 'json-string' })).resolves.toBe('saved');
+            expect(executeTool).toHaveBeenCalledExactlyOnceWith(tool, '{"id":3}');
+        });
+        it.each([
+            new TypeError('handler failed after write'),
+            new Error('failed'),
+            new DOMException('cancelled', 'AbortError'),
+        ])('never retries a failed execution (%s)', async (error) => {
+            const executeTool = vi.fn().mockRejectedValue(error);
+            install({ getTools: async () => [tool], executeTool });
+            await expect(invoke({})).rejects.toBe(error);
+            expect(executeTool).toHaveBeenCalledTimes(1);
+        });
+        it('propagates legacy failures without retrying', async () => {
+            const error = new TypeError('legacy failure');
+            const executeTool = vi.fn().mockRejectedValue(error);
+            install({ getTools: async () => [tool], executeTool });
+            await expect(invoke({}, { inputFormat: 'json-string' })).rejects.toBe(error);
+            expect(executeTool).toHaveBeenCalledTimes(1);
+        });
+        it.each([undefined, null, 5, 'text'])('normalizes non-object input %s to empty input', async (input) => {
+            const executeTool = vi.fn();
+            install({ getTools: async () => [tool], executeTool });
+            await invoke(input);
+            expect(executeTool).toHaveBeenCalledExactlyOnceWith(tool, {});
+        });
+        it.each([undefined, {}, { getTools: async () => [] }])('rejects unavailable tools or APIs', async (context) => {
+            install(context);
+            await expect(invoke({})).rejects.toThrow();
+        });
+        it('never invokes a missing tool', async () => {
+            const executeTool = vi.fn();
+            install({ getTools: async () => [], executeTool });
+            await expect(invoke({})).rejects.toThrow();
+            expect(executeTool).not.toHaveBeenCalled();
+        });
+        it('propagates discovery errors', async () => {
+            const error = new Error('discovery failed');
+            const executeTool = vi.fn();
+            install({ getTools: vi.fn().mockRejectedValue(error), executeTool });
+            await expect(invoke({})).rejects.toBe(error);
+            expect(executeTool).not.toHaveBeenCalled();
+        });
+    });
+}
+it('lists safe metadata and checks tool presence', async () => {
+    install({ getTools: async () => [{ ...tool, execute: () => undefined }] });
+    await expect(listWebMcpTools()).resolves.toEqual([tool]);
+    await expect(expectWebMcpTool(page, tool.name)).resolves.toBeUndefined();
+    await expect(expectWebMcpTool(page, 'missing')).rejects.toThrow('missing');
+    install(undefined);
+    await expect(listWebMcpTools()).resolves.toEqual([]);
+    await expect(expectWebMcpTool(page, tool.name)).rejects.toThrow(tool.name);
+});

package/dist/mock-model-context.d.ts

@@ -1,5 +1,6 @@
-import type { BrowserModelContextTestingExtensions, BrowserWebMcpToolDescriptor, WebMcpRegisterToolOptions } from '@tooluminati/core';
-export declare class MockModelContext extends EventTarget implements BrowserModelContextTestingExtensions {
+import type { BrowserModelContext, BrowserWebMcpToolDescriptor, WebMcpExecuteToolOptions, WebMcpRegisterToolOptions } from '@tooluminati/core';
+export declare function parseExecuteToolInput(input: unknown): unknown;
+export declare class MockModelContext extends EventTarget implements BrowserModelContext {
     readonly tools: Map<string, BrowserWebMcpToolDescriptor>;
     readonly invocations: Array<{
         name: string;
@@ -9,6 +10,6 @@ export declare class MockModelContext extends EventTarget implements BrowserMode
     }>;
     registerTool(tool: BrowserWebMcpToolDescriptor, options?: WebMcpRegisterToolOptions): void;
     getTools(): Promise<BrowserWebMcpToolDescriptor[]>;
-    executeTool(toolOrName: unknown, argsJson?: string): Promise<unknown>;
+    executeTool(toolOrName: unknown, input?: object | string, options?: WebMcpExecuteToolOptions): Promise<unknown>;
 }
 //# sourceMappingURL=mock-model-context.d.ts.map

package/dist/mock-model-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mock-model-context.d.ts","sourceRoot":"","sources":["../src/mock-model-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oCAAoC,EACpC,2BAA2B,EAC3B,yBAAyB,EAC1B,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,gBACX,SAAQ,WACR,YAAW,oCAAoC;IAE/C,QAAQ,CAAC,KAAK,2CAAkD;IAChE,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;QAC1B,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,OAAO,CAAC;QACd,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB,CAAC,CAAM;IAER,YAAY,CACV,IAAI,EAAE,2BAA2B,EACjC,OAAO,GAAE,yBAA8B,GACtC,IAAI;IAsBD,QAAQ,IAAI,OAAO,CAAC,2BAA2B,EAAE,CAAC;IAIlD,WAAW,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,SAAO,GAAG,OAAO,CAAC,OAAO,CAAC;CA0B1E"}
+{"version":3,"file":"mock-model-context.d.ts","sourceRoot":"","sources":["../src/mock-model-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,mBAAmB,CAAC;AAE3B,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAM7D;AAED,qBAAa,gBACX,SAAQ,WACR,YAAW,mBAAmB;IAE9B,QAAQ,CAAC,KAAK,2CAAkD;IAChE,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;QAC1B,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,OAAO,CAAC;QACd,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB,CAAC,CAAM;IAER,YAAY,CACV,IAAI,EAAE,2BAA2B,EACjC,OAAO,GAAE,yBAA8B,GACtC,IAAI;IAsBD,QAAQ,IAAI,OAAO,CAAC,2BAA2B,EAAE,CAAC;IAIlD,WAAW,CACf,UAAU,EAAE,OAAO,EACnB,KAAK,GAAE,MAAM,GAAG,MAAW,EAC3B,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,OAAO,CAAC;CA0BpB"}

package/dist/mock-model-context.js

@@ -1,3 +1,9 @@
+export function parseExecuteToolInput(input) {
+    if (typeof input === 'string') {
+        return JSON.parse(input || '{}');
+    }
+    return input ?? {};
+}
 export class MockModelContext extends EventTarget {
     tools = new Map();
     invocations = [];
@@ -18,7 +24,7 @@ export class MockModelContext extends EventTarget {
     async getTools() {
         return [...this.tools.values()];
     }
-    async executeTool(toolOrName, argsJson = '{}') {
+    async executeTool(toolOrName, input = {}, options = {}) {
         const name = typeof toolOrName === 'string'
             ? toolOrName
             : toolOrName.name;
@@ -29,10 +35,10 @@ export class MockModelContext extends EventTarget {
         if (!tool) {
             throw new Error(`Tool not found: ${name}`);
         }
-        const args = JSON.parse(argsJson);
+        const args = parseExecuteToolInput(input);
         try {
             const result = await tool.execute(args, {
-                signal: new AbortController().signal,
+                signal: options.signal ?? new AbortController().signal,
             });
             this.invocations.push({ name, args, result });
             return result;

package/dist/mock-model-context.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mock-model-context.test.d.ts.map

package/dist/mock-model-context.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-model-context.test.d.ts","sourceRoot":"","sources":["../src/mock-model-context.test.ts"],"names":[],"mappings":""}

package/dist/mock-model-context.test.js

@@ -0,0 +1,106 @@
+import { afterEach, describe, expect, expectTypeOf, it, vi } from 'vitest';
+import { MockModelContext, parseExecuteToolInput } from './mock-model-context';
+import { MODEL_CONTEXT_MOCK_INIT_SCRIPT } from './model-context-mock-script';
+const original = Object.getOwnPropertyDescriptor(document, 'modelContext');
+afterEach(() => {
+    if (original)
+        Object.defineProperty(document, 'modelContext', original);
+    else
+        Reflect.deleteProperty(document, 'modelContext');
+});
+it.each([
+    [{}, {}],
+    ['{"id":2}', { id: 2 }],
+    ['', {}],
+    [undefined, {}],
+    [null, {}],
+])('parses %s', (input, expected) => {
+    expect(parseExecuteToolInput(input)).toEqual(expected);
+});
+it('preserves object identity and rejects invalid JSON', () => {
+    const args = { id: 2 };
+    expect(parseExecuteToolInput(args)).toBe(args);
+    expect(() => parseExecuteToolInput('{broken')).toThrow(SyntaxError);
+});
+it('accepts fromOrigins on the public discovery contract', () => {
+    expectTypeOf().toEqualTypeOf();
+});
+for (const variant of ['class', 'init script']) {
+    const create = () => {
+        if (variant === 'class')
+            return new MockModelContext();
+        window.eval(MODEL_CONTEXT_MOCK_INIT_SCRIPT);
+        return document
+            .modelContext;
+    };
+    describe(variant, () => {
+        it.each([{}, '{"id":2}', undefined])('executes descriptor input %s and forwards client cancellation', async (input) => {
+            const context = create();
+            const client = new AbortController();
+            const execute = vi.fn().mockResolvedValue('ok');
+            context.registerTool({ name: 'read', description: 'Reads.', execute });
+            const [tool] = await context.getTools();
+            await expect(context.executeTool(tool, input, { signal: client.signal })).resolves.toBe('ok');
+            expect(execute).toHaveBeenCalledExactlyOnceWith(parseExecuteToolInput(input), { signal: client.signal });
+            client.abort();
+            expect(execute.mock.calls[0][1].signal.aborted).toBe(true);
+            expect(await context.getTools()).toHaveLength(1);
+        });
+        it('unregisters without aborting an executing callback', async () => {
+            const context = create();
+            const controller = new AbortController();
+            let finish;
+            let signal;
+            context.registerTool({
+                name: 'read',
+                description: 'Reads.',
+                execute: (_args, client) => {
+                    signal = client.signal;
+                    return new Promise((resolve) => {
+                        finish = resolve;
+                    });
+                },
+            }, { signal: controller.signal });
+            const result = context.executeTool('read', {});
+            controller.abort();
+            expect(await context.getTools()).toEqual([]);
+            expect(signal.aborted).toBe(false);
+            finish('finished');
+            await expect(result).resolves.toBe('finished');
+        });
+        it('skips pre-aborted registrations and rejects missing tools and invalid JSON', async () => {
+            const context = create();
+            const controller = new AbortController();
+            controller.abort();
+            const execute = vi.fn();
+            const tool = { name: 'read', description: 'Reads.', execute };
+            context.registerTool(tool, { signal: controller.signal });
+            expect(await context.getTools()).toEqual([]);
+            await expect(context.executeTool('absent')).rejects.toThrow();
+            await expect(context.executeTool({})).rejects.toThrow();
+            context.registerTool(tool);
+            await expect(context.executeTool('read', '{broken')).rejects.toThrow(SyntaxError);
+            expect(execute).not.toHaveBeenCalled();
+        });
+    });
+}
+it('records successful and failed invocations and emits toolchange on lifecycle changes', async () => {
+    const context = new MockModelContext();
+    const changed = vi.fn();
+    context.addEventListener('toolchange', changed);
+    const controller = new AbortController();
+    const error = new Error('failed');
+    const execute = vi
+        .fn()
+        .mockResolvedValueOnce('ok')
+        .mockRejectedValueOnce(error);
+    context.registerTool({ name: 'read', description: 'Reads.', execute }, { signal: controller.signal });
+    await context.executeTool('read', {});
+    await expect(context.executeTool('read', {})).rejects.toBe(error);
+    expect(context.invocations).toEqual([
+        { name: 'read', args: {}, result: 'ok' },
+        { name: 'read', args: {}, error },
+    ]);
+    controller.abort();
+    expect(changed).toHaveBeenCalledTimes(2);
+});

package/dist/model-context-mock-script.d.ts

@@ -1,2 +1,2 @@
-export declare const MODEL_CONTEXT_MOCK_INIT_SCRIPT = "\n(() => {\n  const tools = new Map();\n\n  Object.defineProperty(document, 'modelContext', {\n    configurable: true,\n    value: {\n      registerTool(tool, options = {}) {\n        if (options.signal?.aborted) {\n          return;\n        }\n\n        tools.set(tool.name, tool);\n        options.signal?.addEventListener(\n          'abort',\n          () => {\n            tools.delete(tool.name);\n          },\n          { once: true },\n        );\n      },\n      async getTools() {\n        return [...tools.values()];\n      },\n      async executeTool(toolOrName, argsJson = '{}') {\n        const name =\n          typeof toolOrName === 'string'\n            ? toolOrName\n            : toolOrName?.name;\n        const tool = name ? tools.get(name) : undefined;\n        if (!tool) {\n          throw new Error('Tool not found: ' + name);\n        }\n\n        return tool.execute(JSON.parse(argsJson));\n      },\n    },\n  });\n})();\n";
+export declare const MODEL_CONTEXT_MOCK_INIT_SCRIPT = "\n(() => {\n  const tools = new Map();\n\n  function parseInput(input) {\n    if (typeof input === 'string') {\n      return JSON.parse(input || '{}');\n    }\n    return input ?? {};\n  }\n\n  Object.defineProperty(document, 'modelContext', {\n    configurable: true,\n    value: {\n      registerTool(tool, options = {}) {\n        if (options.signal?.aborted) {\n          return;\n        }\n\n        tools.set(tool.name, tool);\n        options.signal?.addEventListener(\n          'abort',\n          () => {\n            tools.delete(tool.name);\n          },\n          { once: true },\n        );\n      },\n      async getTools() {\n        return [...tools.values()];\n      },\n      async executeTool(toolOrName, input = {}, options = {}) {\n        const name =\n          typeof toolOrName === 'string'\n            ? toolOrName\n            : toolOrName?.name;\n        const tool = name ? tools.get(name) : undefined;\n        if (!tool) {\n          throw new Error('Tool not found: ' + name);\n        }\n\n        return tool.execute(parseInput(input), {\n          signal: options.signal ?? new AbortController().signal,\n        });\n      },\n    },\n  });\n})();\n";
 //# sourceMappingURL=model-context-mock-script.d.ts.map

package/dist/model-context-mock-script.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model-context-mock-script.d.ts","sourceRoot":"","sources":["../src/model-context-mock-script.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B,67BAuC1C,CAAC"}
+{"version":3,"file":"model-context-mock-script.d.ts","sourceRoot":"","sources":["../src/model-context-mock-script.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B,0qCAgD1C,CAAC"}

package/dist/model-context-mock-script.js

@@ -2,6 +2,13 @@ export const MODEL_CONTEXT_MOCK_INIT_SCRIPT = `
 (() => {
   const tools = new Map();
 
+  function parseInput(input) {
+    if (typeof input === 'string') {
+      return JSON.parse(input || '{}');
+    }
+    return input ?? {};
+  }
+
   Object.defineProperty(document, 'modelContext', {
     configurable: true,
     value: {
@@ -22,7 +29,7 @@ export const MODEL_CONTEXT_MOCK_INIT_SCRIPT = `
       async getTools() {
         return [...tools.values()];
       },
-      async executeTool(toolOrName, argsJson = '{}') {
+      async executeTool(toolOrName, input = {}, options = {}) {
         const name =
           typeof toolOrName === 'string'
             ? toolOrName
@@ -32,7 +39,9 @@ export const MODEL_CONTEXT_MOCK_INIT_SCRIPT = `
           throw new Error('Tool not found: ' + name);
         }
 
-        return tool.execute(JSON.parse(argsJson));
+        return tool.execute(parseInput(input), {
+          signal: options.signal ?? new AbortController().signal,
+        });
       },
     },
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tooluminati/testing",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Testing utilities for Tooluminati.",
   "type": "module",
   "sideEffects": false,
@@ -15,7 +15,7 @@
     }
   },
   "dependencies": {
-    "@tooluminati/core": "0.1.1"
+    "@tooluminati/core": "0.2.0"
   },
   "files": [
     "dist"