Skip to content

[v2] client.callTool rejects an input_required result when the tool declares outputSchema (manual mode) #3216

Open

Description

@martindafonte

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.

  1. Save the two files from Code to reproduce in separate server/ and client/ directories. Install @modelcontextprotocol/server@2.4.0 and zod@4.6.7 in server/, and @modelcontextprotocol/client@2.4.0 in client/.
  2. From the parent directory, run cd client && node client.mjs ../server/server.mjs. The script calls listTools() before callTool().
  3. Compare (a) manual mode with outputSchema, (b) automatic mode with the same tool, and (c) manual mode with an otherwise identical tool that omits outputSchema.

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

  1. added
    v2Ideas, requests and plans for v2 of the SDK which will incorporate major changes and fixes
    on Nov 20, 2026
  2. prassu017 commented on Nov 20, 2026

    @prassu017

    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 the input_required round. 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?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    v2Ideas, requests and plans for v2 of the SDK which will incorporate major changes and fixes

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions