Skip to main content
Glama

Get task results

get_task_results
Read-only

Required after any call that returned status: running.

The task keeps working, but its results are not delivered until polled. The call waits for the next event — a new streaming chunk on any listed task, or a task settling — then returns the state of all listed tasks. Tasks settle one at a time: keep calling with the still-running ids to collect the rest (settledInThisCall lists the ones that just finished).

Streaming chunks from advanced_web_fetch, advanced_web_search and seo_metrics arrive in streaming.chunks; chunks already delivered are never redelivered. Act on partial chunks: fire follow-up calls in parallel and pass their new ids to the next get_task_results. A response carries a bounded amount of chunk data: when streaming.pendingChunks is set, that many more chunks of the task are waiting — call again with the same id to receive them, even if the task has finished. A record's index too long for one chunk continues in item.index chunks for the same id (indexPart of indexParts); its parts follow one another line by line.

credits.spent is what was charged since the previous response for the same tasks — a running task keeps charging after the call that started it answers — so spent summed over that first response and every poll is the full cost.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "taskIds": "<taskIds>"
    },
    "name": "get_task_results"
  }
}

Input Schema

NameRequiredDescriptionDefault
taskIdsYesIds of tasks that returned `status: "running"`. Up to 64 per call.
maxWaitSecNoMaximum seconds to wait for the next event. Both the default and the ceiling are the server's 50 seconds — a larger value is clamped down to it. Pass `0` for an immediate non-blocking read.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observed

TDQS

A4.3/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond readOnlyHint=true, the description discloses substantial behavior: the call blocks until an event, tasks settle one at a time, chunks are never redelivered, responses are bounded in chunk volume, and credits accrue between polls. It stops short of stating the maximum block duration or what an empty/settled state looks like, but the behavioral picture is unusually rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The critical condition (required after status: running) is front-loaded, and each subsequent paragraph covers a distinct concern: settle ordering, streaming chunk retrieval, index continuation, and credit accounting. It is dense and long, but nearly every sentence carries operational information an agent needs.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

There is no output schema, and the description compensates fully by naming the return fields an agent must react to (settledInThisCall, streaming.chunks, streaming.pendingChunks, item.index/indexPart, credits.spent) and explaining how they drive the next call. For a polling tool with non-obvious loop semantics, this is complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the schema already documents both parameters, but the description adds real meaning about taskIds: it must be ids that returned running, and on repeat calls it should carry the still-running ids plus any new ids from parallel follow-ups. maxWaitSec is only implicitly covered by 'waits for the next event', relying on the schema for its 0 = non-blocking semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The opening line and following sentence define a specific operation: poll the listed task ids, wait for the next event, and return the state of all listed tasks. It is clearly distinguishable from the sibling fetch/search tools, though the phrase 'Required after any call that returned status: running' is slightly oblique as a standalone purpose statement.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It states exactly when to call (after any response with status: running), how to keep calling (pass the still-running ids), and an edge case (call again with the same id even after the task has finished when pendingChunks is set). It also instructs the agent to act on partial chunks and pass new ids to the next poll, leaving little to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.

Resources