output schema has unnecessary restriction type=object

[spacewander]

Describe the bug
A clear and concise description of what the bug is.

The typescript SDK requires that the outputSchema be in type: "object".

typescript-sdk/src/types.ts

Lines 1013 to 1018 in 0c1cbf0

	outputSchema: z
	.object({
	type: z.literal('object'),
	properties: z.record(z.string(), AssertObjectSchema).optional(),
	required: z.optional(z.array(z.string())),
	additionalProperties: z.optional(z.boolean())

The current constraint prevents describing the response for list and batch requests.
This is noteworthy as the specification does not strictly mandate that the outputSchema must be an object (see: https://modelcontextprotocol.io/specification/draft/server/tools#output-schema).
Consequently, the Python SDK does not enforce this schema constraint on the output.

To Reproduce
Steps to reproduce the behavior:

Let the MCP server return an outputSchema in this format:

         {
            type: "array",
            properties: {
              foo: { type: "string" }
            }
          }

Then an error is thrown:

ZodError: [
  {
    "received": "array",
    "code": "invalid_literal",
    "expected": "object",
    "path": [
      "tools",
      0,
      "outputSchema",
      "type"
    ],
    "message": "Invalid literal value, expected \"object\""
  }
]

Expected behavior
A clear and concise description of what you expected to happen.

Should accept any valid JSONSchema, at least the array one.

[RobJacobson]

Additional Details: Runtime Crash with Non-Object Output Schemas

I encountered this issue in a real-world scenario and traced it to a runtime crash. Here are the details:

Environment

• SDK Version: 1.24.3
• Zod Version: 4.x
• Use case: MCP server wrapping APIs that return optional dates (z.date().optional()) and arrays

Stack Trace

TypeError: Cannot read properties of undefined (reading '_zod')
    at isZ4Schema (zod-compat.ts:61:21)
    at safeParseAsync (zod-compat.ts:97:9)
    at McpServer.validateToolOutput (mcp.ts:201)

Root Cause Analysis

In validateToolOutput() (mcp.ts lines 200-201):

const outputObj = normalizeObjectSchema(tool.outputSchema);
const parseResult = await safeParseAsync(outputObj, result.structuredContent);

normalizeObjectSchema() returns undefined for non-object schemas (arrays, optionals, etc.). This undefined is then passed to safeParseAsync(), which calls isZ4Schema(undefined), causing the crash.

Proposed Fix (4 lines)

const outputObj = normalizeObjectSchema(tool.outputSchema);

// Cannot validate non-object schemas (arrays, optionals at root level, etc.)
if (!outputObj) {
    return;
}

const parseResult = await safeParseAsync(outputObj, result.structuredContent);

Why This Fix

1. Graceful degradation: Tools with non-object output schemas work; validation is skipped
2. No breaking changes: Existing tools with object schemas continue to be validated
3. Minimal change: 4 lines, no architectural changes
4. Aligns with spec: As you noted, the MCP specification doesn't mandate object-only outputSchema

Workaround (for others hitting this)

Until this is fixed, you can work around it by ensuring your outputSchema is always an object:

// Instead of:
outputSchema: z.date().optional()

// Use:
outputSchema: z.object({ value: z.string().datetime().optional() })

---

Happy to submit a PR for this fix if it would be helpful!

[felixweinberger]

Confirmed still an issue on v1.25.1. The spec doesn't require outputSchema to be type: object.

The quick fix (skip validation for non-object schemas) would work but leaves those schemas unvalidated. The proper fix is to use the existing jsonSchemaValidator (AJV) infrastructure for output validation instead of Zod, which would support all JSON Schema types.

Adding to v2 backlog.

[domdomegg]

Related spec issue: modelcontextprotocol/modelcontextprotocol#1906

[dastrobu]

is this related to modelcontextprotocol/modelcontextprotocol#834?

[mcp-claude]

bug confirmed on both main and v1.x. outputSchema is unnecessarily restricted to type: "object" even though the MCP spec only describes it as "Optional JSON Schema" with no root-type requirement (contrast inputSchema, which explicitly says MUST be a valid JSON Schema object).

two enforcement points cause this:

• ToolSchema (packages/core/src/types/schemas.ts:1328) uses type: z.literal('object') — rejects any server message where outputSchema.type is "array" or anything else
• standardSchemaToJsonSchema() (packages/core/src/util/standardSchema.ts:153) throws for any non-object Zod schema passed as outputSchema, blocking tool registration with e.g. z.array(...)

repro script + output

// repro.ts — run with: npx tsx repro.ts
import { ToolSchema } from './packages/core/src/types/schemas.js';
import { standardSchemaToJsonSchema } from './packages/core/src/util/standardSchema.js';
import * as z from 'zod/v4';

// Test 1: parse a tool message with array outputSchema (client-side / protocol layer)
const result = ToolSchema.safeParse({
    name: 'list-items',
    inputSchema: { type: 'object' },
    outputSchema: { type: 'array', items: { type: 'string' } }
});
console.log(result.success ? 'PASS' : 'FAIL', JSON.stringify(result.error?.issues));

// Test 2: register a tool with z.array() outputSchema (server-side)
try {
    standardSchemaToJsonSchema(z.array(z.string()) as any, 'output');
    console.log('PASS');
} catch (e: any) {
    console.log('FAIL', e.message);
}

=== Test 1: ToolSchema validation with type: "array" outputSchema ===
FAIL: ToolSchema rejected array outputSchema (bug reproduced)
Error: [{"code":"invalid_value","values":["object"],"path":["outputSchema","type"],"message":"Invalid input: expected \"object\""}]

=== Test 2: standardSchemaToJsonSchema with z.array() ===
FAIL: standardSchemaToJsonSchema threw for array schema (bug reproduced)
Error: MCP tool and prompt schemas must describe objects (got type: "array"). Wrap your schema in z.object({...}) or equivalent.

suggested fix

// packages/core/src/types/schemas.ts
-    * Must have `type: 'object'` at the root level per MCP spec.
+    * Unlike `inputSchema`, the MCP spec does not restrict `outputSchema` to `type: "object"`.
     */
     outputSchema: z
         .object({
-            type: z.literal('object'),
+            type: z.string().optional(),
             properties: z.record(z.string(), JSONValueSchema).optional(),
             required: z.array(z.string()).optional()
         })

// packages/core/src/util/standardSchema.ts
 export function standardSchemaToJsonSchema(schema: StandardJSONSchemaV1, io: 'input' | 'output' = 'input'): Record<string, unknown> {
     const result = schema['~standard'].jsonSchema[io]({ target: 'draft-2020-12' });
-    if (result.type !== undefined && result.type !== 'object') {
-        throw new Error(
-            `MCP tool and prompt schemas must describe objects (got type: ${JSON.stringify(result.type)}). ` +
-                `Wrap your schema in z.object({...}) or equivalent.`
-        );
+    if (io === 'input') {
+        if (result.type !== undefined && result.type !== 'object') {
+            throw new Error(
+                `MCP tool and prompt schemas must describe objects (got type: ${JSON.stringify(result.type)}). ` +
+                    `Wrap your schema in z.object({...}) or equivalent.`
+            );
+        }
+        return { type: 'object', ...result };
     }
-    return { type: 'object', ...result };
+    return result;
 }

test to verify: ToolSchema.safeParse accepts outputSchema: { type: 'array', items: { type: 'string' } }, and standardSchemaToJsonSchema(z.array(z.string()), 'output') returns { type: 'array', ... } without throwing.