feat: add fromJsonSchema adapter for raw JSON Schema input

Wraps a raw JSON Schema object as StandardSchemaWithJSON so it can be
passed to registerTool/registerPrompt. Useful for TypeBox users or anyone
working at the protocol level with hand-written JSON Schema.

Validator is required (not defaulted) so importing fromJsonSchema doesn't
pull in AJV. Callback args typed via the generic or as unknown.

Author: felixweinberger

.changeset/support-standard-json-schema.md

@@ -18,6 +18,16 @@ server.registerTool('greet', {
 }, async ({ name }) => ({ content: [{ type: 'text', text: `Hello, ${name}!` }] }));
 ```
 
+For raw JSON Schema (e.g. TypeBox output), use the new `fromJsonSchema` adapter:
+
+```typescript
+import { fromJsonSchema, AjvJsonSchemaValidator } from '@modelcontextprotocol/core';
+
+server.registerTool('greet', {
+  inputSchema: fromJsonSchema({ type: 'object', properties: { name: { type: 'string' } } }, new AjvJsonSchemaValidator())
+}, handler);
+```
+
 **Breaking changes:**
 - `experimental.tasks.getTaskResult()` no longer accepts a `resultSchema` parameter. Returns `GetTaskPayloadResult` (a loose `Result`); cast to the expected type at the call site.
 - Removed unused exports from `@modelcontextprotocol/core`: `SchemaInput`, `schemaToJson`, `parseSchemaAsync`, `getSchemaShape`, `getSchemaDescription`, `isOptionalSchema`, `unwrapOptionalSchema`. Use the new `standardSchemaToJsonSchema` and `validateStandardSchema` instead.

packages/core/src/index.ts

@@ -18,6 +18,7 @@ export * from './util/standardSchema.js';
 export * from './experimental/index.js';
 export * from './validators/ajvProvider.js';
 export * from './validators/cfWorkerProvider.js';
+export * from './validators/fromJsonSchema.js';
 /**
  * JSON Schema validation
  *

packages/core/src/validators/fromJsonSchema.examples.ts

@@ -0,0 +1,24 @@
+/**
+ * Type-checked examples for `fromJsonSchema.ts`.
+ *
+ * These examples are synced into JSDoc comments via the sync-snippets script.
+ *
+ * @module
+ */
+
+import { AjvJsonSchemaValidator } from './ajvProvider.js';
+import { fromJsonSchema } from './fromJsonSchema.js';
+
+/**
+ * Example: wrap a raw JSON Schema object for use with registerTool.
+ */
+function fromJsonSchema_basicUsage() {
+    //#region fromJsonSchema_basicUsage
+    const inputSchema = fromJsonSchema<{ name: string }>(
+        { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] },
+        new AjvJsonSchemaValidator()
+    );
+    // Use with server.registerTool('greet', { inputSchema }, handler)
+    //#endregion fromJsonSchema_basicUsage
+    return inputSchema;
+}

packages/core/src/validators/fromJsonSchema.ts

@@ -0,0 +1,38 @@
+import type { StandardSchemaV1, StandardSchemaWithJSON } from '../util/standardSchema.js';
+import type { JsonSchemaType, jsonSchemaValidator } from './types.js';
+
+/**
+ * Wrap a raw JSON Schema object as a {@linkcode StandardSchemaWithJSON} so it can be
+ * passed to `registerTool` / `registerPrompt`. Use this when you already have JSON
+ * Schema (e.g. from TypeBox, or hand-written) and want to register it without going
+ * through a Standard Schema library.
+ *
+ * The callback arguments will be typed `unknown` (raw JSON Schema has no TypeScript
+ * types attached). Cast at the call site, or use the generic `fromJsonSchema<MyType>(...)`.
+ *
+ * @example
+ * ```ts source="./fromJsonSchema.examples.ts#fromJsonSchema_basicUsage"
+ * const inputSchema = fromJsonSchema<{ name: string }>(
+ *     { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] },
+ *     new AjvJsonSchemaValidator()
+ * );
+ * // Use with server.registerTool('greet', { inputSchema }, handler)
+ * ```
+ */
+export function fromJsonSchema<T = unknown>(schema: JsonSchemaType, validator: jsonSchemaValidator): StandardSchemaWithJSON<T, T> {
+    const check = validator.getValidator<T>(schema);
+    return {
+        '~standard': {
+            version: 1,
+            vendor: 'mcp',
+            jsonSchema: {
+                input: () => schema as Record<string, unknown>,
+                output: () => schema as Record<string, unknown>
+            },
+            validate: (data: unknown): StandardSchemaV1.Result<T> => {
+                const result = check(data);
+                return result.valid ? { value: result.data } : { issues: [{ message: result.errorMessage }] };
+            }
+        }
+    };
+}

test/integration/test/standardSchema.test.ts

@@ -5,7 +5,14 @@
 
 import { Client } from '@modelcontextprotocol/client';
 import type { TextContent } from '@modelcontextprotocol/core';
-import { CallToolResultSchema, CompleteResultSchema, InMemoryTransport, ListToolsResultSchema } from '@modelcontextprotocol/core';
+import {
+    AjvJsonSchemaValidator,
+    CallToolResultSchema,
+    CompleteResultSchema,
+    fromJsonSchema,
+    InMemoryTransport,
+    ListToolsResultSchema
+} from '@modelcontextprotocol/core';
 import { completable, McpServer } from '@modelcontextprotocol/server';
 import { toStandardJsonSchema } from '@valibot/to-json-schema';
 import { type } from 'arktype';
@@ -411,6 +418,59 @@ describe('Standard Schema Support', () => {
         });
     });
 
+    describe('Raw JSON Schema via fromJsonSchema', () => {
+        const validator = new AjvJsonSchemaValidator();
+
+        test('should register tool with raw JSON Schema input', async () => {
+            const inputSchema = fromJsonSchema<{ name: string }>(
+                { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] },
+                validator
+            );
+
+            mcpServer.registerTool('greet', { inputSchema }, async ({ name }) => ({
+                content: [{ type: 'text', text: `Hello, ${name}!` }]
+            }));
+
+            await connectClientAndServer();
+
+            const listed = await client.request({ method: 'tools/list' }, ListToolsResultSchema);
+            expect(listed.tools[0].inputSchema).toMatchObject({
+                type: 'object',
+                properties: { name: { type: 'string' } },
+                required: ['name']
+            });
+
+            const result = await client.request(
+                { method: 'tools/call', params: { name: 'greet', arguments: { name: 'World' } } },
+                CallToolResultSchema
+            );
+            expect((result.content[0] as TextContent).text).toBe('Hello, World!');
+        });
+
+        test('should reject invalid input via AJV validation', async () => {
+            const inputSchema = fromJsonSchema(
+                { type: 'object', properties: { count: { type: 'number' } }, required: ['count'] },
+                validator
+            );
+
+            mcpServer.registerTool('double', { inputSchema }, async args => {
+                const { count } = args as { count: number };
+                return { content: [{ type: 'text', text: `${count * 2}` }] };
+            });
+
+            await connectClientAndServer();
+
+            const result = await client.request(
+                { method: 'tools/call', params: { name: 'double', arguments: { count: 'not a number' } } },
+                CallToolResultSchema
+            );
+
+            expect(result.isError).toBe(true);
+            const errorText = (result.content[0] as TextContent).text;
+            expect(errorText).toContain('Input validation error');
+        });
+    });
+
     describe('Prompt completions with Zod completable', () => {
         // Note: completable() is currently Zod-specific
         // These tests verify that Zod schemas with completable still work