Feat/tasks mrtr extension

src/connection/index.ts

@@ -49,6 +49,14 @@ export interface RunContext {
    * GET-SSE, DNS rebinding) bypass this and use raw fetch.
    */
   connect(): Promise<Connection>;
+  /**
+   * Wire mode override for suites that exercise both the legacy and
+   * SEP-2575 stateless wires against a single spec version (notably
+   * SEP-2663 tasks and SEP-2322 MRTR). When absent the wire is implied
+   * by `specVersion` — `2025-x` ⇒ legacy, draft ⇒ stateless. Scenarios
+   * outside the tasks/mrtr suites ignore this knob.
+   */
+  wire?: 'legacy' | 'stateless';
 }
 
 export class JsonRpcError extends Error {

src/scenarios/index.ts

@@ -86,6 +86,17 @@ import {
   InputRequiredResultValidateInputScenario
 } from './server/input-required-result';
 
+import { TasksLifecycleScenario } from './server/tasks/lifecycle';
+import { TasksCapabilityNegotiationScenario } from './server/tasks/capability';
+import { TasksWireFieldsScenario } from './server/tasks/wire-fields';
+import { TasksRequestStateRemovalScenario } from './server/tasks/request-state';
+import { TasksMRTRInputScenario } from './server/tasks/mrtr-input';
+import { TasksRequestHeadersScenario } from './server/tasks/headers';
+import { TasksDispatchScenario } from './server/tasks/dispatch';
+import { TasksStatusNotificationsScenario } from './server/tasks/notifications';
+import { TasksRequiredTaskErrorScenario } from './server/tasks/required-task-error';
+import { MrtrEphemeralFlowScenario } from './server/mrtr/ephemeral-flow';
+
 import {
   HttpHeaderValidationScenario,
   HttpCustomHeaderServerValidationScenario
@@ -122,7 +133,29 @@ const pendingClientScenariosList: ClientScenario[] = [
   // Pending until the everything-server fully implements SEP-2243
   // header validation (case-insensitive names, whitespace trimming, -32001 error code)
   new HttpHeaderValidationScenario(),
-  new HttpCustomHeaderServerValidationScenario()
+  new HttpCustomHeaderServerValidationScenario(),
+
+  // SEP-2663 Tasks extension lifecycle.
+  // The everything-server does not implement the
+  // io.modelcontextprotocol/tasks extension, so all-scenarios.test.ts
+  // cannot exercise these against the default fixture. Active runs target
+  // a SEP-2663-conformant server via the dedicated
+  // tasks/all-scenarios.test.ts harness.
+  new TasksLifecycleScenario(),
+  new TasksCapabilityNegotiationScenario(),
+  new TasksWireFieldsScenario(),
+  new TasksRequestStateRemovalScenario(),
+  new TasksMRTRInputScenario(),
+  new TasksRequestHeadersScenario(),
+  new TasksDispatchScenario(),
+  new TasksStatusNotificationsScenario(),
+  new TasksRequiredTaskErrorScenario(),
+
+  // SEP-2322 MRTR (ephemeral InputRequiredResult flow).
+  // Targets a different fixture than tasks scenarios; the dedicated
+  // mrtr/all-scenarios.test.ts runner points at an MRTR-conformant
+  // server via MRTR_SERVER_URL / MRTR_SERVER_CMD.
+  new MrtrEphemeralFlowScenario()
 ];
 
 // All client scenarios
@@ -189,6 +222,26 @@ const allClientScenariosList: ClientScenario[] = [
   new HttpHeaderValidationScenario(),
   new HttpCustomHeaderServerValidationScenario(),
 
+  // SEP-2663 Tasks extension.
+  // Listed here so the CLI can find each scenario by name and so the
+  // active/pending filter sees it; pendingClientScenariosList above
+  // excludes them from automatic runs against the everything-server
+  // (which doesn't implement io.modelcontextprotocol/tasks yet).
+  new TasksLifecycleScenario(),
+  new TasksCapabilityNegotiationScenario(),
+  new TasksWireFieldsScenario(),
+  new TasksRequestStateRemovalScenario(),
+  new TasksMRTRInputScenario(),
+  new TasksRequestHeadersScenario(),
+  new TasksDispatchScenario(),
+  new TasksStatusNotificationsScenario(),
+  new TasksRequiredTaskErrorScenario(),
+
+  // SEP-2322 MRTR (ephemeral InputRequiredResult flow). Targets a
+  // dedicated MRTR fixture — out of scope for the default
+  // everything-server until SEP-2322 lands there.
+  new MrtrEphemeralFlowScenario(),
+
   // InputRequiredResult scenarios (SEP-2322)
   new InputRequiredResultBasicElicitationScenario(),
   new InputRequiredResultBasicSamplingScenario(),

src/scenarios/server/_shared/checks.ts

@@ -0,0 +1,67 @@
+/**
+ * Test-scaffolding helpers shared across server-conformance scenarios.
+ *
+ * Pure: no I/O, no async, no scenario-specific state. Every server
+ * suite (tasks, mrtr, ...) emits checks in the same JSON shape and
+ * derives them through the same FAILURE / SKIPPED helpers; pulling
+ * them out of any one suite's helpers.ts makes them reusable.
+ *
+ * `AnyResult` is the Zod passthrough schema callers used to pair with
+ * the official MCP TS SDK's `client.request(req, AnyResult)`. The raw
+ * session helpers in `_shared/raw-session.ts` don't depend on Zod, but
+ * scenarios that drive the SDK directly (or want to validate a
+ * particular result shape later) keep using it.
+ */
+
+import { z } from 'zod';
+
+import type { ConformanceCheck, SpecReference } from '../../../types';
+
+export function errMsg(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/** Build a FAILURE check from a thrown error, preserving id/name/description. */
+export function failureCheck(
+  id: string,
+  name: string,
+  description: string,
+  error: unknown,
+  specReferences: SpecReference[]
+): ConformanceCheck {
+  return {
+    id,
+    name,
+    description,
+    status: 'FAILURE',
+    timestamp: new Date().toISOString(),
+    errorMessage: errMsg(error),
+    specReferences
+  };
+}
+
+/** Build a SKIPPED check (preserves id stability so Ctrl+F still finds it). */
+export function skipCheck(
+  id: string,
+  name: string,
+  description: string,
+  reason: string,
+  specReferences: SpecReference[]
+): ConformanceCheck {
+  return {
+    id,
+    name,
+    description,
+    status: 'SKIPPED',
+    timestamp: new Date().toISOString(),
+    errorMessage: `Skipped: ${reason}`,
+    specReferences
+  };
+}
+
+/**
+ * Zod passthrough schema. Pair with `client.request(req, AnyResult)` to
+ * preserve fields the SDK's typed result schemas would strip. Every
+ * SEP-2663 / SEP-2322 wire field falls into this bucket today.
+ */
+export const AnyResult = z.object({}).passthrough();

src/scenarios/server/_shared/raw-session.test.ts

@@ -0,0 +1,152 @@
+/**
+ * Unit tests for readJsonRpcResponse — the SSE / JSON content-type
+ * dispatcher used by every raw-session request. The SSE branch
+ * delegates to `eventsource-parser`; these tests pin the contract
+ * across the cases that matter for Streamable HTTP responses:
+ *
+ *   - application/json — single-frame body, id-match required
+ *   - text/event-stream — multi-event scan, id-match required,
+ *     reassembly of multi-line `data:` continuations, CRLF tolerance,
+ *     comment / retry / id field handling, and error-frame return.
+ */
+
+import { describe, it, expect } from 'vitest';
+
+import { readJsonRpcResponse } from './raw-session';
+
+function sseResponse(body: string, status = 200): Response {
+  return new Response(body, {
+    status,
+    headers: { 'Content-Type': 'text/event-stream' }
+  });
+}
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'Content-Type': 'application/json' }
+  });
+}
+
+describe('readJsonRpcResponse', () => {
+  describe('application/json branch', () => {
+    it('returns the body when id matches', async () => {
+      const body = { jsonrpc: '2.0', id: 42, result: { ok: true } };
+      const out = await readJsonRpcResponse(jsonResponse(body), 42);
+      expect(out).toEqual(body);
+    });
+
+    it('throws on id mismatch', async () => {
+      const body = { jsonrpc: '2.0', id: 99, result: { ok: true } };
+      await expect(readJsonRpcResponse(jsonResponse(body), 42)).rejects.toThrow(
+        /JSON-RPC id mismatch.*expected 42.*got 99/
+      );
+    });
+
+    it('preserves error frames', async () => {
+      const body = {
+        jsonrpc: '2.0',
+        id: 7,
+        error: { code: -32601, message: 'Method not found' }
+      };
+      const out = await readJsonRpcResponse(jsonResponse(body), 7);
+      expect(out.error?.code).toBe(-32601);
+    });
+  });
+
+  describe('text/event-stream branch', () => {
+    it('extracts the single JSON-RPC frame from a one-event stream', async () => {
+      const frame = { jsonrpc: '2.0', id: 1, result: { ok: true } };
+      const body = `data: ${JSON.stringify(frame)}\n\n`;
+      const out = await readJsonRpcResponse(sseResponse(body), 1);
+      expect(out).toEqual(frame);
+    });
+
+    it('picks the matching id when earlier events carry other ids', async () => {
+      // Streamable HTTP allows in-flight notifications (`notifications/*`,
+      // which have no id) followed by the response frame. Make sure we
+      // skip the noise and return the response.
+      const notif = {
+        jsonrpc: '2.0',
+        method: 'notifications/progress',
+        params: { progress: 50 }
+      };
+      const frame = { jsonrpc: '2.0', id: 5, result: { done: true } };
+      const body =
+        `data: ${JSON.stringify(notif)}\n\n` +
+        `data: ${JSON.stringify(frame)}\n\n`;
+      const out = await readJsonRpcResponse(sseResponse(body), 5);
+      expect(out).toEqual(frame);
+    });
+
+    it('reassembles multi-line data: continuations', async () => {
+      // WHATWG SSE concatenates consecutive `data:` lines with `\n`.
+      // The hand-rolled parser this commit replaces also did this, but
+      // only because the frames we send happen to fit on one line; pin
+      // the multi-line case so a future fixture that emits pretty-
+      // printed JSON keeps working.
+      const body =
+        'data: {"jsonrpc":"2.0",\ndata: "id":9,\ndata: "result":{}}\n\n';
+      const out = await readJsonRpcResponse(sseResponse(body), 9);
+      expect(out).toEqual({ jsonrpc: '2.0', id: 9, result: {} });
+    });
+
+    it('tolerates CRLF line endings', async () => {
+      const frame = { jsonrpc: '2.0', id: 3, result: { ok: true } };
+      const body = `data: ${JSON.stringify(frame)}\r\n\r\n`;
+      const out = await readJsonRpcResponse(sseResponse(body), 3);
+      expect(out).toEqual(frame);
+    });
+
+    it('skips comment + id + retry fields without misreading them as frames', async () => {
+      const frame = { jsonrpc: '2.0', id: 11, result: { ok: true } };
+      const body =
+        ': heartbeat\n' +
+        'retry: 5000\n' +
+        'id: event-7\n' +
+        '\n' +
+        `event: message\ndata: ${JSON.stringify(frame)}\n\n`;
+      const out = await readJsonRpcResponse(sseResponse(body), 11);
+      expect(out).toEqual(frame);
+    });
+
+    it('returns error frames from the SSE stream', async () => {
+      const frame = {
+        jsonrpc: '2.0',
+        id: 4,
+        error: { code: -32001, message: 'HeaderMismatch' }
+      };
+      const body = `data: ${JSON.stringify(frame)}\n\n`;
+      const out = await readJsonRpcResponse(sseResponse(body), 4);
+      expect(out.error?.code).toBe(-32001);
+    });
+
+    it('throws when no event matches the expected id', async () => {
+      // Only non-response events on the stream.
+      const notif = {
+        jsonrpc: '2.0',
+        method: 'notifications/progress',
+        params: { progress: 100 }
+      };
+      const body = `data: ${JSON.stringify(notif)}\n\n`;
+      await expect(readJsonRpcResponse(sseResponse(body), 7)).rejects.toThrow(
+        /No JSON-RPC frame with id=7/
+      );
+    });
+
+    it('throws on empty stream body', async () => {
+      await expect(readJsonRpcResponse(sseResponse(''), 1)).rejects.toThrow(
+        /No JSON-RPC frame with id=1/
+      );
+    });
+
+    it('skips events with non-JSON data without throwing', async () => {
+      // Plain text events shouldn't blow up the parser; we just skip
+      // them and keep scanning for the JSON-RPC frame.
+      const frame = { jsonrpc: '2.0', id: 8, result: { ok: true } };
+      const body = 'data: keepalive\n\n' + `data: ${JSON.stringify(frame)}\n\n`;
+      const out = await readJsonRpcResponse(sseResponse(body), 8);
+      expect(out).toEqual(frame);
+    });
+  });
+});