An MCP tools/call result comes back. Which content types could it contain?

MCQ·Easy·4.0 · 0·~1 min·Asked atBraintrust Scale Ai Vernacular Ai·Relevant atAnthropic

Attempt it

When an MCP server responds to a tools/call request, the result object has two fields: `content` (an array of typed blocks) and an optional `isError` boolean. The spec defines five valid **content types**. `text` is a plain string payload. Descriptions, status messages, and query results use it, and it is the most common by far. `image` is a base64-encoded image with a mimeType field (e.g., image/png). A tool that generates a chart or takes a screenshot uses this. Multimodal models read the image as visual input on the next turn. `audio` is a base64-encoded audio clip with a mimeType field (e.g., audio/wav), added in the 2025 spec to support voice-capable agents. `resource_link` is a reference by URI to a resource the host can fetch separately via resources/read. The host retrieves the data only when the model needs it. `resource` embeds a resource's contents directly in the result. A single tool result can mix types. A weather tool might return a text summary alongside an image of the radar map. The host decides which blocks to forward to the model in the next inference request. The type set is closed. Servers cannot invent custom types.

A tools/call result in MCP returns `{content: ContentBlock[], isError?: boolean}`. The spec defines five **content types**, and the set is a closed enumeration. `text` is `{type: "text", text: "..."}`. A UTF-8 string for descriptions, query results, code snippets and status messages. The most common type in production. `image` is `{type: "image", data: "<base64>", mimeType: "image/png"}`. The host forwards this to multimodal models as native image input. Chart and screenshot tools use this. `audio` is `{type: "audio", data: "<base64>", mimeType: "audio/wav"}`, added in the 2025 spec for voice-capable agents. On text-only models, the host can transcribe or drop the block. `resource_link` is `{type: "resource_link", uri: "...", name: "..."}`. A reference by URI to a resource the host can fetch via resources/read. Instead of inlining large or contingent data, the server returns a pointer; the host fetches only what the model reads. A search tool returning twenty matches as twenty links saves an order of magnitude in tokens compared to inlining all twenty documents. `resource` is `{type: "resource", resource: {uri: "...", mimeType: "...", text?: "..."}}`. An embedded resource that carries its contents inline as `text` or a base64 `blob`. Mixed arrays are the norm, not an edge case. A browser navigation tool returns a text description of the page alongside a screenshot image. The host forwards each block to the model in whatever format the provider expects. The closed type set means hosts only need to handle five shapes. A new content type needs a spec revision; servers cannot invent one.

TL;DR

MCP defines five tools/call content types: text, image and audio (base64 plus mimeType; audio added 2025), resource_link (URI pointer) and resource (embedded contents). Mixed arrays are allowed; the set is closed.

Memory aid

Easy to grasp

Think of a tool result as a small package that can hold different kinds of items. MCP gives tools five kinds of boxes to put things in. A text box holds written messages. An image box holds a picture encoded as data. An audio box holds a sound clip. A resource link box holds a card that says 'the actual thing lives at this address, go fetch it when you need it.' A resource box holds a whole file or document packed inside. A single package can contain several boxes at once, like a written summary next to a chart picture, and the host figures out how to show each piece to the model. Servers cannot invent new box types on their own.

Key concepts

Content Blocks tools/call Multimodal Results Resource Reference

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

A tools/call result in MCP carries the tool's output as a typed sequence of content blocks. The five valid types, the closed-set policy, and the lazy-fetch resource link are all design decisions that shape how agents handle multimodal payloads.

The result shape and the five content types

A tools/call JSON-RPC response returns {content: ContentBlock[], isError?: boolean}. The content array can be empty, contain one block, or contain many. Each block is a JSON object with a type field as the discriminator.

text is {type: "text", text: string}. A UTF-8 string payload for natural language output, query results, code, status messages, or any other text. The most common type by a wide margin.

image is {type: "image", data: string, mimeType: string}. The data field holds image bytes encoded as base64. The mimeType specifies the format (image/png, image/jpeg, image/webp). Hosts forward this to multimodal models as native image input. Browser automation tools return screenshots this way. Charting tools return generated visualizations. OCR tools can return the original image alongside recognized text.

audio is {type: "audio", data: string, mimeType: string}. Added in the 2025 spec. Same shape as image but for audio bytes (audio/wav, audio/mpeg, audio/ogg). Hosts route this to voice-capable models. Tools that synthesize speech, capture recordings, or produce audio analysis use this type.

resource_link is {type: "resource_link", uri: string, name: string, mimeType?: string}. Instead of inlining payload data, the block carries a reference to a resource the host can fetch via resources/read. The tool returns a pointer; the host decides whether and when to dereference it.

resource is {type: "resource", resource: {uri: string, mimeType?: string, text?: string, blob?: string}}. It embeds the resource's contents in the result, as text or a base64 blob.

Why the resource link type exists: lazy fetching

Mixed-type arrays as the default pattern

Tool errors versus protocol errors

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

A browser automation server returns a text description of the loaded page alongside an image screenshot; multimodal models read the screenshot as visual input to decide what to click next.
A speech synthesis server returns an audio block with a wav payload and a text block describing the utterance; voice-capable hosts route the audio to the user, text-only hosts display the description.

What an interviewer would ask next. Try answering before peeking at the approach.

QWhy does MCP define a resource link content type instead of always inlining data in text or image blocks?

Inlining forces the tool to pay token and bandwidth cost on every result regardless of whether the model reads the data. A resource URI lets the host fetch lazily. A search returning twenty matches as pointers becomes twenty small blocks; the model picks the one it wants to inspect and only that one is fetched.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Assuming every tool result is plain text. MCP tools can return images, audio, and resource references in the same array, and a single call can mix types freely.

60 second bullets to scan on the way to the call.

Name all five content types: text, image, audio, resource_link, resource.
State that the type set is closed and servers cannot define custom types.

Primary sources. Browse if you want the original framing.