feat(agent): support Standard Schema validators

[LukasParke]

Summary

Adds Standard Schema v1 support to @openrouter/agent, allowing tool input, output, event, context, shared-context, check, and custom-hook schemas to use validators such as Valibot, ArkType, and Effect Schema without requiring Zod schemas.

What changed

• added a small Standard Schema adapter around schema['~standard'].validate(value) with sync and async validation support
• preserved Zod v4 as the detected fast path using the existing z4.parse, safeParse, and z4.toJSONSchema behavior
• widened tool, agent-tool, shared-context, check-schema, and custom-hook schema types while preserving Zod inference
• normalized Standard Schema issues into the existing tool validation error shape
• added inputJsonSchema as the explicit wire-schema escape hatch for non-Zod input validators
• kept recursive ~-key sanitization for generated and caller-supplied JSON Schema
• documented Standard Schema usage and added a minor changeset

Design decisions

JSON Schema strategy

Input JSON Schema conversion now uses a three-tier chain:

1. Zod keeps the existing z4.toJSONSchema(..., { target: 'draft-7' }) fast path, including Zod versions older than 4.2.
2. Other validators may expose the StandardJSONSchemaV1 companion trait; the agent calls schema['~standard'].jsonSchema.input({ target: 'draft-07' }) and falls through if conversion throws.
3. inputJsonSchema remains the deterministic explicit override and fallback. Explicit caller intent wins over the trait.

This adds no runtime dependency: StandardJSONSchemaV1 ships in the existing @standard-schema/spec dependency. Zod 4.2+, ArkType 2.1.28+, Zod Mini, VineJS, and Sury implement the trait natively; Valibot supports it via toStandardJsonSchema() from @valibot/to-json-schema.

Only input schemas need conversion because output, event, context, shared-context, check, and custom-hook schemas remain local validators. Generated and supplied schemas retain recursive ~-key sanitization.

SDK boundary

The agent converts every client tool to the SDK's existing function-tool wire shape before making a request. The boundary remains the already-untyped parameters: Record<string, unknown> JSON Schema handoff, so this PR does not depend on the parallel @openrouter/sdk Standard Schema work. No SDK schema types are exposed or cast into the agent's public validator surface.

Context mutation

Initial context validation supports any synchronous Standard Schema validator. ctx.setContext() and ctx.setSharedContext() remain synchronous APIs, so they reject validators whose ~standard.validate returns a Promise. Zod keeps its existing per-field partial-update behavior; generic Standard Schema context updates validate the merged context object.

Test coverage

• Zod regression: validation and JSON Schema generation
• Valibot input transforms and output validation
• Valibot event and context validation
• Standard Schema issue-path mapping into existing errors
• StandardJSONSchemaV1 conversion, throw fallback, explicit override, and ~ metadata sanitization
• missing inputJsonSchema failure for non-Zod tools
• async Standard Schema validation through tool execution
• compile-time inference for Standard Schema input/output/event/context and unchanged Zod inference
• full monorepo build, typecheck, lint, and unit tests

Verification:

• pnpm build
• pnpm typecheck
• pnpm lint
• pnpm test — 918 agent tests and 168 MCP tests passed

API example

import { tool } from '@openrouter/agent';
import { toStandardJsonSchema } from '@valibot/to-json-schema';
import * as v from 'valibot';

// Trait path: toStandardJsonSchema exposes StandardJSONSchemaV1, so no
// inputJsonSchema is needed.
const search = tool({
  name: 'search',
  inputSchema: toStandardJsonSchema(v.object({ query: v.string() })),
  outputSchema: v.object({ results: v.array(v.string()) }),
  execute: async ({ query }) => ({ results: await searchWeb(query) }),
});

// Escape hatch: validation-only Standard Schema inputs supply the
// provider-facing JSON Schema explicitly (always wins when present,
// including for Zod schemas that z.toJSONSchema cannot convert).
const lookup = tool({
  name: 'lookup',
  inputSchema: v.object({ id: v.pipe(v.string(), v.transform(Number)) }),
  inputJsonSchema: {
    type: 'object',
    properties: { id: { type: 'string' } },
    required: ['id'],
  },
  execute: async ({ id }) => db.get(id), // id is the transformed number
});