MCP compatibility
Which MCP revision and SDK versions the ATP MCP server targets, how its transport behaves, and which capabilities it does and does not support.
This page lists exactly what the ATP MCP server speaks, so you can check your client against it before you connect.
Not deployed
Maturity
Compatibility is tested in process, against the real SDK handler and the official SDK client. No official MCP conformance suite run exists, and no third-party MCP host has been tested. The server is not deployed.
Target and versions
| Item | Value |
|---|---|
| MCP revision | 2026-07-28 |
| Server SDK | @modelcontextprotocol/server 2.4.0, exact pin |
| Node adapter | @modelcontextprotocol/node 2.1.2, exact pin |
| Client SDK | @modelcontextprotocol/client 2.4.0, tests only |
| Runtime | Node 22 or later |
| Other libraries | jose 6.2.17, viem 2.57.19, zod 4.6.7 |
These behaviours were checked against SDK 2.4.0 as pinned. A different SDK version needs the tests re-run.
Transport
The server uses Streamable HTTP in JSON response mode. Each request gets one JSON response. TLS ends at a reverse proxy in front of the server.
It is stateless. A new MCP server instance is built for every HTTP request, and no Mcp-Session-Id is issued or needed. Your client can call any replica.
The legacy handshake is rejected. A pre-2026 initialize request, for example with protocol version 2025-11-25, gets HTTP 400 and JSON-RPC error -32022, with the supported list ["2026-07-28"]. No tool runs. The SDK client in legacy mode fails to connect with "Unsupported protocol version".
{
"jsonrpc": "2.0",
"error": {
"code": -32022,
"data": { "supported": ["2026-07-28"] }
}
}The message field is omitted above. The code and data.supported value are as tested.
HTTP requirements are applied before dispatch: authentication, Origin and Host checks, method, body limit and content type. The server also serves protected resource metadata. See Authorization and Security model.
Supported and unsupported capabilities
| Capability | Status |
|---|---|
Tools (tools/list, tools/call) | Supported. Six tools, see Tools |
| Same tool list for every caller | Yes. Authorization is checked on each call, not hidden in the list |
tools.listChanged notifications | Not used. Set to false |
| Mid-call notifications | Not emitted. JSON response mode drops them |
| Input schema validation | Yes. Failures return an isError tool result with reason INVALID_INPUT, and no caller value is echoed |
| Unknown tool name | JSON-RPC protocol error. The SDK echoes the requested name |
| Structured tool results | Yes. Error results pass through unchanged and are not checked against the success output schema |
| Legacy (pre-2026) handshake | Rejected |
| Server-side sessions | Not used |
subscriptions/listen | Not tested. The SDK streams it over SSE regardless of mode |
| Conformance suite | Not run |
| Third-party hosts, IDEs, desktop agents | Not tested |
| Sinera App and Developer Portal clients | Not tested. Neither contains an MCP client |
| Real OAuth server flows (discovery, PKCE, dynamic registration) | Not tested. Tokens in tests are generated locally |
| Cloudflare Workers or other fetch-only runtimes | Not provided |
Cancellation is partly tested. A request cancelled before dispatch makes zero downstream calls, but no real client cancelled a call mid-flight.
Where the server does not use SDK helpers, it uses its own stricter code: bearer extraction (a duplicated header is a hard deny), protected-resource metadata, Host validation and the CORS allow-list. Credentials are never allowed cross-origin.
One shared server for several apps
The project keeps one independent MCP repository rather than building MCP into each application. The reasons:
- Tool schemas are tested once and stay identical for every application.
- Copying a signer, or embedding MCP in one app, would create an unreviewed authority dependency for the other.
- The server holds no signing keys. Execution authority stays with the application backend and ATP, never in MCP transport state.
Isolation between applications is logical, not physical. A server-side client registry maps each OAuth client to one application. Each application has one backend origin and one service credential. A user parameter cannot switch the application. Any application without a configured backend gets a deterministic BLOCKED_INTEGRATION answer.
This is not a claim that a shared runtime is automatically a safe tenant boundary. An operator can run one deployment per application from the same image for stronger isolation. See Integrations for the two applications.
Cannot be tested here
An official conformance run, real hosts and a real authorization server are all open items. Until they are done, treat interoperability as unproven. Start with Getting started and the overview.