Use WebMCP input schemas and structured output

Use JSON Schema for the browser-facing inputSchema. MCP-B can infer literal schemas, convert Standard JSON Schema implementations, and attach outputSchema metadata for typed MCP results. The WebMCP Community Group draft remains the authority for the browser’s tool dictionary.

Infer input from a JSON Schema literal

Install the declaration package when you want TypeScript to infer the handler input:

Install the type declarations

pnpm add -D @mcp-b/webmcp-types

Preserve literal information with as const satisfies JsonSchemaForInference: If a schema is loaded or widened at runtime, narrow the handler input yourself. MCP-B cannot infer specific fields from a broad runtime type. See the @mcp-b/webmcp-types reference for supported inference keywords.

Convert a Standard JSON Schema implementation

MCP-B hooks accept Standard JSON Schema v1 objects directly. Pass a Zod 4.2 schema as the inputSchema in usewebmcp or @mcp-b/react-webmcp. For direct registerTool() calls, convert the schema through the MCP-B adapter and validate inside the handler:

Install the adapter and Zod

pnpm add @mcp-b/webmcp-polyfill zod@^4.2

search-tool.ts

import { initializeWebMCPPolyfill } from '@mcp-b/webmcp-polyfill';
import { normalizeInputSchema } from '@mcp-b/webmcp-polyfill/schema';
import { z } from 'zod';

initializeWebMCPPolyfill();

const searchInput = z.object({
  query: z.string(),
  limit: z.number().int().min(1).max(50).optional(),
});

await document.modelContext.registerTool({
  name: 'search',
  description: 'Search indexed docs',
  inputSchema: normalizeInputSchema(searchInput).inputSchema,
  async execute(input) {
    const args = searchInput.parse(input);
    return {
      content: [{ type: 'text', text: `Searching for ${args.query}` }],
    };
  },
});

Convert refinements into JSON Schema where possible, but still parse untrusted input inside the handler. Browser execution does not run your schema library before calling the handler.

Add MCP-B output metadata

Add outputSchema when an MCP client needs typed structured data. Declare the descriptor separately so ToolDescriptorFromSchema checks the returned value:

search-summary-tool.ts

import '@mcp-b/global';
import type { JsonSchemaForInference, ToolDescriptorFromSchema } from '@mcp-b/webmcp-types';

const inputSchema = {
  type: 'object',
  properties: {
    query: { type: 'string' },
    limit: { type: 'integer', minimum: 1 },
  },
  required: ['query'],
  additionalProperties: false,
} as const satisfies JsonSchemaForInference;

const outputSchema = {
  type: 'object',
  properties: {
    total: { type: 'integer' },
    items: { type: 'array', items: { type: 'string' } },
  },
  required: ['total'],
  additionalProperties: false,
} as const satisfies JsonSchemaForInference;

const tool = {
  name: 'search_summary',
  description: 'Search with summary',
  inputSchema,
  outputSchema,
  execute: ({ query }) => ({ total: 1, items: [query] }),
} satisfies ToolDescriptorFromSchema<typeof inputSchema, typeof outputSchema>;

await document.modelContext.registerTool(tool);

outputSchema is MCP-B metadata for output inference and structured MCP responses. If your handler constructs an MCP CallToolResult directly, include schema-compatible structuredContent as well as human-readable content. The package reference lists the output inference types.

Check the agent-facing schema

After registration, inspect the emitted schema in Chrome’s WebMCP DevTools panel. Then run the Lighthouse WebMCP schema validity audit. Use Chrome’s WebMCP best practices for names, descriptions, and schema design. Use WebMCP evals to test whether agents select the tool and supply the expected arguments.

How-To Guides

Adoption

Frameworks

Connectivity

Use WebMCP input schemas and structured output

Infer input from a JSON Schema literal

Convert a Standard JSON Schema implementation

Add MCP-B output metadata

Check the agent-facing schema

​Infer input from a JSON Schema literal

​Convert a Standard JSON Schema implementation

​Add MCP-B output metadata

​Check the agent-facing schema

Infer input from a JSON Schema literal

Convert a Standard JSON Schema implementation

Add MCP-B output metadata

Check the agent-facing schema