Testing WebMCP Tools

Why test your WebMCP tools

WebMCP tools are part of your public interface, just like a form or an API endpoint. They break in the same ways:

• Registration: a deploy removes or renames a tool, so the agent no longer finds it.
• Schema: an input schema becomes invalid or stops matching what the tool actually accepts.
• Behavior: the tool registers fine but its execute() callback returns the wrong result, throws, or silently changes shape.
• Cross-browser: a tool works in one Chrome version but not another, or only when the page reaches a certain state.

Running these checks on real browsers in CI catches regressions before your users' AI agents do.

Prerequisites

• A TestingBot account with your key and secret.
• A website that registers WebMCP tools through navigator.modelContext.
• Google Chrome 149 or higher (WebMCP is currently a Chromium-only origin trial).
• The WebMCP testing surface enabled, so your test can list and invoke tools without a live AI agent. This exposes navigator.modelContextTesting with getTools() and executeTool().

Testing WebMCP tools

The pattern is the same in every framework: launch Chrome 149 or higher with the WebMCP testing flag, navigate to your page, then call navigator.modelContextTesting.getTools() to read the registered tools and navigator.modelContextTesting.executeTool(name, input) to invoke one and inspect its result.

from selenium import webdriver

options = webdriver.ChromeOptions()
options.browser_version = "latest"  # Chrome 149 or higher
# Enable the WebMCP testing surface (navigator.modelContextTesting) and the DevTools WebMCP domain
options.add_argument("--enable-features=WebMCPTesting,DevToolsWebMCPSupport")
options.set_capability("platformName", "WINDOWS")
options.set_capability("tb:options", {
    "key": "YOUR_KEY",
    "secret": "YOUR_SECRET",
    "name": "WebMCP tool test",
})

driver = webdriver.Remote(
    command_executor="https://hub.testingbot.com/wd/hub",
    options=options,
)

try:
    driver.get("https://your-site.com")

    if not driver.execute_script("return 'modelContextTesting' in navigator"):
        raise RuntimeError("WebMCP testing surface is not available in this browser")

    # 1. List the tools your site registered with navigator.modelContext
    tools = driver.execute_async_script("""
        const done = arguments[arguments.length - 1];
        navigator.modelContextTesting.getTools().then(done);
    """)
    names = [t["name"] for t in tools]
    assert "searchProducts" in names, names

    # 2. Invoke a tool and check the structured result
    result = driver.execute_async_script("""
        const [name, input, done] = arguments;
        navigator.modelContextTesting.executeTool(name, input).then(done);
    """, "searchProducts", {"query": "shoes"})
    assert result["total"] > 0
finally:
    driver.quit()

const { Builder } = require('selenium-webdriver')
const chrome = require('selenium-webdriver/chrome')

const options = new chrome.Options()
options.setBrowserVersion('latest') // Chrome 149 or higher
// Enable the WebMCP testing surface and the DevTools WebMCP domain (Chrome 149+)
options.addArguments('--enable-features=WebMCPTesting,DevToolsWebMCPSupport')
options.set('tb:options', {
  key: 'YOUR_KEY',
  secret: 'YOUR_SECRET',
  name: 'WebMCP tool test'
})

;(async () => {
  const driver = await new Builder()
    .usingServer('https://hub.testingbot.com/wd/hub')
    .forBrowser('chrome')
    .setChromeOptions(options)
    .build()

  try {
    await driver.get('https://your-site.com')

    // 1. List the registered tools
    const tools = await driver.executeAsyncScript(`
      const done = arguments[arguments.length - 1];
      navigator.modelContextTesting.getTools().then(done);
    `)
    console.log(tools.map(t => t.name))

    // 2. Invoke a tool and check its result
    const result = await driver.executeAsyncScript(`
      const [name, input, done] = arguments;
      navigator.modelContextTesting.executeTool(name, input).then(done);
    `, 'searchProducts', { query: 'shoes' })
    console.log(result)
  } finally {
    await driver.quit()
  }
})()

const playwright = require('playwright')

const capabilities = {
  'tb:options': {
    key: 'YOUR_KEY',
    secret: 'YOUR_SECRET',
    name: 'WebMCP tool test'
  },
  browserName: 'chrome',
  browserVersion: 'latest', // Chrome 149 or higher
  // Enable the WebMCP testing surface and the DevTools WebMCP domain (Chrome 149+)
  'goog:chromeOptions': { args: ['--enable-features=WebMCPTesting,DevToolsWebMCPSupport'] }
}

;(async () => {
  const browser = await playwright.chromium.connect(
    `wss://cloud.testingbot.com/playwright?capabilities=${encodeURIComponent(JSON.stringify(capabilities))}`
  )
  const page = await browser.newPage()
  await page.goto('https://your-site.com')

  // 1. List the registered tools
  const tools = await page.evaluate(() => navigator.modelContextTesting.getTools())
  console.log(tools.map(t => t.name))

  // 2. Invoke a tool and check its result
  const result = await page.evaluate(
    ([name, input]) => navigator.modelContextTesting.executeTool(name, input),
    ['searchProducts', { query: 'shoes' }]
  )
  console.log(result)

  await browser.close()
})()

// Puppeteer 25.1.0 or higher ships a native page.webmcp API
const puppeteer = require('puppeteer-core')

const capabilities = {
  'tb:options': {
    key: 'YOUR_KEY',
    secret: 'YOUR_SECRET',
    name: 'WebMCP tool test'
  },
  browserName: 'chrome',
  browserVersion: 'latest', // Chrome 149 or higher
  // Enable the WebMCP testing surface and the DevTools WebMCP domain
  'goog:chromeOptions': { args: ['--enable-features=WebMCPTesting,DevToolsWebMCPSupport'] }
}

;(async () => {
  const browser = await puppeteer.connect({
    browserWSEndpoint: `wss://cloud.testingbot.com/puppeteer?capabilities=${encodeURIComponent(JSON.stringify(capabilities))}`
  })
  const page = await browser.newPage()
  await page.goto('https://your-site.com')

  // 1. List the tools your site registered with navigator.modelContext
  const tools = page.webmcp.tools()
  console.log(tools.map(t => t.name))

  // 2. Invoke a tool and check its structured result
  const tool = tools.find(t => t.name === 'searchProducts')
  if (tool) {
    const result = await tool.execute({ query: 'shoes' })
    if (result.status === 'Completed') {
      console.log(result.output)
    }
  }

  await browser.close()
})()

After the run, mark the test as passed or failed in your TestingBot dashboard the same way you do for any other test, either from your test script or through the REST API.

What to assert

A useful WebMCP test suite checks more than "the page loaded". Good assertions include:

• Tool presence: every tool you expect is listed by getTools(), with the right name and description.
• Schema correctness: each tool's inputSchema declares the parameters you intend, including required fields and enums.
• Happy path: executeTool() with valid input returns the expected structured result.
• Error handling: invalid input is rejected cleanly rather than throwing an unhandled error.
• State changes: write tools (for example "add to cart") actually change the page state, and read-only tools do not.

Browser support and caveats

• WebMCP is Chromium-only today. Firefox and Safari have not committed to it.
• The exact flag and API names can change between Chrome releases during the origin trial.
• Your site must enable WebMCP (through its origin-trial token or flag) for navigator.modelContext to be available.

FAQ