Client sees "Task <id> failed" instead of the real error/result on failed tasks

[jirispilka]

I initially started with a PR (the fix itself is small), but the returned shape changes for existing consumers, so wanted to raise it first. I would be happy to work on this PR.

For reference, we experienced this issue while adding support for long-running async tasks for Actors in Apify MCP server - see failed task do not return results and apify/apify-mcp-server#685 (comment)"

Describe the bug

From the spec:

For tasks in a terminal status, receivers MUST return from tasks/result exactly what the underlying request would have returned, whether that is a successful result or a JSON-RPC error.

So when a task fails, we're blind to the real error - the client just gets Task <id> failed.

When a task-augmented request reaches failed status, TaskManager.requestStream doesn't call tasks/result it just yields a hardcoded ProtocolError(InternalError, "Task <id> failed"). So whatever the handler stored (e.g. { isError: true, content: [...] }) is unreachable.

// packages/core/src/shared/taskManager.ts:303
if (isTerminal(task.status)) {
    switch (task.status) {
        case 'completed': {
            const result = await this.getTaskResult({ taskId }, resultSchema, options);
            yield { type: 'result', result };
            break;
        }
        case 'failed': {
            yield { type: 'error', error: new ProtocolError(ProtocolErrorCode.InternalError, `Task ${taskId} failed`) };
            break;
        }
        case 'cancelled': { /* synthesized */ }
    }
    return;
}

To Reproduce

1. Register a tool whose handler stores a failure with storeTaskResult(taskId, 'failed', { content: [...], isError: true }).
2. Call it via client.experimental.tasks.requestStream(...) with the task option set.
3. The terminal event is ProtocolError("Task <id> failed")

Expected behavior
requestStream should call tasks/result on failed the same way it does on completed, and yield whatever comes back: { type: 'result', result } for a stored Result, or { type: 'error', error } (with the real code/message/data preserved) if tasks/result returns a JSON-RPC error. cancelled can stay synthesized since nothing is stored for it.

Logs
N/A - deterministic from the code path above.

Additional context
This helper is shared between the client and server experimental tasks modules, so both ExperimentalClientTasks.requestStream and ExperimentalServerTasks.requestStream are affected.

[mcp-claude]

confirmed: when a task-augmented request reaches failed status, requestStream skips tasks/result and yields a hardcoded ProtocolError("Task <id> failed"). the real stored error/result is never retrieved.

root cause: taskManager.ts:310-312 — the failed case doesn't mirror the completed case (lines 305–308). fix is to call this.getTaskResult(...) for failed, then yield { type: 'result', result } — the same pattern as completed. the completed branch is already correct and serves as the template.

v1.x doesn't have the tasks feature at all — main only.

repro script (repro.ts)

import { TaskManager } from './packages/core/src/shared/taskManager.js';
import type { TaskManagerHost } from './packages/core/src/shared/taskManager.js';
import { ProtocolError, ProtocolErrorCode } from './packages/core/src/types/index.js';
import { z } from 'zod';

const ResultSchema = z.object({
    _meta: z.object({}).optional(),
    content: z.array(z.object({ type: z.string(), text: z.string() })).optional(),
    isError: z.boolean().optional(),
});

async function main() {
    const taskId = 'task-abc-123';
    const realStoredResult = {
        content: [{ type: 'text', text: 'Tool execution failed: connection refused' }],
        isError: true,
    };
    const hostRequests: string[] = [];

    const mockHost: TaskManagerHost = {
        enforceStrictCapabilities: false,
        assertTaskCapability() {},
        assertTaskHandlerCapability() {},
        reportError(err) { console.error('reportError:', err); },
        removeProgressHandler() {},
        registerHandler() {},
        sendOnResponseStream: async () => {},
        async request(request, _schema, _options) {
            hostRequests.push(request.method as string);
            if (request.method === 'tools/call') {
                return { task: { taskId, status: 'working', createdAt: new Date().toISOString(), ttl: null, pollInterval: 10 } } as any;
            }
            if (request.method === 'tasks/get') {
                return { taskId, status: 'failed', createdAt: new Date().toISOString(), ttl: null, pollInterval: 10 } as any;
            }
            if (request.method === 'tasks/result') {
                return realStoredResult as any;
            }
            throw new Error(`Unexpected method: ${request.method}`);
        },
        async notification() {},
    };

    const manager = new TaskManager({ defaultTaskPollInterval: 10 });
    manager.bind(mockHost);

    const events: Array<{ type: string; data: any }> = [];
    for await (const event of manager.requestStream(
        { method: 'tools/call', params: { name: 'my-tool' } },
        ResultSchema,
        { task: { ttl: 5000 } }
    )) {
        events.push({ type: event.type, data: event });
    }

    console.log('Host requests made:', hostRequests);
    const terminalEvent = events.find(e => e.type === 'error' || e.type === 'result');
    if (terminalEvent?.type === 'error') {
        console.log('Error message:', (terminalEvent.data as any).error.message);
    }
}
main().catch(console.error);

command + output

$ npx tsx repro.ts
Host requests made: [ 'tools/call', 'tasks/get' ]
Error message: Task task-abc-123 failed

tasks/result is absent from host requests — it's never called. the terminal event is the hardcoded ProtocolError(-32603, "Task task-abc-123 failed") instead of the real stored result.

code path

taskManager.ts:303  if (isTerminal(task.status))
taskManager.ts:304    switch (task.status)
taskManager.ts:305      case 'completed':
taskManager.ts:306        const result = await this.getTaskResult(...)   // ✓ correct
taskManager.ts:307        yield { type: 'result', result }
taskManager.ts:310      case 'failed':
taskManager.ts:311        yield { type: 'error', error: new ProtocolError(..., `Task ${taskId} failed`) }  // ✗ hardcoded, no getTaskResult call

the completed branch (305–308) is correct; the failed branch (310–312) needs the same treatment.

suggested fix

// packages/core/src/shared/taskManager.ts
                        case 'failed': {
-                           yield { type: 'error', error: new ProtocolError(ProtocolErrorCode.InternalError, `Task ${taskId} failed`) };
+                           const result = await this.getTaskResult({ taskId }, resultSchema, options);
+                           yield { type: 'result', result };
                            break;
                        }

test to verify: assert that after requestStream completes on a failed task, tasks/result appears in the host's request log and the terminal event is { type: 'result' } carrying the stored isError: true content rather than a generic ProtocolError.