@yawlabs/mcp-compliance 0.6.0 → 0.8.0

package/dist/{chunk-QLFYT4I7.js → chunk-DOIOJVEE.js}

@@ -56,7 +56,7 @@ function computeScore(tests) {
 
 // src/types.ts
 var TEST_DEFINITIONS = [
-  // ── Transport (10 tests) ─────────────────────────────────────────
+  // ── Transport (13 tests) ─────────────────────────────────────────
   {
     id: "transport-post",
     name: "HTTP POST accepted",
@@ -81,8 +81,8 @@ var TEST_DEFINITIONS = [
     category: "transport",
     required: false,
     specRef: "basic/transports#streamable-http",
-    description: "Verifies that sending a JSON-RPC notification (no id field) returns HTTP 202 Accepted with no body. Per spec, servers MUST return 202 for notifications.",
-    recommendation: "Detect JSON-RPC messages without an id field and return HTTP 202 with an empty body. Do not attempt to send a JSON-RPC response for notifications."
+    description: "Verifies that sending a JSON-RPC notification (no id field) returns exactly HTTP 202 Accepted with no body. Per spec, servers MUST return 202 \u2014 not 200 or 204.",
+    recommendation: "Detect JSON-RPC messages without an id field and return HTTP 202 with an empty body. Do not return 200 or 204 \u2014 the spec requires exactly 202 Accepted."
   },
   {
     id: "transport-session-id",
@@ -93,6 +93,24 @@ var TEST_DEFINITIONS = [
     description: "Tests that the server returns HTTP 400 when MCP-Session-Id header is missing on requests after initialization (when the server issued a session ID).",
     recommendation: "If your server issues an MCP-Session-Id header in the initialize response, reject subsequent requests that omit this header with HTTP 400."
   },
+  {
+    id: "transport-session-invalid",
+    name: "Returns 404 for unknown session ID",
+    category: "transport",
+    required: false,
+    specRef: "basic/transports#streamable-http",
+    description: "Sends a request with a fabricated MCP-Session-Id and verifies the server returns HTTP 404. Per spec, servers managing sessions MUST return 404 for unrecognized session IDs.",
+    recommendation: "Return HTTP 404 (Not Found) for requests with an MCP-Session-Id that does not match any active session. Do not return 400 \u2014 that is for missing session IDs."
+  },
+  {
+    id: "transport-content-type-reject",
+    name: "Rejects non-JSON request Content-Type",
+    category: "transport",
+    required: false,
+    specRef: "basic/transports#streamable-http",
+    description: "Sends a POST with Content-Type: text/plain instead of application/json and verifies the server rejects it with a 4xx status.",
+    recommendation: "Validate the Content-Type header on incoming POST requests. Reject requests that are not application/json with HTTP 415 (Unsupported Media Type) or 400."
+  },
   {
     id: "transport-get",
     name: "GET returns SSE stream or 405",
@@ -147,7 +165,16 @@ var TEST_DEFINITIONS = [
     description: "Sends multiple JSON-RPC requests in parallel and verifies the server responds to all with correct matching IDs. Tests that the server can handle concurrent connections.",
     recommendation: "Ensure your server can handle multiple simultaneous requests. Each response must include the correct id matching the request. Use async handlers or connection pooling."
   },
-  // ── Lifecycle (12 tests) ─────────────────────────────────────────
+  {
+    id: "transport-sse-event-field",
+    name: "SSE responses include event: message",
+    category: "transport",
+    required: false,
+    specRef: "basic/transports#streamable-http",
+    description: "Sends a request with Accept: text/event-stream and checks that SSE responses include the event: message field. Per spec, servers MUST set event: message for JSON-RPC messages in SSE streams.",
+    recommendation: 'Include "event: message" before each "data:" line in your SSE responses. This is required by the MCP spec for JSON-RPC messages sent over SSE.'
+  },
+  // ── Lifecycle (17 tests) ─────────────────────────────────────────
   {
     id: "lifecycle-init",
     name: "Initialize handshake",
@@ -220,6 +247,33 @@ var TEST_DEFINITIONS = [
     description: "Verifies that the JSON-RPC response id matches the request id sent by the client. This is a fundamental JSON-RPC 2.0 requirement.",
     recommendation: "Copy the id field from the request into the response. This is a core JSON-RPC 2.0 requirement. Check that your framework does not modify or discard the request ID."
   },
+  {
+    id: "lifecycle-string-id",
+    name: "Supports string request IDs",
+    category: "lifecycle",
+    required: false,
+    specRef: "basic",
+    description: "Sends a request with a string id instead of a number. JSON-RPC 2.0 allows both string and number IDs. The server must echo back the exact string id in the response.",
+    recommendation: "Ensure your JSON-RPC implementation supports both string and number request IDs. Echo the id back exactly as received, preserving its type."
+  },
+  {
+    id: "lifecycle-version-negotiate",
+    name: "Handles unknown protocol version",
+    category: "lifecycle",
+    required: false,
+    specRef: "basic/lifecycle#version-negotiation",
+    description: 'Sends an initialize request with a future protocol version ("2099-01-01") and verifies the server either negotiates down to a version it supports or returns an error.',
+    recommendation: "When the client requests an unsupported protocol version, respond with the closest version your server supports. Do not blindly accept unknown versions."
+  },
+  {
+    id: "lifecycle-reinit-reject",
+    name: "Rejects second initialize request",
+    category: "lifecycle",
+    required: false,
+    specRef: "basic/lifecycle#initialization",
+    description: "Sends a second initialize request within the same session. Per spec, the client MUST NOT send initialize more than once. The server should reject it.",
+    recommendation: "Track initialization state per session. Reject duplicate initialize requests with a JSON-RPC error or HTTP 4xx. Do not reset session state on re-initialization."
+  },
   {
     id: "lifecycle-logging",
     name: "logging/setLevel accepted",
@@ -249,12 +303,30 @@ var TEST_DEFINITIONS = [
   },
   {
     id: "lifecycle-progress",
-    name: "Accepts progress notifications",
+    name: "Handles progress notifications gracefully",
     category: "lifecycle",
     required: false,
     specRef: "basic/utilities#progress",
-    description: "Tests that the server accepts notifications/progress without error. Servers should handle progress notifications for request tracking.",
-    recommendation: "Accept notifications/progress with progressToken, progress, and optional total fields. Ignore notifications for unknown progress tokens."
+    description: "Sends a notifications/progress to the server and verifies it does not error. Note: per spec, progress flows from server to client during long-running requests. This test validates the server handles unexpected notifications gracefully.",
+    recommendation: "Accept unknown notifications without returning an error. The server should not crash or return a non-2xx status for notifications it does not recognize."
+  },
+  {
+    id: "lifecycle-list-changed",
+    name: "Accepts listChanged notifications",
+    category: "lifecycle",
+    required: false,
+    specRef: "basic/lifecycle#capability-negotiation",
+    description: "Sends notifications/tools/list_changed, notifications/resources/list_changed, and notifications/prompts/list_changed for declared capabilities and verifies the server accepts them.",
+    recommendation: "Accept listChanged notifications gracefully. When received, re-fetch the relevant list to detect changes. These notifications signal that the client's cached list may be stale."
+  },
+  {
+    id: "lifecycle-progress-token",
+    name: "Supports progress tokens in requests",
+    category: "lifecycle",
+    required: false,
+    specRef: "basic/utilities#progress",
+    description: "Sends a tools/call request with _meta.progressToken and checks if the server sends progress notifications via SSE. Progress support is optional but recommended for long-running operations.",
+    recommendation: "When a request includes _meta.progressToken, send notifications/progress events via SSE to report progress. Include progressToken, progress (current), and optionally total fields."
   },
   // ── Tools (4 tests) ──────────────────────────────────────────────
   {
@@ -263,7 +335,7 @@ var TEST_DEFINITIONS = [
     category: "tools",
     required: false,
     specRef: "server/tools#listing-tools",
-    description: "Calls tools/list and validates it returns an array of tool definitions. Required if the server declares tools capability.",
+    description: "Calls tools/list and validates it returns an array of tool definitions. Dynamically required at runtime if the server declares tools capability.",
     recommendation: "Implement the tools/list handler to return { tools: [...] } with an array of tool definition objects. Each tool needs at least a name and inputSchema."
   },
   {
@@ -300,7 +372,7 @@ var TEST_DEFINITIONS = [
     category: "resources",
     required: false,
     specRef: "server/resources#listing-resources",
-    description: "Calls resources/list and validates it returns an array. Required if the server declares resources capability.",
+    description: "Calls resources/list and validates it returns an array. Dynamically required at runtime if the server declares resources capability.",
     recommendation: "Implement resources/list to return { resources: [...] } with an array of resource objects. Each resource needs at least a uri and name."
   },
   {
@@ -346,7 +418,7 @@ var TEST_DEFINITIONS = [
     category: "prompts",
     required: false,
     specRef: "server/prompts#listing-prompts",
-    description: "Calls prompts/list and validates it returns an array. Required if the server declares prompts capability.",
+    description: "Calls prompts/list and validates it returns an array. Dynamically required at runtime if the server declares prompts capability.",
     recommendation: "Implement prompts/list to return { prompts: [...] } with an array of prompt objects. Each prompt needs at least a name field."
   },
   {
@@ -367,7 +439,7 @@ var TEST_DEFINITIONS = [
     description: "Tests cursor-based pagination on prompts/list. Validates nextCursor is a string if present and that fetching the next page works.",
     recommendation: "If you return nextCursor in prompts/list, ensure it is a string and that passing it back as cursor in the next request returns valid results."
   },
-  // ── Error Handling (8 tests) ─────────────────────────────────────
+  // ── Error Handling (10 tests) ────────────────────────────────────
   {
     id: "error-unknown-method",
     name: "Returns JSON-RPC error for unknown method",
@@ -440,6 +512,24 @@ var TEST_DEFINITIONS = [
     description: "Calls tools/call with a nonexistent tool name and verifies the server returns an error response.",
     recommendation: "Return a JSON-RPC error or set isError: true when tools/call receives an unrecognized tool name. Do not return an empty success response."
   },
+  {
+    id: "error-capability-gated",
+    name: "Rejects methods for undeclared capabilities",
+    category: "errors",
+    required: false,
+    specRef: "basic/lifecycle#capability-negotiation",
+    description: "Calls list methods (tools/list, resources/list, prompts/list) for capabilities the server did NOT declare, and verifies the server returns an error instead of success.",
+    recommendation: "Return a JSON-RPC error (e.g., -32601 Method not found) for methods associated with capabilities not declared in your initialize response."
+  },
+  {
+    id: "error-invalid-cursor",
+    name: "Handles invalid pagination cursor gracefully",
+    category: "errors",
+    required: false,
+    specRef: "basic",
+    description: "Sends a garbage pagination cursor to a list method and verifies the server handles it gracefully \u2014 either returning an error or ignoring the invalid cursor.",
+    recommendation: "Validate pagination cursors before use. Return a JSON-RPC error for unrecognized cursors, or treat invalid cursors as a request for the first page."
+  },
   // ── Schema Validation (6 tests) ──────────────────────────────────
   {
     id: "tools-schema",
@@ -456,8 +546,8 @@ var TEST_DEFINITIONS = [
     category: "schema",
     required: false,
     specRef: "server/tools#annotations",
-    description: "Validates tool annotation fields if present: readOnlyHint, destructiveHint, idempotentHint, openWorldHint should be booleans; title should be a string.",
-    recommendation: "If you include annotations on tools, ensure readOnlyHint, destructiveHint, idempotentHint, and openWorldHint are booleans. Title must be a string."
+    description: "Validates tool annotation fields if present: readOnlyHint, destructiveHint, idempotentHint, openWorldHint should be booleans.",
+    recommendation: "If you include annotations on tools, ensure readOnlyHint, destructiveHint, idempotentHint, and openWorldHint are booleans. Note: title belongs on the Tool object, not inside annotations."
   },
   {
     id: "tools-title-field",
@@ -495,7 +585,7 @@ var TEST_DEFINITIONS = [
     description: "Validates every resource has a valid URI (parseable as a URL) and a name field.",
     recommendation: "Ensure every resource has a valid, parseable URI and a name field. Add description and mimeType for better client integration."
   },
-  // ── Security: Auth & Transport (8 tests) ─────────────────────────
+  // ── Security: Auth & Transport (10 tests) ────────────────────────
   {
     id: "security-auth-required",
     name: "Rejects unauthenticated requests",
@@ -505,6 +595,15 @@ var TEST_DEFINITIONS = [
     description: "Sends a request without an Authorization header and verifies the server returns HTTP 401. Servers exposed over the network should require authentication.",
     recommendation: "Implement authentication on your MCP endpoint. Return HTTP 401 Unauthorized for requests without valid credentials. Use OAuth 2.1 or Bearer tokens as recommended by the MCP spec."
   },
+  {
+    id: "security-www-authenticate",
+    name: "401 responses include WWW-Authenticate header",
+    category: "security",
+    required: false,
+    specRef: "basic/authorization",
+    description: "When the server returns HTTP 401, checks for a WWW-Authenticate header indicating the required authentication scheme. Per HTTP spec (RFC 9110), servers SHOULD include this header.",
+    recommendation: `Include a WWW-Authenticate header in 401 responses to indicate the required auth scheme (e.g., 'WWW-Authenticate: Bearer realm="mcp"').`
+  },
   {
     id: "security-auth-malformed",
     name: "Rejects malformed auth credentials",
@@ -543,12 +642,12 @@ var TEST_DEFINITIONS = [
   },
   {
     id: "security-oauth-metadata",
-    name: "OAuth metadata endpoint exists",
+    name: "Protected Resource Metadata endpoint exists",
     category: "security",
     required: false,
     specRef: "basic/authorization",
-    description: "Checks for a well-known OAuth authorization server metadata endpoint at /.well-known/oauth-authorization-server. If the server requires auth, it should advertise how to obtain tokens.",
-    recommendation: "Publish an OAuth 2.0 Authorization Server Metadata document at /.well-known/oauth-authorization-server on your server's origin. Include issuer, token_endpoint, and supported grant types."
+    description: "Checks for a Protected Resource Metadata (RFC 9728) endpoint at /.well-known/oauth-protected-resource. Per MCP 2025-11-25, the MCP server publishes PRM with a resource identifier and authorization_servers array. Falls back to legacy /.well-known/oauth-authorization-server with a warning.",
+    recommendation: "Publish a Protected Resource Metadata document at /.well-known/oauth-protected-resource on your server's origin. Include 'resource' (your server's URL) and 'authorization_servers' (array of OAuth AS URLs). See RFC 9728."
   },
   {
     id: "security-token-in-uri",
@@ -568,6 +667,15 @@ var TEST_DEFINITIONS = [
     description: "If the server returns CORS headers, verifies that Access-Control-Allow-Origin is not set to wildcard (*). Wildcard CORS on an authenticated API allows cross-origin credential theft.",
     recommendation: 'Set Access-Control-Allow-Origin to specific trusted origins, not "*". If CORS is not needed (server-to-server only), do not send CORS headers at all.'
   },
+  {
+    id: "security-origin-validation",
+    name: "Validates Origin header on requests",
+    category: "security",
+    required: false,
+    specRef: "basic/transports#streamable-http",
+    description: "Sends a request with a suspicious Origin header (https://evil-rebinding-attack.example.com) and verifies the server rejects it. Per spec, servers MUST validate the Origin header to prevent DNS rebinding attacks.",
+    recommendation: "Validate the Origin header on all incoming requests. Reject requests from untrusted origins with HTTP 403. Maintain an allowlist of permitted origins."
+  },
   // ── Security: Input Validation (6 tests) ─────────────────────────
   {
     id: "security-command-injection",
@@ -753,7 +861,7 @@ function createIdCounter(start = 0) {
 }
 function parseSSEResponse(text) {
   const lines = text.split("\n");
-  let lastJsonRpcResponse = null;
+  let firstJsonRpcResponse = null;
   let currentData = [];
   function flushEvent() {
     if (currentData.length === 0) return;
@@ -762,8 +870,8 @@ function parseSSEResponse(text) {
     if (!data.trim()) return;
     try {
       const parsed = JSON.parse(data);
-      if (parsed.jsonrpc === "2.0" && parsed.id !== void 0) {
-        lastJsonRpcResponse = parsed;
+      if (!firstJsonRpcResponse && parsed.jsonrpc === "2.0" && parsed.id !== void 0) {
+        firstJsonRpcResponse = parsed;
       }
     } catch {
     }
@@ -777,7 +885,7 @@ function parseSSEResponse(text) {
     }
   }
   flushEvent();
-  return lastJsonRpcResponse;
+  return firstJsonRpcResponse;
 }
 async function mcpRequest(backendUrl, method, params, nextId, extraHeaders, timeout) {
   const id = nextId();
@@ -987,6 +1095,32 @@ async function runComplianceSuite(url, options = {}) {
       return { passed: valid, details: `Content-Type: ${ct}` };
     }
   );
+  await test(
+    "transport-content-type-reject",
+    "Rejects non-JSON request Content-Type",
+    "transport",
+    false,
+    "basic/transports#streamable-http",
+    async () => {
+      const res = await request(backendUrl, {
+        method: "POST",
+        headers: { "Content-Type": "text/plain", Accept: "application/json, text/event-stream", ...userHeaders },
+        body: JSON.stringify({ jsonrpc: "2.0", id: 99905, method: "ping" }),
+        signal: AbortSignal.timeout(timeout)
+      });
+      await res.body.text();
+      if (res.statusCode >= 400 && res.statusCode < 500) {
+        return { passed: true, details: `HTTP ${res.statusCode} (incorrect Content-Type rejected)` };
+      }
+      if (res.statusCode >= 200 && res.statusCode < 300) {
+        return {
+          passed: false,
+          details: `HTTP ${res.statusCode} \u2014 server accepted text/plain Content-Type (should require application/json)`
+        };
+      }
+      return { passed: false, details: `HTTP ${res.statusCode}` };
+    }
+  );
   await test(
     "transport-get",
     "GET returns SSE stream or 405",
@@ -1001,7 +1135,8 @@ async function runComplianceSuite(url, options = {}) {
         signal: AbortSignal.timeout(timeout)
       });
       const body = await res.body.text();
-      const ct = (res.headers["content-type"] || "").toLowerCase();
+      const rawCt = res.headers["content-type"];
+      const ct = (Array.isArray(rawCt) ? rawCt[0] : rawCt || "").toLowerCase();
       if (res.statusCode === 405) {
         return { passed: true, details: "HTTP 405 Method Not Allowed (acceptable)" };
       }
@@ -1109,6 +1244,50 @@ async function runComplianceSuite(url, options = {}) {
       return { passed: valid, details: `Version: ${version}` };
     }
   );
+  await test(
+    "lifecycle-version-negotiate",
+    "Handles unknown protocol version",
+    "lifecycle",
+    false,
+    "basic/lifecycle#version-negotiation",
+    async () => {
+      try {
+        const futureRes = await mcpRequest(
+          backendUrl,
+          "initialize",
+          {
+            protocolVersion: "2099-01-01",
+            capabilities: {},
+            clientInfo: { name: "mcp-compliance", version: TOOL_VERSION }
+          },
+          createIdCounter(99960),
+          userHeaders,
+          timeout
+        );
+        const result = futureRes.body?.result;
+        const error = futureRes.body?.error;
+        if (error) {
+          return {
+            passed: true,
+            details: `Server rejected unknown version with error: ${error.code} \u2014 ${error.message}`
+          };
+        }
+        if (result?.protocolVersion) {
+          const offered = result.protocolVersion;
+          if (offered === "2099-01-01") {
+            return {
+              passed: false,
+              details: 'Server accepted impossible future version "2099-01-01" \u2014 should offer a version it actually supports'
+            };
+          }
+          return { passed: true, details: `Server negotiated down to ${offered} (correct)` };
+        }
+        return { passed: false, details: "No protocolVersion or error in response" };
+      } catch {
+        return { passed: true, details: "Connection rejected for unknown version (acceptable)" };
+      }
+    }
+  );
   await test(
     "lifecycle-server-info",
     "Includes serverInfo",
@@ -1180,6 +1359,73 @@ async function runComplianceSuite(url, options = {}) {
       details: match ? `Request id=${res.requestId}, response id=${body.id} (match)` : `Request id=${res.requestId}, response id=${body.id} (MISMATCH)`
     };
   });
+  await test("lifecycle-string-id", "Supports string request IDs", "lifecycle", false, "basic", async () => {
+    const stringId = "compliance-test-string-id";
+    const body = JSON.stringify({ jsonrpc: "2.0", id: stringId, method: "ping", params: {} });
+    const res = await request(backendUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+        ...buildHeaders()
+      },
+      body,
+      signal: AbortSignal.timeout(timeout)
+    });
+    const text = await res.body.text();
+    const rawCtStr = res.headers["content-type"];
+    const ct = (Array.isArray(rawCtStr) ? rawCtStr[0] : rawCtStr || "").toLowerCase();
+    let parsed;
+    if (ct.includes("text/event-stream")) {
+      parsed = parseSSEResponse(text);
+    }
+    if (!parsed) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+      }
+    }
+    if (!parsed) return { passed: false, details: "Could not parse response" };
+    if (parsed.id === stringId) {
+      return { passed: true, details: `String id="${stringId}" echoed back correctly` };
+    }
+    if (parsed.id === void 0) {
+      return { passed: false, details: "No id in response" };
+    }
+    return {
+      passed: false,
+      details: `String id="${stringId}" sent, got back id=${JSON.stringify(parsed.id)} (type: ${typeof parsed.id})`
+    };
+  });
+  await test(
+    "lifecycle-reinit-reject",
+    "Rejects second initialize request",
+    "lifecycle",
+    false,
+    "basic/lifecycle#initialization",
+    async () => {
+      try {
+        const res = await rpc("initialize", {
+          protocolVersion: SPEC_VERSION,
+          capabilities: {},
+          clientInfo: { name: "mcp-compliance", version: TOOL_VERSION }
+        });
+        const error = res.body?.error;
+        if (error) {
+          return { passed: true, details: `Re-initialization rejected with error: ${error.code} \u2014 ${error.message}` };
+        }
+        if (res.statusCode >= 400) {
+          return { passed: true, details: `HTTP ${res.statusCode} (re-initialization rejected)` };
+        }
+        return {
+          passed: false,
+          details: `Server accepted second initialize (HTTP ${res.statusCode}) \u2014 should reject duplicate initialization`
+        };
+      } catch {
+        return { passed: true, details: "Connection rejected (acceptable)" };
+      }
+    }
+  );
   const hasLogging = !!serverInfo.capabilities.logging;
   await test(
     "lifecycle-logging",
@@ -1254,7 +1500,7 @@ async function runComplianceSuite(url, options = {}) {
   );
   await test(
     "lifecycle-progress",
-    "Accepts progress notifications",
+    "Handles progress notifications gracefully",
     "lifecycle",
     false,
     "basic/utilities#progress",
@@ -1267,9 +1513,96 @@ async function runComplianceSuite(url, options = {}) {
         timeout
       );
       if (res.statusCode >= 200 && res.statusCode < 300) {
-        return { passed: true, details: `HTTP ${res.statusCode} (progress notification accepted)` };
+        return { passed: true, details: `HTTP ${res.statusCode} (notification handled gracefully)` };
+      }
+      return {
+        passed: false,
+        details: `HTTP ${res.statusCode} \u2014 server should accept unknown notifications without error`
+      };
+    }
+  );
+  await test(
+    "lifecycle-list-changed",
+    "Accepts listChanged notifications",
+    "lifecycle",
+    false,
+    "basic/lifecycle#capability-negotiation",
+    async () => {
+      const notifications = [
+        { method: "notifications/tools/list_changed", gate: hasTools },
+        { method: "notifications/resources/list_changed", gate: hasResources },
+        { method: "notifications/prompts/list_changed", gate: hasPrompts }
+      ];
+      const applicable = notifications.filter((n) => n.gate);
+      if (applicable.length === 0) {
+        return { passed: true, details: "No capabilities declared \u2014 listChanged notifications not applicable" };
+      }
+      const issues = [];
+      for (const { method } of applicable) {
+        try {
+          const res = await mcpNotification(backendUrl, method, void 0, buildHeaders(), timeout);
+          if (res.statusCode < 200 || res.statusCode >= 300) {
+            issues.push(`${method}: HTTP ${res.statusCode}`);
+          }
+        } catch (err) {
+          issues.push(`${method}: ${err instanceof Error ? err.message : "error"}`);
+        }
+      }
+      if (issues.length > 0) return { passed: false, details: issues.join("; ") };
+      return {
+        passed: true,
+        details: `${applicable.length} listChanged notification(s) accepted: ${applicable.map((n) => n.method).join(", ")}`
+      };
+    }
+  );
+  await test(
+    "lifecycle-progress-token",
+    "Supports progress tokens in requests",
+    "lifecycle",
+    false,
+    "basic/utilities#progress",
+    async () => {
+      if (!hasTools || toolNames.length === 0) {
+        return { passed: true, details: "No tools available for progress token test (skipped)" };
+      }
+      const progressToken = "compliance-progress-test";
+      const reqBody = JSON.stringify({
+        jsonrpc: "2.0",
+        id: nextId(),
+        method: "tools/call",
+        params: {
+          name: toolNames[0],
+          arguments: {},
+          _meta: { progressToken }
+        }
+      });
+      try {
+        const res = await request(backendUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "text/event-stream",
+            ...buildHeaders()
+          },
+          body: reqBody,
+          signal: AbortSignal.timeout(timeout)
+        });
+        const text = await res.body.text();
+        const rawCtProgress = res.headers["content-type"];
+        const ct = (Array.isArray(rawCtProgress) ? rawCtProgress[0] : rawCtProgress || "").toLowerCase();
+        if (ct.includes("text/event-stream") && text.includes("notifications/progress")) {
+          return { passed: true, details: "Server sent progress notifications via SSE with progressToken" };
+        }
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          return {
+            passed: true,
+            details: "Server accepted request with progressToken (no progress events observed \u2014 optional)"
+          };
+        }
+        return { passed: true, details: `HTTP ${res.statusCode} \u2014 request with progressToken accepted` };
+      } catch {
+        return { passed: true, details: "Request with progressToken handled (no progress events observed \u2014 optional)" };
       }
-      return { passed: false, details: `HTTP ${res.statusCode} \u2014 server should accept progress notifications` };
     }
   );
   await test(
@@ -1311,7 +1644,11 @@ async function runComplianceSuite(url, options = {}) {
         return { passed: true, details: "HTTP 202 Accepted (correct)" };
       }
       if (res.statusCode >= 200 && res.statusCode < 300) {
-        return { passed: true, details: `HTTP ${res.statusCode} (accepted, but 202 is preferred)` };
+        warnings.push(`Notification returned HTTP ${res.statusCode} instead of spec-required 202 Accepted`);
+        return {
+          passed: false,
+          details: `HTTP ${res.statusCode} \u2014 spec requires 202 Accepted for notifications (MUST)`
+        };
       }
       return { passed: false, details: `HTTP ${res.statusCode} \u2014 expected 202 Accepted for notifications` };
     }
@@ -1342,6 +1679,34 @@ async function runComplianceSuite(url, options = {}) {
       return { passed: false, details: `HTTP ${res.statusCode}` };
     }
   );
+  await test(
+    "transport-session-invalid",
+    "Returns 404 for unknown session ID",
+    "transport",
+    false,
+    "basic/transports#streamable-http",
+    async () => {
+      if (!sessionId) {
+        return { passed: true, details: "Server did not issue session ID (test not applicable)" };
+      }
+      const fakeHeaders = {
+        ...userHeaders,
+        "mcp-session-id": "invalid-nonexistent-session-id"
+      };
+      if (negotiatedProtocolVersion) fakeHeaders["mcp-protocol-version"] = negotiatedProtocolVersion;
+      const res = await mcpRequest(backendUrl, "ping", void 0, createIdCounter(99915), fakeHeaders, timeout);
+      if (res.statusCode === 404) {
+        return { passed: true, details: "HTTP 404 for unknown session ID (correct per spec)" };
+      }
+      if (res.statusCode === 400) {
+        return {
+          passed: false,
+          details: "HTTP 400 \u2014 spec requires 404 (Not Found) for unrecognized session IDs, not 400"
+        };
+      }
+      return { passed: false, details: `HTTP ${res.statusCode} \u2014 spec requires 404 for unrecognized MCP-Session-Id` };
+    }
+  );
   await test(
     "transport-get-stream",
     "GET with session returns SSE or 405",
@@ -1358,7 +1723,8 @@ async function runComplianceSuite(url, options = {}) {
         signal: AbortSignal.timeout(Math.min(timeout, 3e3))
       });
       const body = await res.body.text();
-      const ct = (res.headers["content-type"] || "").toLowerCase();
+      const rawCt2 = res.headers["content-type"];
+      const ct = (Array.isArray(rawCt2) ? rawCt2[0] : rawCt2 || "").toLowerCase();
       if (res.statusCode === 405) {
         return { passed: true, details: "HTTP 405 (server does not support server-initiated messages)" };
       }
@@ -1397,7 +1763,8 @@ async function runComplianceSuite(url, options = {}) {
           signal: AbortSignal.timeout(timeout)
         }).then(async (res) => {
           const text = await res.body.text();
-          const ct = (res.headers["content-type"] || "").toLowerCase();
+          const rawCtConcurrent = res.headers["content-type"];
+          const ct = (Array.isArray(rawCtConcurrent) ? rawCtConcurrent[0] : rawCtConcurrent || "").toLowerCase();
           let body;
           if (ct.includes("text/event-stream")) {
             body = parseSSEResponse(text);
@@ -1424,6 +1791,42 @@ async function runComplianceSuite(url, options = {}) {
       return { passed: true, details: `${results.length} concurrent requests handled correctly` };
     }
   );
+  await test(
+    "transport-sse-event-field",
+    "SSE responses include event: message",
+    "transport",
+    false,
+    "basic/transports#streamable-http",
+    async () => {
+      const res = await request(backendUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream",
+          ...buildHeaders()
+        },
+        body: JSON.stringify({ jsonrpc: "2.0", id: createIdCounter(99940)(), method: "ping" }),
+        signal: AbortSignal.timeout(timeout)
+      });
+      const text = await res.body.text();
+      const rawCtSse = res.headers["content-type"];
+      const ct = (Array.isArray(rawCtSse) ? rawCtSse[0] : rawCtSse || "").toLowerCase();
+      if (!ct.includes("text/event-stream")) {
+        return { passed: true, details: "Server responded with JSON (not SSE) \u2014 event field check not applicable" };
+      }
+      const hasEventMessage = /^event:\s*message\s*$/m.test(text);
+      if (hasEventMessage) {
+        return { passed: true, details: "SSE response includes required event: message field" };
+      }
+      if (text.includes("data:")) {
+        return {
+          passed: false,
+          details: "SSE response has data: fields but missing required event: message field (spec: MUST include event: message)"
+        };
+      }
+      return { passed: true, details: "SSE response empty or no data fields \u2014 check not applicable" };
+    }
+  );
   const hasTools = !!serverInfo.capabilities.tools;
   let cachedToolsList = null;
   await test(
@@ -1505,9 +1908,6 @@ async function runComplianceSuite(url, options = {}) {
             issues.push(`${tool.name}: annotations.${field} should be boolean, got ${typeof ann[field]}`);
           }
         }
-        if (ann.title !== void 0 && typeof ann.title !== "string") {
-          issues.push(`${tool.name}: annotations.title should be string`);
-        }
       }
       if (issues.length > 0) return { passed: false, details: issues.join("; ") };
       return {
@@ -2055,6 +2455,63 @@ async function runComplianceSuite(url, options = {}) {
     }
     return { passed: false, details: `HTTP ${res.statusCode} \u2014 expected error code -32600` };
   });
+  const undeclaredMethods = [
+    { method: "tools/list", capability: "tools", declared: hasTools },
+    { method: "resources/list", capability: "resources", declared: hasResources },
+    { method: "prompts/list", capability: "prompts", declared: hasPrompts }
+  ];
+  const undeclared = undeclaredMethods.filter((m) => !m.declared);
+  await test(
+    "error-capability-gated",
+    "Rejects methods for undeclared capabilities",
+    "errors",
+    false,
+    "basic/lifecycle#capability-negotiation",
+    async () => {
+      if (undeclared.length === 0) {
+        return {
+          passed: true,
+          details: "Server declares all capabilities (tools, resources, prompts) \u2014 no undeclared methods to test"
+        };
+      }
+      const issues = [];
+      for (const { method, capability } of undeclared) {
+        const res = await rpc(method);
+        const error = res.body?.error;
+        if (!error && res.body?.result) {
+          issues.push(`${method} returned success despite missing ${capability} capability`);
+        }
+      }
+      if (issues.length > 0) return { passed: false, details: issues.join("; ") };
+      return {
+        passed: true,
+        details: `Tested ${undeclared.length} undeclared method(s): ${undeclared.map((m) => m.method).join(", ")} \u2014 all returned errors`
+      };
+    }
+  );
+  const listMethodForCursor = hasTools ? "tools/list" : hasResources ? "resources/list" : hasPrompts ? "prompts/list" : null;
+  await test(
+    "error-invalid-cursor",
+    "Handles invalid pagination cursor gracefully",
+    "errors",
+    false,
+    "basic",
+    async () => {
+      if (!listMethodForCursor) {
+        return { passed: true, details: "No list methods available to test (skipped)" };
+      }
+      const res = await rpc(listMethodForCursor, { cursor: "!!!invalid-garbage-cursor-$$$" });
+      const error = res.body?.error;
+      if (error) {
+        return { passed: true, details: `Invalid cursor rejected with error: ${error.code} \u2014 ${error.message}` };
+      }
+      const result = res.body?.result;
+      if (result) {
+        return { passed: true, details: "Server returned results (likely ignored invalid cursor)" };
+      }
+      return { passed: false, details: "No error or result for invalid cursor" };
+    }
+  );
   const hasAuth = !!userHeaders.Authorization || !!userHeaders.authorization;
   await test(
     "security-auth-required",
@@ -2082,6 +2539,39 @@ async function runComplianceSuite(url, options = {}) {
       }
     }
   );
+  await test(
+    "security-www-authenticate",
+    "401 responses include WWW-Authenticate header",
+    "security",
+    false,
+    "basic/authorization",
+    async () => {
+      if (!hasAuth) {
+        return { passed: true, details: "Skipped: server does not require auth" };
+      }
+      const noAuthHeaders = {};
+      if (sessionId) noAuthHeaders["mcp-session-id"] = sessionId;
+      try {
+        const res = await mcpRequest(backendUrl, "ping", void 0, nextId, noAuthHeaders, timeout);
+        if (res.statusCode === 401) {
+          const wwwAuth = res.headers["www-authenticate"];
+          if (wwwAuth) {
+            return { passed: true, details: `WWW-Authenticate: ${wwwAuth}` };
+          }
+          return {
+            passed: false,
+            details: "HTTP 401 but missing WWW-Authenticate header (spec: SHOULD include to indicate required auth scheme)"
+          };
+        }
+        if (res.statusCode === 403) {
+          return { passed: true, details: "HTTP 403 (WWW-Authenticate not applicable for 403)" };
+        }
+        return { passed: true, details: `HTTP ${res.statusCode} \u2014 not a 401 response` };
+      } catch {
+        return { passed: true, details: "Connection rejected (acceptable)" };
+      }
+    }
+  );
   await test(
     "security-auth-malformed",
     "Rejects malformed auth credentials",
@@ -2199,7 +2689,7 @@ async function runComplianceSuite(url, options = {}) {
   );
   await test(
     "security-oauth-metadata",
-    "OAuth metadata endpoint exists",
+    "Protected Resource Metadata endpoint exists",
     "security",
     false,
     "basic/authorization",
@@ -2208,9 +2698,9 @@ async function runComplianceSuite(url, options = {}) {
         return { passed: true, details: "Skipped: server does not require auth" };
       }
       const parsedUrl = new URL(url);
-      const metadataUrl = `${parsedUrl.protocol}//${parsedUrl.host}/.well-known/oauth-authorization-server`;
+      const prmUrl = `${parsedUrl.protocol}//${parsedUrl.host}/.well-known/oauth-protected-resource`;
       try {
-        const res = await request(metadataUrl, {
+        const res = await request(prmUrl, {
           method: "GET",
           headers: { Accept: "application/json" },
           signal: AbortSignal.timeout(Math.min(timeout, 5e3))
@@ -2219,20 +2709,51 @@ async function runComplianceSuite(url, options = {}) {
         if (res.statusCode === 200) {
           try {
             const meta = JSON.parse(text);
-            if (meta.issuer && meta.token_endpoint) {
-              return { passed: true, details: `OAuth metadata found: issuer=${meta.issuer}` };
+            if (!meta.resource) {
+              return { passed: false, details: "PRM response missing required 'resource' field" };
+            }
+            if (!Array.isArray(meta.authorization_servers) || meta.authorization_servers.length === 0) {
+              return { passed: false, details: "PRM response missing 'authorization_servers' array" };
             }
             return {
-              passed: false,
-              details: "OAuth metadata response missing required fields (issuer, token_endpoint)"
+              passed: true,
+              details: `Protected Resource Metadata found: resource=${meta.resource}, ${meta.authorization_servers.length} auth server(s)`
             };
           } catch {
-            return { passed: false, details: "OAuth metadata endpoint returned non-JSON response" };
+            return { passed: false, details: "PRM endpoint returned non-JSON response" };
           }
         }
-        return { passed: false, details: `OAuth metadata endpoint returned HTTP ${res.statusCode}` };
+        const legacyUrl = `${parsedUrl.protocol}//${parsedUrl.host}/.well-known/oauth-authorization-server`;
+        try {
+          const legacyRes = await request(legacyUrl, {
+            method: "GET",
+            headers: { Accept: "application/json" },
+            signal: AbortSignal.timeout(Math.min(timeout, 5e3))
+          });
+          const legacyText = await legacyRes.body.text();
+          if (legacyRes.statusCode === 200) {
+            try {
+              const legacyMeta = JSON.parse(legacyText);
+              if (legacyMeta.issuer && legacyMeta.token_endpoint) {
+                warnings.push(
+                  "Server uses legacy /.well-known/oauth-authorization-server instead of /.well-known/oauth-protected-resource (RFC 9728). Update to PRM for 2025-11-25 compliance."
+                );
+                return {
+                  passed: true,
+                  details: `Legacy OAuth AS metadata found: issuer=${legacyMeta.issuer} (should migrate to PRM)`
+                };
+              }
+            } catch {
+            }
+          }
+        } catch {
+        }
+        return {
+          passed: false,
+          details: `PRM endpoint returned HTTP ${res.statusCode} and no legacy OAuth metadata found`
+        };
       } catch {
-        return { passed: false, details: "OAuth metadata endpoint unreachable" };
+        return { passed: false, details: "PRM endpoint unreachable" };
       }
     }
   );
@@ -2308,6 +2829,44 @@ async function runComplianceSuite(url, options = {}) {
       }
     }
   );
+  await test(
+    "security-origin-validation",
+    "Validates Origin header on requests",
+    "security",
+    false,
+    "basic/transports#streamable-http",
+    async () => {
+      try {
+        const res = await request(backendUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            Origin: "https://evil-rebinding-attack.example.com",
+            ...buildHeaders()
+          },
+          body: JSON.stringify({ jsonrpc: "2.0", id: createIdCounter(99970)(), method: "ping" }),
+          signal: AbortSignal.timeout(timeout)
+        });
+        await res.body.text();
+        if (res.statusCode === 403 || res.statusCode === 401) {
+          return { passed: true, details: `HTTP ${res.statusCode} (suspicious Origin rejected)` };
+        }
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          return {
+            passed: false,
+            details: `HTTP ${res.statusCode} \u2014 server accepted request with untrusted Origin header (spec: MUST validate Origin for DNS rebinding protection)`
+          };
+        }
+        if (res.statusCode >= 400) {
+          return { passed: true, details: `HTTP ${res.statusCode} (suspicious Origin rejected)` };
+        }
+        return { passed: false, details: `HTTP ${res.statusCode}` };
+      } catch {
+        return { passed: true, details: "Connection rejected (acceptable)" };
+      }
+    }
+  );
   async function runInjectionTest(toolName, paramName, payloads, detectPattern, label) {
     const issues = [];
     for (const payload of payloads) {