· reAPI Team
MCP tool calls: why they fail after switching APIs
Trace MCP tool calls across discovery, model support, execution and returned results. Diagnose API migration failures before retrying or submitting paid tasks.

The MCP server says Connected. The assistant still answers in ordinary text, or says it checked a task without showing any result. If this began after changing model APIs, inspect what crossed that new connection before changing the prompt again.
A connected tool server and a model able to request tools are separate parts of the application. MCP defines tool discovery and invocation. The host must then expose the appropriate tools to the model, execute any permitted call it requests, and send the result back.[1][2] A success at the first step does not establish the last one.
Find the tool in the list the client received
Start with one tool. Read the actual tools/list result received by the affected client, including further pages where applicable. Keep its name, description and input schema. A connection badge does not show whether this particular tool was discovered.
If it is absent, check the selected server, supported transport and authentication in the process running the client. The current MCP specification allows available tools to vary with the authorization supplied.[1] Seeing one tool is therefore not proof that the same caller can see every tool offered by that server.
For a reAPI connection, the documented server uses remote Streamable HTTP with a custom Bearer authorization header. A client offering only OAuth sign-in without custom headers cannot connect through that configuration.[3] Repeating a model instruction cannot supply a transport or credential mechanism the client lacks.
Keep the model-provider credential and tool-server credential distinct in the investigation. They can belong to different connections. Replacing a model API key does not repair a missing credential on the MCP connection, and replacing the MCP credential does not add tools to an outgoing model request. Record safe configuration identifiers rather than the secrets.
Compare the discovered schema with what the model sees
Use this fictional read-only tool as an example. It looks up an existing task by ID. The fragment is an illustrative discovery entry, not a complete protocol response or a tool we deployed:
{
"name": "inspect_task_example",
"description": "Look up the status of an existing task.",
"inputSchema": {
"type": "object",
"properties": {
"task_id": { "type": "string" }
},
"required": ["task_id"]
}
}Now inspect the serialized request sent to the model. Its tool format can differ from MCP's inputSchema format, but the name, property and required-field meaning must survive the conversion. If the host sends the tool name without the task_id property or required list, the model has received a different contract.
That is a concrete place to repair the adapter. A longer prompt telling the model to “use the tool correctly” does not restore the missing schema. Compare the two objects before adding more instructions or changing providers again.
In this example, compare task_id in three places: the discovered property, the model-facing property and the arguments the host later dispatches. It must still name the same required string value. A converter that renames it to id in one place but leaves task_id in another has introduced a mismatch. Use the model API's supported wrapper for the definition while preserving that field's name, type and required status.
Also check for stale definitions. A tool renamed on the server can remain under its old name in a cached client list. Save the definition used in the failed request so the comparison concerns what the model actually received, not the latest schema visible in a separate documentation page.
Did the model ask for a tool, or just describe using one?
Read the model response structure. Ordinary prose saying “I will check the task” is not a structured tool call. A refusal, plain answer, malformed call and valid call need different next steps, even if all arrived through successful HTTP responses.
If the request included the right schema but no call was returned, inspect model support, tool-choice settings and the route used. Automatic tool selection can produce an ordinary answer; a setting that disables tools can prevent selection. Stricter tool-choice values also vary in support by model.[2] Do not treat every absence as malformed arguments.
Routing is relevant when an intermediary chooses a provider. OpenRouter documents require_parameters for restricting routes to providers supporting all requested parameters. Its default parameter preferences, including preferences around tools, are not the same as strict filtering.[4] Check fallback models and the route that served the request. Do not copy that provider-specific option into a different API and assume equivalent behavior.
If a structured call did arrive, stop debugging selection and follow that call. The model has requested an action; the application still has to run it. OpenRouter's tool-calling tutorial explicitly assigns execution to the caller, not to the model.[2]
Follow the same call ID through execution and return
Here is the next part of the fictional example, using the Chat Completions message shape. The IDs and result are invented. These are message fragments for inspection, not a script that sends a request:
[
{
"role": "assistant",
"content": null,
"tool_calls": [
{
"id": "call_example_1",
"type": "function",
"function": {
"name": "inspect_task_example",
"arguments": "{\"task_id\":\"example_task_7\"}"
}
}
]
},
{
"role": "tool",
"tool_call_id": "call_example_1",
"content": "{\"task_id\":\"example_task_7\",\"status\":\"processing\"}"
}
]Between those two messages, the host must dispatch the permitted call to the tool and receive its result. A model response containing call_example_1 does not prove that dispatch occurred. Look for the corresponding execution record and server result.
If execution is waiting for approval, preserve that state. If the user declined it, the declined operation is the outcome; another tool or retry is not permission to bypass the decision. If approval was granted and dispatch never happened, investigate the host's execution logic.
Check the dispatched tool name and arguments against the requested call as well. In this example, the lookup must receive example_task_7; a host that accidentally reuses the previous task ID has executed a different lookup, even if the server returns a valid result. Save the mapping from model call ID to tool invocation and returned content. That makes a wrong-task result visible before the model incorporates it into a confident answer. Correct this local mapping without changing the source tool's schema or broadening its access.
For streamed calls, wait for the complete arguments. OpenRouter describes collecting deltas by call index and parsing after the argument string is complete.[2] An early fragment that stops midway through task_id is not valid JSON yet. Keep that separate from a complete argument string that remains invalid.
The second message above carries the same call ID as the first. In the documented Chat Completions loop, the assistant tool-call turn is followed by a result message for each requested call.[2] If several calls were returned, preserve each identity and result. Sending one result under every ID can make the conversation look complete while attaching the wrong data to the requested actions.
Suppose the tool really returned processing, but the next model request omitted the tool message. Execution succeeded; the model never received the result. Or suppose the host replaced the result with an empty string during conversion. Changing the model would leave that same missing information in the conversation.
Compare the actual server result with the outgoing continuation. Keep relevant content and errors, not just a success flag in a client log. The model's final wording should be assessed against the result it was given; its claim that it checked the task is not a substitute for that record.
Keep tool errors visible
MCP distinguishes protocol problems from tool execution failures. An unknown tool or malformed protocol request can produce a JSON-RPC error. A tool execution failure can instead be returned with isError: true.[1] Preserve that distinction and the associated message when converting the result for the model.
For the example lookup, an error that the task cannot be accessed must not become an empty successful status. If the model receives only an empty string, it has lost the information needed to explain the failure or choose an appropriate next action. Inspect the conversion before blaming the final answer.
A useful local check is to feed saved or synthetic messages through the adapter: one ordinary result, one execution error and two calls with different IDs. Verify that content, error meaning and identity survive. This tests the adapter's handling of those fixtures; it does not establish that a remote model will select the tool correctly. A live model evaluation can still incur inference charges even when the chosen tool is read-only.
Make the two synthetic results visibly different, then return them in the opposite order from the requests. The host should associate them by their call identities, not by arrival position. Identical test results can conceal this mistake because swapping them leaves no visible difference in the next model input.
Finish the connection check before submitting a generation
For reAPI, start with the non-submitting tools relevant to the problem. The MCP reference lists model discovery, schema retrieval, estimation, task status and balance operations as not charging credits. submit_task is separate: a call that creates a task is billed for that task.[3]
The documented server is stateless and accepts one JSON-RPC message per HTTP request, not batch arrays. Media inputs require public HTTP or HTTPS URLs rather than base64 or data URIs.[3] Check those actual interface requirements when the execution step fails; do not use repeated generation submissions as a connection test.
Preserve a returned task ID and query that existing task. reAPI documents task submission as non-idempotent: repeating a creation request can create another billable task.[3] A lost submission response needs an acceptance check, not an assumption that nothing happened.
For the fictional lookup, the migration comparison is complete when you can show where the messages first differ: discovery, the model-facing definition, the structured call, execution or the returned result. Fix that specific difference, then repeat the same harmless check. Keep the server, model, client version and recorded call together so the next person can see what was verified without relying on a Connected badge.
References
- Model Context Protocol, Tools specification, revision 2026-07-28. Read November 16, 2026. Protocol versions and server implementations can differ.
- OpenRouter, “Tool Calling Across Any Model: Write the Loop Once, Swap the Model String,” official tutorial, updated September 24, 2026. Read November 16, 2026.
- reAPI, MCP Server documentation. Reviewed November 16, 2026. No live generation or client compatibility test was performed for this guide.
- OpenRouter, “Provider Routing,” official documentation, “Requiring Providers to Support All Parameters” and “Default parameter preferences.” Read November 16, 2026.