Repository navigation
Description
What happened?
With inputRequired: { autoFulfill: false } and callTool(..., { allowInputRequired: true }), a tool that declares an outputSchema fails on the first round. The server sends resultType: "input_required" with a form elicitation request. The client throws before the caller can read inputRequests and respond.
Environment: Node.js v26.13.1 and v22.23.2, stdio, protocol pinned to and negotiated as 2026-07-28. Both runs used client, server and core 2.4.0, with Zod 4.6.7.
- Save the two files from Code to reproduce in separate
server/andclient/directories. Install@modelcontextprotocol/server@2.4.0andzod@4.6.7inserver/, and@modelcontextprotocol/client@2.4.0inclient/. - From the parent directory, run
cd client && node client.mjs ../server/server.mjs. The script callslistTools()beforecallTool(). - Compare (a) manual mode with
outputSchema, (b) automatic mode with the same tool, and (c) manual mode with an otherwise identical tool that omitsoutputSchema.
First tools/call response in case (a), captured over stdio:
{"jsonrpc":"2.0","id":1,"result":{"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"repro-server","version":"0"}},"resultType":"input_required","inputRequests":{"confirmation":{"method":"elicitation/create","params":{"message":"Delete item 7?","requestedSchema":{"type":"object","properties":{}},"mode":"form"}}}}}Result lines from the run:
RESULT (a): threw ProtocolError code=-32600: Tool delete_item has an output schema but did not return structured content
RESULT (b): returned {"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"repro-server","version":"0"}},"content":[{"type":"text","text":"{\"id\":7}"}],"structuredContent":{"id":7}}
RESULT (c): returned {"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"repro-server","version":"0"}},"content":[{"type":"text","text":"{\"id\":7}"}],"structuredContent":{"id":7}}
In (c), the first call returns input_required. The follow-up call with inputResponses completes. In (b), the client handles the confirmation internally and returns the completed result with structuredContent.
The output check in Client.callTool checks for missing structuredContent without first checking for input_required. This source was inspected on main. The reproduction above ran on 2.4.0.
Coverage includes stdio and an accepted form elicitation in the working controls. HTTP, manual decline and cancellation, other SDK client versions, and a patched client were outside the reproduction.
AI assistance was used to prepare the reproduction, draft this report, and cross-check the SDK source. The output above was captured from an executed run.
What did you expect?
callTool should return the first input_required response to the manual caller, as it does in case (c). The caller can then answer the elicitation and retry. Output-schema validation should apply to the completed tool output. The 2026-07-28 tools specification describes this intermediate response. Input Required Tool Results
A possible fix would be to return the intermediate result before the output check, while retaining schema validation for the completed result. This is an untested proposal.
Code to reproduce
// server/server.mjs
// Minimal server: two identical tools, one with an outputSchema and one without.
// First tools/call returns input_required (one form elicitation); the retry with
// inputResponses returns the complete result.
import { McpServer, inputRequired, inputResponse } from '@modelcontextprotocol/server';
import { serveStdio } from '@modelcontextprotocol/server/stdio';
import * as z from 'zod';
const handler = async ({ id }, ctx) => {
const answer = inputResponse(ctx.mcpReq.inputResponses, 'confirmation');
if (answer.kind === 'missing') {
return inputRequired({
inputRequests: {
confirmation: inputRequired.elicit({
message: `Delete item ${id}?`,
requestedSchema: { type: 'object', properties: {} },
}),
},
});
}
if (answer.kind !== 'elicit' || answer.action !== 'accept') {
return { content: [{ type: 'text', text: 'not deleted' }], isError: true };
}
return { content: [{ type: 'text', text: JSON.stringify({ id }) }], structuredContent: { id } };
};
const createServer = () => {
const server = new McpServer({ name: 'repro-server', version: '0' });
const inputSchema = z.object({ id: z.number().int() });
server.registerTool(
'delete_item',
{ description: 'Deletes an item (declares outputSchema).', inputSchema, outputSchema: z.object({ id: z.number().int() }) },
handler
);
server.registerTool(
'delete_item_no_schema',
{ description: 'Deletes an item (no outputSchema).', inputSchema },
handler
);
return server;
};
await serveStdio(createServer);
// client/client.mjs
// Usage: node client.mjs <path to server.mjs>
import { readFileSync } from 'node:fs';
import { Client } from '@modelcontextprotocol/client';
import { StdioClientTransport } from '@modelcontextprotocol/client/stdio';
const pkg = JSON.parse(readFileSync(new URL('./node_modules/@modelcontextprotocol/client/package.json', import.meta.url)));
console.log(`@modelcontextprotocol/client ${pkg.version}, node ${process.version}`);
// Prints every JSON-RPC message that crosses the transport.
const tap = (transport, label) => {
const send = transport.send.bind(transport);
transport.send = (message, options) => {
console.log(` [${label}] --> ${JSON.stringify(message)}`);
return send(message, options);
};
let onmessage;
Object.defineProperty(transport, 'onmessage', {
get: () => onmessage,
set: fn => {
onmessage = (message, extra) => {
console.log(` [${label}] <-- ${JSON.stringify(message)}`);
return fn(message, extra);
};
},
});
return transport;
};
const connect = async (label, options = {}) => {
const client = new Client(
{ name: 'repro-client', version: '0' },
{ capabilities: { elicitation: { form: {} } }, versionNegotiation: { mode: { pin: '2026-07-28' } }, ...options }
);
client.setRequestHandler('elicitation/create', async () => ({ action: 'accept', content: {} }));
await client.connect(tap(new StdioClientTransport({ command: process.execPath, args: [process.argv[2]] }), label));
const { tools } = await client.listTools(); // caches the outputSchema validators
console.log(` negotiated protocol: ${client.getNegotiatedProtocolVersion()}`);
console.log(` tools: ${JSON.stringify(tools.map(t => ({ name: t.name, outputSchema: t.outputSchema ?? null })))}`);
return client;
};
const run = async (title, fn) => {
console.log(`\n=== ${title}`);
try {
const result = await fn();
console.log(`RESULT ${title.slice(0, 3)}: returned ${JSON.stringify(result)}`);
} catch (error) {
console.log(`RESULT ${title.slice(0, 3)}: threw ${error.constructor.name} code=${error.code}: ${error.message}`);
}
};
// Manual mode: take the input_required result, answer it, retry.
const manual = async name => {
const client = await connect('manual', { inputRequired: { autoFulfill: false } });
try {
const first = await client.callTool({ name, arguments: { id: 7 } }, { allowInputRequired: true });
console.log(` first round returned: ${JSON.stringify(first)}`);
return await client.callTool(
{ name, arguments: { id: 7 }, inputResponses: { confirmation: { action: 'accept', content: {} } }, requestState: first.requestState },
{ allowInputRequired: true }
);
} finally {
await client.close();
}
};
await run('(a) manual mode, tool WITH outputSchema', () => manual('delete_item'));
await run('(b) automatic mode (default), tool WITH outputSchema', async () => {
const client = await connect('auto');
try {
return await client.callTool({ name: 'delete_item', arguments: { id: 7 } });
} finally {
await client.close();
}
});
await run('(c) manual mode, same tool WITHOUT outputSchema (control)', () => manual('delete_item_no_schema'));SDK version
@modelcontextprotocol/client 2.4.0, @modelcontextprotocol/server 2.4.0, @modelcontextprotocol/core 2.4.0
Area
Client
Activity
prassu017 commentedon Nov 20, 2026
Reproduced on main (5ee54ee): with a tool that declares an
outputSchema,callTool(..., { allowInputRequired: true })throws "has an output schema but did not return structured content" on theinput_requiredround. The output check ran before the input-required check. #3217 skips validation for that intermediate result and keeps it for the completed retry, with a test. Could this be assigned to me?