Protocol Support
This page is the contract a server developer builds against: what the host speaks, what it claims of itself on each protocol era, and what it leaves out on purpose. Where the host does not advertise a capability, that is a decision, and the reason is given next to it.
Specification revisions
Section titled “Specification revisions”NimbleBrain uses the official TypeScript SDK v2 (@modelcontextprotocol/client and @modelcontextprotocol/server 2.x) as a client and for both sides of its MCP endpoint. The MCP App Bridge reaches the endpoint on 2026-07-28.
The revisions fall into two eras. 2026-07-28 has no initialize handshake: a client probes with server/discover, and every request carries its protocol version, client info and client capabilities in its own _meta envelope. Every earlier revision is negotiated once, by initialize, under the specification’s lifecycle rules.
| Revision | Supported |
|---|---|
2026-07-28 |
Yes. As a client, the host probes for it first. As a server, it is the only revision served. |
2025-11-25 |
As a client. The revision the host offers in initialize. |
2025-06-18 |
As a client |
2025-03-26 |
As a client |
2024-11-05 |
As a client |
2024-10-07 |
As a client |
As a client, the host negotiates each connection on its own. It sends server/discover first. A server that answers it with a 2026-07-28 result is spoken to on that revision. Any other answer, such as a method-not-found error, leads to the 2025 initialize handshake, which offers 2025-11-25 and accepts any older revision above that the server answers with. A probe that meets an HTTP 5xx is retried once on the 2025 era, because some 2025 servers answer every method they do not know with a 500. Nothing is pinned, so a server that moves to 2026-07-28 is spoken to on it at its next connection. As a server, the host speaks 2026-07-28 only; see As a server to external clients.
MCP Apps (the ui:// extension) is implemented from @modelcontextprotocol/ext-apps. See the MCP App Bridge for the exact messages the host serves.
As a client to your server
Section titled “As a client to your server”Transports
Section titled “Transports”| Transport | Supported | Notes |
|---|---|---|
| Streamable HTTP | Yes | The default. Declare streamable-http in the server’s catalog entry. |
| HTTP+SSE | Yes | Only for servers that support nothing newer. Declare sse. |
| stdio | No | The runtime connects to servers over the network. It never downloads or runs a server’s code. |
Authorization follows the specification’s authorization flow: dynamic client registration, a pre-registered OAuth client, or a credential the platform supplies. The operator chooses one per server in the connectors catalog.
Client capabilities the host advertises
Section titled “Client capabilities the host advertises”A claim travels differently on each era. On a 2025-era connection the host sends it once, in initialize’s capabilities. On a 2026-07-28 connection it sends it on every request, server/discover included, under _meta["io.modelcontextprotocol/clientCapabilities"]. The host claims a capability only on the era where it serves it.
On a 2025-era connection, a workspace connector’s initialize carries exactly these capabilities:
{ "capabilities": { "extensions": { "io.modelcontextprotocol/ui": { "mimeTypes": ["text/html;profile=mcp-app"] }, "io.modelcontextprotocol/skills": {}, "ai.nimblebrain/facets": {}, "ai.nimblebrain/lifecycle": {}, "ai.nimblebrain/resource-arguments": { "maxChars": 49600, "maxSize": 10485760, "maxUris": 32 }, "ai.nimblebrain/host-resources": { "read": { "enabled": true, "range": false, "maxSize": 10485760 }, "list": { "enabled": true }, "write": { "enabled": false }, "schemes": ["files"] } } }}On a 2026-07-28 connection, every request’s envelope carries the same MCP Apps, Skills, facets, lifecycle, and resource-arguments claims, and no ai.nimblebrain/host-resources:
{ "_meta": { "io.modelcontextprotocol/clientCapabilities": { "extensions": { "io.modelcontextprotocol/ui": { "mimeTypes": ["text/html;profile=mcp-app"] }, "io.modelcontextprotocol/skills": {}, "ai.nimblebrain/facets": {}, "ai.nimblebrain/lifecycle": {}, "ai.nimblebrain/resource-arguments": { "maxChars": 49600, "maxSize": 10485760, "maxUris": 32 } } } }}io.modelcontextprotocol/ui: MCP Apps, claimed on both eras with the one UI resource MIME type the host renders, text/html;profile=mcp-app. A server that checks the claim (ext-apps’ getUiCapability) before offering UI sees it on either era.
io.modelcontextprotocol/tasks: the host runs long-running tools as tasks through the 2026-07-28 tasks extension, and only through it. When a server advertises the extension, each tools/call names it in that request’s own client capabilities, and the server decides per call whether to answer outright or with a task. The host polls tasks/get and reads the result it inlines. When the run that made a call is cancelled, the host sends tasks/cancel. A task that asks for input (input_required) is cancelled and reported as an error, since the host has no one to ask. A task-augmented call is never retried after a transport failure, because the task’s state lives on the server and a retry would start the work twice. The extension is claimed on those requests only, never on the connection, so it appears in neither block above.
On a 2025-era connection the host never attaches a task. A tool that declares execution.taskSupport as optional is called as an ordinary blocking tools/call, so a call that outlasts a timeout in the path fails as any long request does. A tool that declares it as required cannot be called: the host refuses the call before sending it, with an error saying the tool needs the 2025-11-25 tasks utility. To run a long tool from NimbleBrain, serve it over 2026-07-28 with the tasks extension.
io.modelcontextprotocol/skills: the MCP Skills Extension, claimed on both eras because skill discovery runs on both. On a 2026-07-28 connection the host asks for skills/list only when the server advertises the extension. On a 2025-era connection it asks whether or not the server declared it, because some SDKs leave capabilities.extensions out of the legacy initialize result; a -32601 (method not found) answer means the server publishes no skills.
ai.nimblebrain/* extensions: the vendor capabilities described in the Extensions registry. ai.nimblebrain/facets is claimed on both eras, because the host lists and reads facets over whichever era connected. ai.nimblebrain/lifecycle is claimed on both eras, because the host reads a server’s handlers and calls them over whichever era connected. ai.nimblebrain/resource-arguments is claimed on both eras, because the host delivers its contents in the tools/call request. ai.nimblebrain/host-resources is claimed on the 2025 era only, because it is served through server-to-client requests, which 2026-07-28 removed. A personal connector’s connection claims neither, since it belongs to no workspace. Read this block before calling an extension method.
Client capabilities the host does not advertise
Section titled “Client capabilities the host does not advertise”| Capability | Why not |
|---|---|
sampling |
The specification is deprecating it. A server that needs a model should call one itself. |
roots |
The specification is deprecating it. A server reaches workspace files through host-resources instead. |
tasks (2025-11-25) |
Task augmentation is the 2026-07-28 tasks extension only. On a 2025-era connection the host calls every tool inline and refuses one whose execution.taskSupport is required; see io.modelcontextprotocol/tasks. |
elicitation |
The host claims no elicitation on its own calls. An agent here often runs with nobody present, such as a scheduled task or a webhook-triggered run, and even when someone is present they are at the far end of an event stream, not waiting behind the tool call. A tool that needs input should return that as its result, and the agent will ask. A call an outside client makes through /mcp/<workspaceId> is different: the connector sees that client’s own capabilities, and its elicitation, form or URL mode, is relayed to that client to answer. |
What the host reads from your server
Section titled “What the host reads from your server”| Server feature | How the host uses it |
|---|---|
tools |
Offered to the agent, filtered by workspace, feature flags, and the caller’s role. annotations (readOnlyHint, destructiveHint, and the rest) and outputSchema are forwarded as declared. Annotations are the server’s claims about itself, so the host never uses them to relax a check. |
inputSchema on a tool |
Checked against every agent call before it reaches your server. A schema that declares properties is read as the complete list of argument names unless something in it admits other keys: additionalProperties or unevaluatedProperties (true or a schema), patternProperties, a $ref, or a conditional keyword (if / then / else, dependentSchemas, dependencies). Otherwise an agent call naming any other argument is refused, and the agent is told the arguments you declared. Arguments declared in allOf, anyOf, or oneOf branches count. Calls from an app’s view and from external MCP clients are not subject to this check. To accept arbitrary keys, say so with additionalProperties. |
_meta.ui.resourceUri on a tool |
Mounts the tool’s MCP Apps view inline with its result. |
_meta.ui.visibility on a tool |
Absent means ["model", "app"]. A tool without "model" is left out of every tool list an agent sees, in chat and at the MCP endpoint, and an agent’s call that names it is refused. A tool without "app" is refused when an app’s view calls it, and a view can only call tools on its own server. |
resources |
Read when the host needs them: ui:// views when they mount, and the server’s notification outbox. The host reads on its own schedule. The agent reads any other resource with nb__read_resource: the server’s resource templates (resources/templates/list, up to 10, outside the host’s own schemes) are listed under the server in the system prompt, and a read returns up to the 50,000-character tool-result limit (12,000 for skill://), with a note when it is cut. If the server advertises resources.subscribe, the host subscribes to the outbox and treats notifications/resources/updated as a hint to read it sooner, not as a replacement for reading. On 2025 it subscribes with resources/subscribe; on 2026-07-28 it names the URI in a subscriptions/listen stream instead. |
listChanged on tools or resources |
On 2025 the host reacts to the list-changed notifications the server sends. On 2026-07-28, where a server sends nothing unsolicited, the host opens a subscriptions/listen stream for them, and for the resource updates above, and reopens it when it drops. |
instructions |
From the initialize result on 2025, from the server/discover result on 2026-07-28. Composed into the agent’s prompt for the workspace. |
As an MCP Apps host
Section titled “As an MCP Apps host”The host implements the MCP Apps specification: ui/initialize, tool input and result delivery, ui/message, ui/open-link, ui/update-model-context, ui/download-file, ui/request-display-mode, size changes, and tools/call and resources/read proxied to the app’s own server. The MCP App Bridge reference lists every message and its exact behavior, including the three ai.nimblebrain/* bridge extensions.
As a server to external clients
Section titled “As a server to external clients”Each workspace is its own MCP server at /mcp/<workspaceId>, over Streamable HTTP with OAuth 2.0 protected-resource discovery. It speaks 2026-07-28 only: each request carrying the _meta envelope is answered on its own, with no session, and server/discover answers the capabilities. A request without the envelope, a 2025-era initialize included, is refused with HTTP 400 and -32022, whose error.data.supported is ["2026-07-28"]. A resources/read whose URI resolves nowhere answers -32602. It advertises:
| Capability | Notes |
|---|---|
tools |
The workspace’s tools and the caller’s identity tools, with the same filtering the agent gets |
resources |
Resources from the workspace’s servers |
prompts |
The workspace’s connectors’ prompts, each named <source>__<prompt> as its tools are, in one page. prompts/get reaches the connector that serves the prompt; a name no connector answers to is refused with -32602. prompts/get carries the caller’s side of the protocol as a tool call does (below). |
completions |
Asked of the connector that owns the reference: the one a <source>__<prompt> name names, or the one that lists the resource template. A connector that declares no completions capability has nothing to suggest. |
io.modelcontextprotocol/skills |
In server/discover’s capabilities.extensions. skills/list and skills/get answer the skills the workspace’s connectors serve, and each skill file reads through resources/read. A skill URI that two connectors serve is left out. |
io.modelcontextprotocol/tasks |
In server/discover’s capabilities.extensions. Long-running tools stay long-running through the endpoint: a tools/call whose request names the extension in its client capabilities is answered with a task when the tool can run as one, tasks/get inlines the result once the task ends, and tasks/cancel acknowledges. A call that does not opt in runs to completion inside the request. The 2025-11-25 tasks utility is not served. |
It advertises neither listChanged nor resources.subscribe. The endpoint does not serve the optional GET server-to-client stream, so progress arrives on the POST that started the call.
A tool call to a connector that does not advertise the tasks extension, and every prompts/get, carries the caller’s side of the protocol through to that connector. (A connector that advertises the extension runs each call as a task, polled to completion, and cannot ask the caller for input.)
- The connector sees the caller’s client capabilities, so it asks only for what the caller declared.
- A connector’s
input_requiredanswer (elicitation, sampling, or a roots request) reaches the caller, and the caller’s retry withinputResponsesreaches the connector. The client shows an elicitation as the host’s, so each elicitation’smessage, form or URL mode, starts with the connector’s name, which tells the client which connector asked (for example,Mail: Confirm sending 40 messages). The connector cannot choose or remove the name, but the text after it is its own. Everything else, a URL-modeurlincluded, is relayed as the connector sent it, and the host never opens a URL itself. - The
requestStatethe caller holds is the endpoint’s own, signed and bound to the caller, the workspace, the tool or prompt, and the request’s arguments; the connector’s state travels inside it. A state echoed by another caller, at another workspace’s URL, on another tool or prompt, or with other arguments is refused with-32602, as is one older than ten minutes or minted before the runtime restarted. - A URL request carries a person to the connector’s page; it does not confirm anything. A connector that needs a person’s confirmation checks it on that page, behind its own sign-in, and treats the client’s
acceptonly as consent to open the link. - A connector’s
-32021(a client capability the request did not declare) reaches the caller as that error. - A connector’s progress reaches the caller under the caller’s own
progressToken. The MCP endpoint reference covers authentication, the protocol revision, and the audience rule.
Related
Section titled “Related”- NimbleBrain and MCP: the three roles
- Extensions: every extension and the rules they follow
- Host resources: the
extensionscapability in detail - Connector configuration: transport and auth fields