fix(server): address review feedback on ProtocolError re-throw alignment

- Remove dead null-guard after getTask try-catch (getTask never returns null)
- Add migration doc bullet for no-task-store InternalError case
- Add test for output schema validation in automatic-polling path

Prior commits on this branch already addressed: MethodNotFound -> InvalidParams,
plain Error -> ProtocolError for no-task-store, getTask InvalidParams -> InternalError
conversion, status-guarded validateToolOutput, and error-code assertions in tests.

Author: felixweinberger

docs/migration-SKILL.md

@@ -174,6 +174,7 @@ Behavior changes in `callTool` results:
 - Output validation failure: `{ isError: true }` → throws `ProtocolError` (`InternalError`)
 - Task-required without task: `{ isError: true }` → throws `ProtocolError` (`InvalidParams`)
 - Handler throws `ProtocolError`: `{ isError: true }` → re-thrown as JSON-RPC error
+- No task store configured for `taskSupport: 'optional'` tool: `{ isError: true }` → throws `ProtocolError` (`InternalError`)
 - Handler throws plain `Error`: `{ isError: true }` → `{ isError: true }` (unchanged)
 
 Migration: if code checks `result.isError` to detect output-schema violations or deliberate `ProtocolError` throws, add a `try/catch` around `callTool`. If a handler throws `ProtocolError` expecting tool-level wrapping, change it to throw a plain `Error`.

docs/migration.md

@@ -641,6 +641,7 @@ This aligns error surfaces with the MCP spec's classification:
 - **Output validation failure** — now throws `ProtocolError` with `InternalError` code (was `{ isError: true }`)
 - **Task-required tool called without task** — now throws `ProtocolError` with `InvalidParams` code (was `{ isError: true }`)
 - **Handler throws `ProtocolError`** — now re-thrown as a JSON-RPC error (was `{ isError: true }`)
+- **No task store configured for `taskSupport: 'optional'` tool** — now throws `ProtocolError` with `InternalError` code (was `{ isError: true }`)
 - **Handler throws plain `Error`** — unchanged, still returns `{ isError: true }`
 
 **Before (v1):**

packages/server/src/server/mcp.ts

@@ -324,9 +324,8 @@ export class McpServer {
 
         while (task.status !== 'completed' && task.status !== 'failed' && task.status !== 'cancelled') {
             await new Promise(resolve => setTimeout(resolve, pollInterval));
-            let updatedTask;
             try {
-                updatedTask = await ctx.task.store.getTask(taskId);
+                task = await ctx.task.store.getTask(taskId);
             } catch (error) {
                 // RequestTaskStore.getTask throws InvalidParams when the task is
                 // missing, but a task vanishing mid-poll is a server-side issue
@@ -336,10 +335,6 @@ export class McpServer {
                 }
                 throw error;
             }
-            if (!updatedTask) {
-                throw new ProtocolError(ProtocolErrorCode.InternalError, `Task ${taskId} not found during polling`);
-            }
-            task = updatedTask;
         }
 
         // Return the final result

test/integration/test/server/mcp.test.ts

@@ -6642,6 +6642,108 @@ describe('Zod v4', () => {
             taskStore.cleanup();
         });
 
+        test('should validate output schema for taskSupport "optional" tool result returned via automatic polling', async () => {
+            const taskStore = new InMemoryTaskStore();
+            const { releaseLatch, waitForLatch } = createLatch();
+
+            const mcpServer = new McpServer(
+                {
+                    name: 'test server',
+                    version: '1.0'
+                },
+                {
+                    capabilities: {
+                        tools: {},
+                        tasks: {
+                            requests: {
+                                tools: {
+                                    call: {}
+                                }
+                            },
+
+                            taskStore
+                        }
+                    }
+                }
+            );
+
+            const client = new Client(
+                {
+                    name: 'test client',
+                    version: '1.0'
+                },
+                {
+                    capabilities: {
+                        tasks: {
+                            requests: {
+                                tools: {
+                                    call: {}
+                                }
+                            }
+                        }
+                    }
+                }
+            );
+
+            mcpServer.experimental.tasks.registerToolTask(
+                'optional-task-with-output-schema',
+                {
+                    description: 'An optional task with an output schema',
+                    inputSchema: z.object({
+                        value: z.number()
+                    }),
+                    outputSchema: z.object({
+                        count: z.number()
+                    }),
+                    execution: {
+                        taskSupport: 'optional'
+                    }
+                },
+                {
+                    createTask: async (_args, ctx) => {
+                        const task = await ctx.task.store.createTask({ ttl: 60_000, pollInterval: 100 });
+                        const store = ctx.task.store;
+                        setTimeout(async () => {
+                            await store.storeTaskResult(task.taskId, 'completed', {
+                                content: [{ type: 'text' as const, text: 'done' }],
+                                structuredContent: { count: 'not-a-number' }
+                            });
+                            releaseLatch();
+                        }, 150);
+                        return { task };
+                    },
+                    getTask: async (_args, ctx) => {
+                        const task = await ctx.task.store.getTask(ctx.task.id);
+                        if (!task) {
+                            throw new Error('Task not found');
+                        }
+                        return task;
+                    },
+                    getTaskResult: async (_args, ctx) => {
+                        const result = await ctx.task.store.getTaskResult(ctx.task.id);
+                        return result as CallToolResult;
+                    }
+                }
+            );
+
+            const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+            await Promise.all([client.connect(clientTransport), mcpServer.connect(serverTransport)]);
+
+            await expect(
+                client.callTool({
+                    name: 'optional-task-with-output-schema',
+                    arguments: { value: 1 }
+                })
+            ).rejects.toMatchObject({
+                code: ProtocolErrorCode.InternalError,
+                message: expect.stringMatching(/Invalid structured content/)
+            });
+
+            await waitForLatch();
+            taskStore.cleanup();
+        });
+
         test('should return CreateTaskResult when tool with taskSupport "required" is called WITH task augmentation', async () => {
             const taskStore = new InMemoryTaskStore();
             const { releaseLatch, waitForLatch } = createLatch();