@yawlabs/mcp-compliance 0.9.0 → 0.9.2

package/dist/chunk-FKTEFLK5.js

@@ -0,0 +1,3914 @@
+// src/runner.ts
+import { createRequire } from "module";
+import { request as request2 } from "undici";
+
+// src/badge.ts
+import { createHash } from "crypto";
+function urlHash(url) {
+  return createHash("sha256").update(url).digest("hex").slice(0, 12);
+}
+function generateBadge(url) {
+  const hash = urlHash(url);
+  const imageUrl = `https://mcp.hosting/api/compliance/ext/${hash}/badge`;
+  const reportUrl = `https://mcp.hosting/compliance/ext/${hash}`;
+  return {
+    imageUrl,
+    reportUrl,
+    markdown: `[![MCP Compliant](${imageUrl})](${reportUrl})`,
+    html: `<a href="${reportUrl}"><img src="${imageUrl}" alt="MCP Compliant"></a>`
+  };
+}
+
+// src/grader.ts
+function computeGrade(score) {
+  if (score >= 90) return "A";
+  if (score >= 75) return "B";
+  if (score >= 60) return "C";
+  if (score >= 40) return "D";
+  return "F";
+}
+function computeScore(tests) {
+  const total = tests.length;
+  const passed = tests.filter((t) => t.passed).length;
+  const failed = total - passed;
+  const requiredTests = tests.filter((t) => t.required);
+  const requiredPassed = requiredTests.filter((t) => t.passed).length;
+  const requiredScore = requiredTests.length > 0 ? requiredPassed / requiredTests.length * 70 : 70;
+  const optionalTests = tests.filter((t) => !t.required);
+  const optionalPassed = optionalTests.filter((t) => t.passed).length;
+  const optionalScore = optionalTests.length > 0 ? optionalPassed / optionalTests.length * 30 : 30;
+  const score = Math.round(requiredScore + optionalScore);
+  const overall = requiredPassed === requiredTests.length ? passed === total ? "pass" : "partial" : "fail";
+  const categories = {};
+  for (const t of tests) {
+    if (!categories[t.category]) categories[t.category] = { passed: 0, total: 0 };
+    categories[t.category].total++;
+    if (t.passed) categories[t.category].passed++;
+  }
+  return {
+    score,
+    grade: computeGrade(score),
+    overall,
+    summary: { total, passed, failed, required: requiredTests.length, requiredPassed },
+    categories
+  };
+}
+
+// src/transport/http.ts
+import { request } from "undici";
+
+// src/sse.ts
+function parseSSEResponse(text) {
+  const lines = text.split("\n");
+  let firstJsonRpcResponse = null;
+  let currentData = [];
+  function flushEvent() {
+    if (currentData.length === 0) return;
+    const data = currentData.join("\n");
+    currentData = [];
+    if (!data.trim()) return;
+    try {
+      const parsed = JSON.parse(data);
+      if (!firstJsonRpcResponse && parsed.jsonrpc === "2.0" && parsed.id !== void 0) {
+        firstJsonRpcResponse = parsed;
+      }
+    } catch {
+    }
+  }
+  for (const line of lines) {
+    if (line.startsWith("data:")) {
+      const content = line.slice(5);
+      currentData.push(content.startsWith(" ") ? content.slice(1) : content);
+    } else if (line.trim() === "") {
+      flushEvent();
+    }
+  }
+  flushEvent();
+  return firstJsonRpcResponse;
+}
+
+// src/transport/http.ts
+function createHttpTransport(opts) {
+  const { url } = opts;
+  const userHeaders = { ...opts.headers ?? {} };
+  let sessionId = null;
+  let protocolVersion = null;
+  function sessionHeaders() {
+    const h = { ...userHeaders };
+    if (sessionId) h["mcp-session-id"] = sessionId;
+    if (protocolVersion) h["mcp-protocol-version"] = protocolVersion;
+    return h;
+  }
+  function normalizeHeaders(raw) {
+    const out = {};
+    for (const [k, v] of Object.entries(raw)) {
+      if (typeof v === "string") out[k] = v;
+    }
+    return out;
+  }
+  async function doRawRequest(method, body, extraHeaders, timeout) {
+    const headers = {
+      Accept: "application/json, text/event-stream",
+      ...sessionHeaders(),
+      ...extraHeaders
+    };
+    if (body !== void 0 && !("Content-Type" in headers) && !("content-type" in headers)) {
+      headers["Content-Type"] = "application/json";
+    }
+    const res = await request(url, {
+      method,
+      headers,
+      body,
+      signal: AbortSignal.timeout(timeout)
+    });
+    const text = await res.body.text();
+    return {
+      statusCode: res.statusCode,
+      body: text,
+      headers: normalizeHeaders(res.headers)
+    };
+  }
+  const transport = {
+    kind: "http",
+    url,
+    async request(method, params, nextId, init) {
+      const id = nextId();
+      const body = JSON.stringify({ jsonrpc: "2.0", id, method, params: params ?? {} });
+      const raw = await doRawRequest("POST", body, init.headers ?? {}, init.timeout);
+      const contentType = (raw.headers["content-type"] || "").toLowerCase();
+      let parsed;
+      if (contentType.includes("text/event-stream")) {
+        const sseParsed = parseSSEResponse(raw.body);
+        if (sseParsed) {
+          parsed = sseParsed;
+        } else {
+          try {
+            parsed = JSON.parse(raw.body);
+          } catch {
+            parsed = { _raw: raw.body };
+          }
+        }
+      } else {
+        try {
+          parsed = JSON.parse(raw.body);
+        } catch {
+          parsed = { _raw: raw.body };
+        }
+      }
+      return {
+        body: parsed,
+        requestId: id,
+        statusCode: raw.statusCode,
+        headers: raw.headers
+      };
+    },
+    async notify(method, params, init) {
+      const body = JSON.stringify({ jsonrpc: "2.0", method, ...params ? { params } : {} });
+      const raw = await doRawRequest("POST", body, init.headers ?? {}, init.timeout);
+      return { statusCode: raw.statusCode, headers: raw.headers };
+    },
+    async close() {
+    },
+    setSessionId(id) {
+      sessionId = id;
+    },
+    setProtocolVersion(v) {
+      protocolVersion = v;
+    },
+    getSessionId() {
+      return sessionId;
+    },
+    getProtocolVersion() {
+      return protocolVersion;
+    },
+    rawPost(body, extraHeaders, timeout) {
+      return doRawRequest("POST", body, extraHeaders, timeout);
+    },
+    rawRequest(method, body, extraHeaders, timeout) {
+      return doRawRequest(method, body, extraHeaders, timeout);
+    }
+  };
+  return transport;
+}
+
+// src/transport/stdio.ts
+import { spawn } from "child_process";
+function createStdioTransport(opts) {
+  const { command, args = [], env, cwd, verbose = false } = opts;
+  const stderrBufferSize = opts.stderrBufferSize ?? 64 * 1024;
+  const stdoutBufferSize = opts.stdoutBufferSize ?? 1024 * 1024;
+  const isWindows = process.platform === "win32";
+  const child = spawn(command, args, {
+    env: env ? { ...process.env, ...env } : process.env,
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    // Windows .cmd/.bat shims (npx, npm) need shell:true to launch.
+    shell: isWindows
+  });
+  let protocolVersion = null;
+  let exited = false;
+  let exitCode = null;
+  let spawnError = null;
+  const pending = /* @__PURE__ */ new Map();
+  let stdoutBuffer = "";
+  let stderrBuffer = "";
+  child.on("error", (err) => {
+    spawnError = err;
+    rejectAllPending(err);
+  });
+  child.on("exit", (code, signal) => {
+    exited = true;
+    exitCode = code;
+    if (pending.size > 0) {
+      const reason = signal ? `child exited (signal ${signal})` : `child exited with code ${code}`;
+      rejectAllPending(new Error(reason));
+    }
+  });
+  child.stdout?.setEncoding("utf8");
+  child.stdout?.on("data", (chunk) => {
+    stdoutBuffer += chunk;
+    let idx;
+    while ((idx = stdoutBuffer.indexOf("\n")) !== -1) {
+      const line = stdoutBuffer.slice(0, idx);
+      stdoutBuffer = stdoutBuffer.slice(idx + 1);
+      handleLine(line);
+    }
+    if (stdoutBuffer.length > stdoutBufferSize) {
+      stdoutBuffer = "";
+    }
+  });
+  child.stderr?.setEncoding("utf8");
+  child.stderr?.on("data", (chunk) => {
+    if (verbose) process.stderr.write(chunk);
+    stderrBuffer += chunk;
+    if (stderrBuffer.length > stderrBufferSize) {
+      stderrBuffer = stderrBuffer.slice(stderrBuffer.length - stderrBufferSize);
+    }
+  });
+  function handleLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    if (!parsed || typeof parsed !== "object") return;
+    const msg = parsed;
+    if (typeof msg.id === "number" && pending.has(msg.id)) {
+      const p = pending.get(msg.id);
+      if (!p) return;
+      clearTimeout(p.timer);
+      pending.delete(msg.id);
+      p.resolve({ body: parsed, requestId: msg.id });
+    }
+  }
+  function rejectAllPending(err) {
+    const annotated = err.message.includes("child stderr") ? err : new Error(annotateWithStderr(err.message));
+    for (const p of pending.values()) {
+      clearTimeout(p.timer);
+      p.reject(annotated);
+    }
+    pending.clear();
+  }
+  function annotateWithStderr(message) {
+    const tail = stderrBuffer.trim();
+    if (!tail) return message;
+    const snippet = tail.length > 800 ? `\u2026${tail.slice(-800)}` : tail;
+    return `${message}
+  child stderr:
+    ${snippet.replace(/\n/g, "\n    ")}`;
+  }
+  async function writeLine(line) {
+    if (exited) {
+      throw new Error(annotateWithStderr(`stdio transport: child has exited (code ${exitCode})`));
+    }
+    if (spawnError) throw new Error(annotateWithStderr(`stdio transport: spawn failed \u2014 ${spawnError.message}`));
+    const stdin = child.stdin;
+    if (!stdin || stdin.destroyed) throw new Error(annotateWithStderr("stdio transport: stdin is closed"));
+    return new Promise((resolve, reject) => {
+      stdin.write(`${line}
+`, "utf8", (err) => err ? reject(err) : resolve());
+    });
+  }
+  const transport = {
+    kind: "stdio",
+    command,
+    args,
+    get pid() {
+      return child.pid;
+    },
+    get exited() {
+      return exited;
+    },
+    get exitCode() {
+      return exitCode;
+    },
+    stderrTail() {
+      return stderrBuffer;
+    },
+    async request(method, params, nextId, init) {
+      const id = nextId();
+      const body = JSON.stringify({ jsonrpc: "2.0", id, method, params: params ?? {} });
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          reject(
+            new Error(
+              annotateWithStderr(`stdio transport: request timed out after ${init.timeout}ms (method=${method})`)
+            )
+          );
+        }, init.timeout);
+        pending.set(id, { resolve, reject, id, timer });
+        writeLine(body).catch((err) => {
+          clearTimeout(timer);
+          pending.delete(id);
+          reject(err);
+        });
+      });
+    },
+    async notify(method, params, _init) {
+      const body = JSON.stringify({ jsonrpc: "2.0", method, ...params ? { params } : {} });
+      await writeLine(body);
+      return {};
+    },
+    async close() {
+      if (exited) return;
+      try {
+        child.stdin?.end();
+      } catch {
+      }
+      const gracePeriodMs = 2e3;
+      await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+          resolve();
+        }, gracePeriodMs);
+        child.once("exit", () => {
+          clearTimeout(timer);
+          resolve();
+        });
+        try {
+          child.kill(isWindows ? void 0 : "SIGTERM");
+        } catch {
+        }
+      });
+      rejectAllPending(new Error("stdio transport: closed"));
+    },
+    setSessionId(_id) {
+    },
+    setProtocolVersion(v) {
+      protocolVersion = v;
+    },
+    getSessionId() {
+      return null;
+    },
+    getProtocolVersion() {
+      return protocolVersion;
+    }
+  };
+  return transport;
+}
+
+// src/types.ts
+var TEST_DEFINITIONS = [
+  // ── Transport (13 tests) ─────────────────────────────────────────
+  {
+    id: "transport-post",
+    name: "HTTP POST accepted",
+    category: "transport",
+    required: true,
+    specRef: "basic/transports#streamable-http",
+    description: "Verifies the server accepts HTTP POST requests and returns a 2xx status code. This is the fundamental transport requirement for Streamable HTTP MCP servers.",
+    recommendation: "Ensure your server listens for POST requests on the MCP endpoint. If you see 401/403, pass --auth with a valid token. Check that the URL is correct and the server is running."
+  },
+  {
+    id: "transport-content-type",
+    name: "Responds with JSON or SSE",
+    category: "transport",
+    required: true,
+    specRef: "basic/transports#streamable-http",
+    description: "Checks that the server responds with Content-Type application/json or text/event-stream. MCP servers must use one of these two content types.",
+    recommendation: 'Set the Content-Type response header to "application/json" for synchronous responses or "text/event-stream" for streaming. Do not use text/html or other types.'
+  },
+  {
+    id: "transport-notification-202",
+    name: "Notification returns 202 Accepted",
+    category: "transport",
+    required: false,
+    specRef: "basic/transports#streamable-http",
+    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",
+    name: "Enforces MCP-Session-Id after init",
+    category: "transport",
+    required: false,
+    specRef: "basic/transports#streamable-http",
+    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",
+    category: "transport",
+    required: false,
+    specRef: "basic/transports#streamable-http",
+    description: "Tests the GET endpoint for server-initiated messages. Server should return text/event-stream or 405 Method Not Allowed.",
+    recommendation: "If your server supports server-initiated messages, handle GET with text/event-stream. Otherwise, return 405 Method Not Allowed."
+  },
+  {
+    id: "transport-delete",
+    name: "DELETE accepted or returns 405",
+    category: "transport",
+    required: false,
+    specRef: "basic/transports#streamable-http",
+    description: "Tests the DELETE endpoint for session termination. Server should accept the request or return 405 Method Not Allowed.",
+    recommendation: "Handle DELETE requests for session cleanup, or return 405 if session termination is not supported. Do not return 500."
+  },
+  {
+    id: "transport-batch-reject",
+    name: "Rejects JSON-RPC batch requests",
+    category: "transport",
+    required: true,
+    specRef: "basic/transports#streamable-http",
+    description: "Sends a JSON-RPC batch request (array of messages) and verifies the server rejects it with an error. MCP does not support JSON-RPC batch requests.",
+    recommendation: "Check if the parsed JSON body is an array. If so, return a JSON-RPC error or HTTP 400. Do not process batch requests \u2014 MCP explicitly forbids them."
+  },
+  {
+    id: "transport-content-type-init",
+    name: "Initialize response has valid content type",
+    category: "transport",
+    required: false,
+    specRef: "basic/transports#streamable-http",
+    description: "Validates that the initialize response uses application/json or text/event-stream content type. Some servers return other types for the handshake.",
+    recommendation: 'Ensure the initialize response uses Content-Type "application/json" or "text/event-stream". Do not return text/html or other types for JSON-RPC responses.'
+  },
+  {
+    id: "transport-get-stream",
+    name: "GET with session returns SSE or 405",
+    category: "transport",
+    required: false,
+    specRef: "basic/transports#streamable-http",
+    description: "Tests the GET endpoint with an active session ID for server-initiated messages. After initialization, the server should either return an SSE stream or 405.",
+    recommendation: "If your server supports server-initiated messages, return text/event-stream on GET with a valid session ID. Otherwise, return 405 Method Not Allowed."
+  },
+  {
+    id: "transport-concurrent",
+    name: "Handles concurrent requests",
+    category: "transport",
+    required: false,
+    specRef: "basic/transports#streamable-http",
+    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."
+  },
+  {
+    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.'
+  },
+  // ── Stdio transport (stdio-only) ─────────────────────────────────
+  {
+    id: "stdio-framing",
+    name: "Newline-delimited JSON framing",
+    category: "transport",
+    required: true,
+    specRef: "basic/transports#stdio",
+    description: "Fires several JSON-RPC requests in rapid succession and verifies the server frames each response with a trailing newline per the MCP stdio transport spec.",
+    recommendation: "Emit one JSON message per line on stdout, terminated by \\n. Do not split a single message across multiple lines or merge multiple messages onto one line.",
+    transports: ["stdio"]
+  },
+  {
+    id: "stdio-unicode",
+    name: "UTF-8 unicode roundtrip",
+    category: "transport",
+    required: false,
+    specRef: "basic/transports#stdio",
+    description: "Sends a request with non-ASCII (CJK + emoji) parameters and verifies the response preserves the characters. Catches byte-level encoding mistakes in framing/parsing.",
+    recommendation: "Decode stdin as UTF-8 and encode stdout as UTF-8. Avoid latin-1 or platform-default encodings on Windows. Most JSON libraries handle this correctly if you don't override defaults.",
+    transports: ["stdio"]
+  },
+  {
+    id: "stdio-unknown-method-recovers",
+    name: "Recovers after unknown method",
+    category: "transport",
+    required: false,
+    specRef: "basic/transports#stdio",
+    description: "Sends an unknown method, then a valid ping immediately after. Verifies the server returns a JSON-RPC error for the unknown method and continues serving the subsequent request without crashing.",
+    recommendation: "Return JSON-RPC error -32601 (Method not found) for unknown methods. Do not exit the process or disconnect \u2014 the client should be able to keep using the session after an error.",
+    transports: ["stdio"]
+  },
+  // ── Lifecycle (17 tests) ─────────────────────────────────────────
+  {
+    id: "lifecycle-init",
+    name: "Initialize handshake",
+    category: "lifecycle",
+    required: true,
+    specRef: "basic/lifecycle#initialization",
+    description: "Tests the initialize handshake by sending an initialize request with client capabilities. The server must return a result with protocolVersion.",
+    recommendation: 'Implement the "initialize" method handler. Return a result object with at least protocolVersion, capabilities, and serverInfo fields.'
+  },
+  {
+    id: "lifecycle-proto-version",
+    name: "Returns valid protocol version",
+    category: "lifecycle",
+    required: true,
+    specRef: "basic/lifecycle#version-negotiation",
+    description: "Validates that the protocolVersion returned by the server matches the YYYY-MM-DD date format required by the spec.",
+    recommendation: `Return protocolVersion as a YYYY-MM-DD string (e.g., "2025-11-25"). The server should negotiate based on the client's requested version.`
+  },
+  {
+    id: "lifecycle-server-info",
+    name: "Includes serverInfo",
+    category: "lifecycle",
+    required: false,
+    specRef: "basic/lifecycle#initialization",
+    description: "Checks that the server includes a serverInfo object with at least a name field in its initialize response. While recommended, this is not strictly required.",
+    recommendation: 'Add a serverInfo object to your initialize response: { name: "your-server", version: "1.0.0" }. This helps clients identify your server.'
+  },
+  {
+    id: "lifecycle-capabilities",
+    name: "Returns capabilities object",
+    category: "lifecycle",
+    required: true,
+    specRef: "basic/lifecycle#capability-negotiation",
+    description: "Verifies the server returns a capabilities object in its initialize response. An empty object is valid (no optional features declared).",
+    recommendation: "Include a capabilities object in your initialize response. Declare the features your server supports (tools, resources, prompts, logging, etc.). An empty object {} is valid."
+  },
+  {
+    id: "lifecycle-jsonrpc",
+    name: "Response is valid JSON-RPC 2.0",
+    category: "lifecycle",
+    required: true,
+    specRef: "basic",
+    description: 'Validates that the initialize response is a proper JSON-RPC 2.0 message with jsonrpc="2.0", an id field, and either a result or error field.',
+    recommendation: 'Ensure every response includes jsonrpc: "2.0", the matching id from the request, and either a result or error field. Never omit the jsonrpc field.'
+  },
+  {
+    id: "lifecycle-ping",
+    name: "Responds to ping",
+    category: "lifecycle",
+    required: true,
+    specRef: "basic/utilities#ping",
+    description: "Tests that the server responds to the ping method with an empty result object. This is a required utility method.",
+    recommendation: 'Implement a "ping" method handler that returns an empty result object {}. This is required by the MCP spec for keepalive and connectivity checking.'
+  },
+  {
+    id: "lifecycle-instructions",
+    name: "Instructions field is valid",
+    category: "lifecycle",
+    required: false,
+    specRef: "basic/lifecycle#initialization",
+    description: "If the server includes an instructions field in the initialize response, validates it is a string. Instructions provide guidance for how the client should interact with the server.",
+    recommendation: "If you include an instructions field in the initialize response, ensure it is a string. Remove the field or fix the type if it is not a string."
+  },
+  {
+    id: "lifecycle-id-match",
+    name: "Response ID matches request ID",
+    category: "lifecycle",
+    required: true,
+    specRef: "basic",
+    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",
+    category: "lifecycle",
+    required: false,
+    specRef: "server/utilities#logging",
+    description: "If the server declares logging capability, tests that logging/setLevel method is accepted with a valid log level.",
+    recommendation: 'If you declare logging in capabilities, implement the "logging/setLevel" handler. Accept standard log levels: debug, info, notice, warning, error, critical, alert, emergency.'
+  },
+  {
+    id: "lifecycle-completions",
+    name: "completion/complete accepted",
+    category: "lifecycle",
+    required: false,
+    specRef: "server/utilities#completion",
+    description: "If the server declares completions capability, tests that the completion/complete method is accepted.",
+    recommendation: 'If you declare completions in capabilities, implement the "completion/complete" handler. Return a completion object with a values array, even if empty.'
+  },
+  {
+    id: "lifecycle-cancellation",
+    name: "Handles cancellation notifications",
+    category: "lifecycle",
+    required: false,
+    specRef: "basic/utilities#cancellation",
+    description: "Tests that the server accepts notifications/cancelled without error. Servers should gracefully handle cancellation of unknown or completed requests.",
+    recommendation: "Accept notifications/cancelled and stop any in-progress work for the referenced requestId. If the request is unknown or already complete, silently ignore the cancellation."
+  },
+  {
+    id: "lifecycle-progress",
+    name: "Handles progress notifications gracefully",
+    category: "lifecycle",
+    required: false,
+    specRef: "basic/utilities#progress",
+    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) ──────────────────────────────────────────────
+  {
+    id: "tools-list",
+    name: "tools/list returns valid response",
+    category: "tools",
+    required: false,
+    specRef: "server/tools#listing-tools",
+    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."
+  },
+  {
+    id: "tools-call",
+    name: "tools/call responds correctly",
+    category: "tools",
+    required: false,
+    specRef: "server/tools#calling-tools",
+    description: "Calls the first tool with empty arguments and verifies the response format. Accepts both successful results and InvalidParams errors.",
+    recommendation: "Ensure tools/call returns { content: [...] } with an array of content objects, each having a type field. Return isError: true for tool execution errors."
+  },
+  {
+    id: "tools-pagination",
+    name: "tools/list supports pagination",
+    category: "tools",
+    required: false,
+    specRef: "server/tools#listing-tools",
+    description: "Tests cursor-based pagination on tools/list. Validates nextCursor is a string if present and that fetching the next page returns a valid response.",
+    recommendation: "If your server has many tools, include a nextCursor string in the response. Ensure passing this cursor back in a subsequent request returns the next page."
+  },
+  {
+    id: "tools-content-types",
+    name: "Tool content items have valid types",
+    category: "tools",
+    required: false,
+    specRef: "server/tools#calling-tools",
+    description: "Validates that content items returned by tools/call have a recognized type field (text, image, audio, resource, resource_link).",
+    recommendation: 'Every content item returned by tools/call must have a type field set to one of: "text", "image", "audio", "resource", or "resource_link". Check for typos or missing type fields.'
+  },
+  // ── Resources (5 tests) ──────────────────────────────────────────
+  {
+    id: "resources-list",
+    name: "resources/list returns valid response",
+    category: "resources",
+    required: false,
+    specRef: "server/resources#listing-resources",
+    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."
+  },
+  {
+    id: "resources-read",
+    name: "resources/read returns content",
+    category: "resources",
+    required: false,
+    specRef: "server/resources#reading-resources",
+    description: "Reads the first resource and validates the response contains a contents array with proper uri and text/blob fields.",
+    recommendation: "Implement resources/read to return { contents: [...] } where each item has a uri and either a text or blob field. Ensure the uri matches the requested resource."
+  },
+  {
+    id: "resources-templates",
+    name: "resources/templates/list returns valid response",
+    category: "resources",
+    required: false,
+    specRef: "server/resources#resource-templates",
+    description: "Tests the resource templates endpoint. Accepts Method not found (-32601) since templates are optional.",
+    recommendation: "If your server supports resource templates, implement resources/templates/list returning { resourceTemplates: [...] }. Otherwise, return error code -32601."
+  },
+  {
+    id: "resources-pagination",
+    name: "resources/list supports pagination",
+    category: "resources",
+    required: false,
+    specRef: "server/resources#listing-resources",
+    description: "Tests cursor-based pagination on resources/list. Validates nextCursor is a string if present and that fetching the next page works.",
+    recommendation: "If you return nextCursor in resources/list, ensure it is a string and that passing it back as cursor in the next request returns valid results."
+  },
+  {
+    id: "resources-subscribe",
+    name: "Resource subscribe/unsubscribe",
+    category: "resources",
+    required: false,
+    specRef: "server/resources#subscriptions",
+    description: "If the server declares resources.subscribe capability, tests that resources/subscribe and resources/unsubscribe methods are accepted.",
+    recommendation: "If you declare resources.subscribe capability, implement both resources/subscribe and resources/unsubscribe handlers. Both should accept a uri parameter."
+  },
+  // ── Prompts (3 tests) ────────────────────────────────────────────
+  {
+    id: "prompts-list",
+    name: "prompts/list returns valid response",
+    category: "prompts",
+    required: false,
+    specRef: "server/prompts#listing-prompts",
+    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."
+  },
+  {
+    id: "prompts-get",
+    name: "prompts/get returns valid messages",
+    category: "prompts",
+    required: false,
+    specRef: "server/prompts#getting-a-prompt",
+    description: "Gets the first prompt and validates the response contains a messages array with proper role and content fields.",
+    recommendation: 'Implement prompts/get to return { messages: [...] } where each message has a role ("user" or "assistant") and a content field.'
+  },
+  {
+    id: "prompts-pagination",
+    name: "prompts/list supports pagination",
+    category: "prompts",
+    required: false,
+    specRef: "server/prompts#listing-prompts",
+    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 (10 tests) ────────────────────────────────────
+  {
+    id: "error-unknown-method",
+    name: "Returns JSON-RPC error for unknown method",
+    category: "errors",
+    required: true,
+    specRef: "basic",
+    description: "Sends an unknown method and verifies the server returns a JSON-RPC error. The spec requires error code -32601 (Method not found).",
+    recommendation: "Return a JSON-RPC error with code -32601 (Method not found) for any unrecognized method name. Do not silently ignore unknown methods."
+  },
+  {
+    id: "error-method-code",
+    name: "Uses correct JSON-RPC error code for unknown method",
+    category: "errors",
+    required: false,
+    specRef: "basic",
+    description: "Checks the error code is specifically -32601 (Method not found) for unknown methods, as required by JSON-RPC 2.0.",
+    recommendation: "Use exactly error code -32601 for unknown methods. Do not use generic error codes like -32000. This is required by JSON-RPC 2.0."
+  },
+  {
+    id: "error-invalid-jsonrpc",
+    name: "Handles malformed JSON-RPC",
+    category: "errors",
+    required: true,
+    specRef: "basic",
+    description: "Sends a malformed JSON-RPC message (missing required fields) and verifies the server returns an error or 4xx status.",
+    recommendation: "Validate incoming JSON-RPC messages for required fields (jsonrpc, method). Return error code -32600 (Invalid Request) or HTTP 400 for malformed messages."
+  },
+  {
+    id: "error-invalid-json",
+    name: "Handles invalid JSON body",
+    category: "errors",
+    required: false,
+    specRef: "basic",
+    description: "Sends invalid JSON and verifies the server returns a parse error (-32700) or 4xx status code.",
+    recommendation: "Catch JSON parse errors and return error code -32700 (Parse error) with a descriptive message. Do not return 500 for malformed input."
+  },
+  {
+    id: "error-missing-params",
+    name: "Returns error for tools/call without name",
+    category: "errors",
+    required: false,
+    specRef: "server/tools#error-handling",
+    description: "Calls tools/call with an empty params object (missing required name field) and verifies an error is returned.",
+    recommendation: "Validate tools/call params and return error code -32602 (Invalid params) when the required name field is missing."
+  },
+  {
+    id: "error-parse-code",
+    name: "Returns -32700 for invalid JSON",
+    category: "errors",
+    required: false,
+    specRef: "basic",
+    description: "Checks that the server returns the specific JSON-RPC error code -32700 (Parse error) when receiving invalid JSON, as required by the JSON-RPC 2.0 specification.",
+    recommendation: "Return exactly error code -32700 for JSON parse failures. Most JSON-RPC frameworks handle this automatically \u2014 check yours does not override the code."
+  },
+  {
+    id: "error-invalid-request-code",
+    name: "Returns -32600 for invalid request",
+    category: "errors",
+    required: false,
+    specRef: "basic",
+    description: "Checks that the server returns the specific JSON-RPC error code -32600 (Invalid Request) for malformed JSON-RPC messages missing required fields.",
+    recommendation: "Return exactly error code -32600 for structurally invalid JSON-RPC messages (e.g., missing method field). Check your JSON-RPC middleware configuration."
+  },
+  {
+    id: "tools-call-unknown",
+    name: "Returns error for unknown tool name",
+    category: "errors",
+    required: false,
+    specRef: "server/tools#error-handling",
+    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",
+    name: "All tools have name and inputSchema",
+    category: "schema",
+    required: false,
+    specRef: "server/tools#data-types",
+    description: 'Validates every tool has a valid name (1-128 chars, alphanumeric/underscore/hyphen/dot) and a required inputSchema of type "object".',
+    recommendation: 'Ensure every tool has a name (1-128 chars, [A-Za-z0-9_.-]) and an inputSchema with type: "object". Add descriptions to tools for better AI assistant integration.'
+  },
+  {
+    id: "tools-annotations",
+    name: "Tool annotations are valid",
+    category: "schema",
+    required: false,
+    specRef: "server/tools#annotations",
+    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",
+    name: "Tools include title field",
+    category: "schema",
+    required: false,
+    specRef: "server/tools#data-types",
+    description: "Checks if tools include the optional title field for human-readable display names. Added in spec version 2025-11-25.",
+    recommendation: "Add a title field (human-readable string) to each tool definition. This helps MCP clients display your tools in a user-friendly way."
+  },
+  {
+    id: "tools-output-schema",
+    name: "Tools with outputSchema are valid",
+    category: "schema",
+    required: false,
+    specRef: "server/tools#structured-content",
+    description: 'If tools declare an outputSchema, validates it is a valid JSON Schema object with type "object". Used for structured output validation.',
+    recommendation: 'If you declare outputSchema on a tool, ensure it is a valid JSON Schema object with type: "object". Remove outputSchema if you do not need structured output.'
+  },
+  {
+    id: "prompts-schema",
+    name: "Prompts have name field",
+    category: "schema",
+    required: false,
+    specRef: "server/prompts#data-types",
+    description: "Validates every prompt has a name and that any arguments array contains items with name fields.",
+    recommendation: "Ensure every prompt has a name field. If the prompt has arguments, each argument object must include a name field."
+  },
+  {
+    id: "resources-schema",
+    name: "Resources have uri and name",
+    category: "schema",
+    required: false,
+    specRef: "server/resources#data-types",
+    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 (10 tests) ────────────────────────
+  {
+    id: "security-auth-required",
+    name: "Rejects unauthenticated requests",
+    category: "security",
+    required: false,
+    specRef: "basic/authorization",
+    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",
+    category: "security",
+    required: false,
+    specRef: "basic/authorization",
+    description: "Sends a request with a malformed Authorization header (garbage value) and verifies the server returns HTTP 401 or 403. Servers must validate auth tokens, not just check for presence.",
+    recommendation: "Validate the format and signature of Authorization header values. Reject malformed or invalid tokens with HTTP 401. Do not treat any non-empty Authorization header as valid."
+  },
+  {
+    id: "security-tls-required",
+    name: "Enforces HTTPS/TLS",
+    category: "security",
+    required: false,
+    specRef: "basic/authorization",
+    description: "If the server URL uses HTTPS, attempts an HTTP (plaintext) connection and verifies it is rejected or redirected. Production MCP servers should not accept plaintext connections.",
+    recommendation: "Configure your server to reject HTTP connections or redirect to HTTPS. Use TLS 1.2 or higher. The MCP spec requires HTTPS for production deployments."
+  },
+  {
+    id: "security-session-entropy",
+    name: "Session IDs are high-entropy",
+    category: "security",
+    required: false,
+    specRef: "basic/transports#streamable-http",
+    description: "Analyzes the MCP-Session-Id returned by the server. Session IDs should be cryptographically random and not sequential or predictable.",
+    recommendation: "Generate session IDs using a cryptographically secure random source (e.g., crypto.randomUUID()). Session IDs should be at least 128 bits of entropy. Do not use sequential counters or timestamps."
+  },
+  {
+    id: "security-session-not-auth",
+    name: "Session ID does not bypass auth",
+    category: "security",
+    required: false,
+    specRef: "basic/transports#streamable-http",
+    description: "Verifies that presenting a valid MCP-Session-Id without an Authorization header is still rejected. Per spec, servers MUST NOT use sessions for authentication.",
+    recommendation: "Always validate the Authorization header independently of the MCP-Session-Id. Sessions are for request routing, not authentication. Reject requests that lack valid auth even if they have a valid session ID."
+  },
+  {
+    id: "security-oauth-metadata",
+    name: "Protected Resource Metadata endpoint exists",
+    category: "security",
+    required: false,
+    specRef: "basic/authorization",
+    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",
+    name: "Rejects auth tokens in query string",
+    category: "security",
+    required: false,
+    specRef: "basic/authorization",
+    description: "Sends a request with the auth token in the URL query string instead of the Authorization header. The MCP spec forbids transmitting credentials in URIs.",
+    recommendation: "Never accept authentication tokens from URL query parameters. Tokens in URIs are logged by proxies, appear in browser history, and leak via the Referer header. Only accept tokens in the Authorization header."
+  },
+  {
+    id: "security-cors-headers",
+    name: "CORS headers are restrictive",
+    category: "security",
+    required: false,
+    specRef: "basic/transports#streamable-http",
+    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",
+    name: "Resists command injection in tool params",
+    category: "security",
+    required: false,
+    specRef: "server/tools#calling-tools",
+    description: "Calls each tool with OS command injection payloads in string parameters (e.g., '; cat /etc/passwd', '$(whoami)'). Verifies the server does not execute injected commands.",
+    recommendation: "Never pass tool argument values directly to shell commands. Use parameterized APIs, execFile() instead of exec(), or allowlists. Sanitize all user-provided input before use in system calls."
+  },
+  {
+    id: "security-sql-injection",
+    name: "Resists SQL injection in tool params",
+    category: "security",
+    required: false,
+    specRef: "server/tools#calling-tools",
+    description: `Calls each tool with SQL injection payloads in string parameters (e.g., "' OR 1=1 --"). Verifies the server does not return database errors or unexpected data.`,
+    recommendation: "Use parameterized queries or prepared statements for all database operations. Never concatenate user input into SQL strings. Return generic error messages that do not reveal database structure."
+  },
+  {
+    id: "security-path-traversal",
+    name: "Resists path traversal in tool params",
+    category: "security",
+    required: false,
+    specRef: "server/tools#calling-tools",
+    description: "Calls each tool with path traversal payloads in string parameters (e.g., '../../etc/passwd', '..\\\\..\\\\windows\\\\system.ini'). Verifies the server does not expose files outside its intended scope.",
+    recommendation: "Validate and sanitize file paths. Use path.resolve() and verify the result is within the allowed directory. Reject paths containing '..' segments. Use a chroot or sandboxed filesystem for file operations."
+  },
+  {
+    id: "security-ssrf-internal",
+    name: "Resists SSRF to internal networks",
+    category: "security",
+    required: false,
+    specRef: "server/tools#calling-tools",
+    description: "For tools that accept URL parameters, submits internal IP addresses (169.254.169.254, 127.0.0.1, 10.0.0.0/8) and cloud metadata endpoints. Verifies the server blocks requests to internal networks.",
+    recommendation: "Validate and restrict URLs in tool parameters. Block requests to private IP ranges (10.x, 172.16-31.x, 192.168.x, 127.x, 169.254.x), link-local addresses, and cloud metadata endpoints. Use an allowlist of permitted domains."
+  },
+  {
+    id: "security-oversized-input",
+    name: "Handles oversized inputs gracefully",
+    category: "security",
+    required: false,
+    specRef: "server/tools#calling-tools",
+    description: "Sends a tools/call request with an extremely large argument value (1MB+ string). Verifies the server rejects it with an error instead of crashing or consuming excessive resources.",
+    recommendation: "Implement request body size limits. Return HTTP 413 or JSON-RPC error for oversized payloads. Set explicit maxBodyLength in your HTTP server configuration."
+  },
+  {
+    id: "security-extra-params",
+    name: "Rejects or ignores extra tool params",
+    category: "security",
+    required: false,
+    specRef: "server/tools#calling-tools",
+    description: "Calls a tool with unexpected additional parameters beyond what the schema defines. Verifies the server either rejects them (strict) or silently ignores them (permissive) without errors.",
+    recommendation: "Use JSON Schema validation with additionalProperties: false to reject unexpected parameters, or strip unknown properties before processing. Do not pass unvalidated properties to internal functions."
+  },
+  // ── Security: Tool Integrity (4 tests) ───────────────────────────
+  {
+    id: "security-tool-schema-defined",
+    name: "All tools define inputSchema",
+    category: "security",
+    required: false,
+    specRef: "server/tools#data-types",
+    description: "Verifies all tools have an inputSchema with type 'object'. Tools without schemas cannot have their inputs validated, creating an injection risk.",
+    recommendation: "Define a complete JSON Schema (inputSchema with type: 'object') for every tool. Specify all expected properties, their types, and constraints. This enables input validation and prevents parameter injection."
+  },
+  {
+    id: "security-tool-rug-pull",
+    name: "Tool definitions are stable across calls",
+    category: "security",
+    required: false,
+    specRef: "server/tools#listing-tools",
+    description: "Calls tools/list twice and compares the results. Tool definitions should not change between calls within the same session, which could indicate a rug-pull attack.",
+    recommendation: "Ensure tools/list returns consistent results within a session. If tools change dynamically, send a tools/list_changed notification. Never silently alter tool definitions \u2014 this is a known MCP attack vector (tool poisoning)."
+  },
+  {
+    id: "security-tool-description-poisoning",
+    name: "Tool descriptions free of injection patterns",
+    category: "security",
+    required: false,
+    specRef: "server/tools#data-types",
+    description: "Scans all tool names, descriptions, and parameter descriptions for prompt injection patterns: 'ignore previous', 'override', 'system prompt', hidden Unicode characters, and Base64-encoded strings.",
+    recommendation: "Review all tool descriptions for prompt injection patterns. Remove any text that attempts to override LLM instructions, references system prompts, or contains hidden characters. Tool descriptions are rendered to LLMs and can be used for prompt injection."
+  },
+  {
+    id: "security-tool-cross-reference",
+    name: "Tools do not reference other tools by name",
+    category: "security",
+    required: false,
+    specRef: "server/tools#data-types",
+    description: "Checks that tool descriptions do not reference other tool names. Cross-references between tools can be used to manipulate LLM tool selection and create implicit execution chains.",
+    recommendation: "Avoid referencing other tool names in tool descriptions. Each tool should be self-contained. If tools have dependencies, document them in server instructions, not in individual tool descriptions."
+  },
+  // ── Security: Information Disclosure (3 tests) ───────────────────
+  {
+    id: "security-error-no-stacktrace",
+    name: "Error responses do not leak stack traces",
+    category: "security",
+    required: false,
+    specRef: "basic",
+    description: "Triggers various error conditions and inspects responses for stack traces, file paths, and internal implementation details. Error responses should not reveal server internals.",
+    recommendation: "Sanitize error responses before returning them to clients. Remove stack traces, file paths, database connection strings, and internal IP addresses. Use generic error messages for unexpected failures."
+  },
+  {
+    id: "security-error-no-internal-ip",
+    name: "Error responses do not leak internal IPs",
+    category: "security",
+    required: false,
+    specRef: "basic",
+    description: "Inspects error response bodies for private IP addresses (10.x, 172.16-31.x, 192.168.x, 127.x) that would reveal internal network topology.",
+    recommendation: "Strip internal IP addresses from error responses. Configure your reverse proxy to not forward X-Real-IP or internal addressing. Use a centralized error handler that sanitizes responses."
+  },
+  {
+    id: "security-rate-limiting",
+    name: "Rate limiting is enforced",
+    category: "security",
+    required: false,
+    specRef: "basic/transports#streamable-http",
+    description: "Sends a burst of rapid requests and checks if the server eventually returns HTTP 429 Too Many Requests. Production servers should implement rate limiting to prevent abuse.",
+    recommendation: "Implement rate limiting on your MCP endpoint. Return HTTP 429 with a Retry-After header when limits are exceeded. Consider per-IP, per-token, and per-session rate limits."
+  }
+];
+
+// src/runner.ts
+var TEST_DEFINITIONS_MAP = new Map(TEST_DEFINITIONS.map((t) => [t.id, t]));
+var _require = createRequire(import.meta.url);
+var { version: TOOL_VERSION } = _require("../package.json");
+var SPEC_VERSION = "2025-11-25";
+var SPEC_BASE = `https://modelcontextprotocol.io/specification/${SPEC_VERSION}`;
+var VALID_CONTENT_TYPES = ["text", "image", "audio", "resource", "resource_link"];
+var INJECTION_PAYLOADS = {
+  command: ["; cat /etc/passwd", "$(whoami)", "| ls -la", "`id`", "&& echo pwned"],
+  sql: ["' OR 1=1 --", "'; DROP TABLE users; --", "1 UNION SELECT * FROM information_schema.tables--"],
+  pathTraversal: ["../../etc/passwd", "..\\..\\windows\\system.ini", "%2e%2e%2f%2e%2e%2fetc%2fpasswd"],
+  ssrf: ["http://169.254.169.254/latest/meta-data/", "http://127.0.0.1:22", "http://[::1]/", "http://10.0.0.1/"]
+};
+var STACK_TRACE_PATTERNS = [
+  /at\s+\S+\s+\(.*:\d+:\d+\)/i,
+  // Node.js: "at Function (file.js:10:5)"
+  /Traceback\s+\(most recent/i,
+  // Python
+  /\.py",\s+line\s+\d+/i,
+  // Python file reference
+  /\.java:\d+\)/i,
+  // Java
+  /\.go:\d+/i,
+  // Go
+  /from\s+\S+\.rb:\d+/i,
+  // Ruby
+  /\.cs:line\s+\d+/i,
+  // C#/.NET
+  /#\d+\s+\/.*\.php\(\d+\)/i,
+  // PHP
+  /panicked\s+at\s+'/i,
+  // Rust
+  /ENOENT|EACCES|EPERM/,
+  // Node.js system errors
+  /node_modules\//,
+  // Node.js module paths
+  /\/usr\/local\/|\/home\//,
+  // Unix paths
+  /[A-Z]:\\.*\\/,
+  // Windows paths
+  /password|passwd|secret|credential/i,
+  // Sensitive terms
+  /jdbc:|mysql:|postgres:|mongodb:/i
+  // DB connection strings
+];
+var INTERNAL_IP_PATTERNS = [
+  /\b10\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,
+  /\b172\.(1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}\b/,
+  /\b192\.168\.\d{1,3}\.\d{1,3}\b/,
+  /\b127\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,
+  /\b::1\b/,
+  // IPv6 loopback
+  /\bfe80:/i,
+  // IPv6 link-local
+  /\bf[cd][0-9a-f]{2}:/i
+  // IPv6 unique local (fc00::/fd00::)
+];
+function createIdCounter(start = 0) {
+  let id = start;
+  return () => ++id;
+}
+var STDIO_INCOMPATIBLE_IDS = /* @__PURE__ */ new Set([
+  // Lifecycle tests that use raw undici for HTTP-specific checks
+  "lifecycle-string-id",
+  // Lifecycle tests that interpret HTTP status codes — for stdio these
+  // would always read as the wrapper's default 200 and produce
+  // misleading "(HTTP 200)" failure messages.
+  "lifecycle-reinit-reject",
+  "lifecycle-cancellation",
+  "lifecycle-progress",
+  "lifecycle-progress-token",
+  // Error tests that send hand-crafted malformed bytes via raw HTTP
+  // (JSON-RPC layer would reject them before they hit the wire). Could
+  // be reimplemented for stdio later by writing raw bytes to stdin.
+  "error-invalid-jsonrpc",
+  "error-invalid-json",
+  "error-parse-code",
+  "error-invalid-request-code",
+  // Security tests that are inherently HTTP-layer (auth headers,
+  // sessions, CORS, TLS, rate limits, RFC 9728 metadata). For stdio
+  // servers these don't apply — the parent process owns the trust
+  // boundary, not the server.
+  "security-tls-required",
+  "security-oauth-metadata",
+  "security-token-in-uri",
+  "security-rate-limiting",
+  "security-cors-headers",
+  "security-origin-validation",
+  "security-session-not-auth",
+  "security-auth-required",
+  "security-auth-malformed",
+  "security-www-authenticate",
+  "security-session-entropy"
+]);
+function supportsTransport(def, kind) {
+  if (!def) return true;
+  if (def.transports) return def.transports.includes(kind);
+  if (kind === "http") return true;
+  if (def.category === "transport") return false;
+  if (STDIO_INCOMPATIBLE_IDS.has(def.id)) return false;
+  return true;
+}
+function previewTests(opts = {}) {
+  const transport = opts.transport ?? "http";
+  return TEST_DEFINITIONS.filter((def) => {
+    if (!supportsTransport(def, transport)) return false;
+    if (opts.only?.length) {
+      if (!opts.only.includes(def.category) && !opts.only.includes(def.id)) return false;
+    }
+    if (opts.skip?.length) {
+      if (opts.skip.includes(def.category) || opts.skip.includes(def.id)) return false;
+    }
+    return true;
+  });
+}
+async function runComplianceSuite(target, options = {}) {
+  const resolvedTarget = typeof target === "string" ? { type: "http", url: target, headers: options.headers } : target;
+  if (resolvedTarget.type === "http") {
+    try {
+      const parsed = new URL(resolvedTarget.url);
+      if (!["http:", "https:"].includes(parsed.protocol)) {
+        throw new Error("Only HTTP and HTTPS URLs are supported");
+      }
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("Only HTTP")) throw e;
+      throw new Error(`Invalid URL: ${resolvedTarget.url}`);
+    }
+  } else if (!resolvedTarget.command) {
+    throw new Error("stdio target requires a command");
+  }
+  const transport = resolvedTarget.type === "http" ? createHttpTransport({
+    url: resolvedTarget.url,
+    headers: resolvedTarget.headers ?? options.headers
+  }) : createStdioTransport({
+    command: resolvedTarget.command,
+    args: resolvedTarget.args,
+    env: resolvedTarget.env,
+    cwd: resolvedTarget.cwd,
+    verbose: resolvedTarget.verbose
+  });
+  try {
+    let buildHeaders2 = function() {
+      const h = { ...userHeaders };
+      if (sessionId) h["mcp-session-id"] = sessionId;
+      if (negotiatedProtocolVersion) h["mcp-protocol-version"] = negotiatedProtocolVersion;
+      return h;
+    }, shouldRun2 = function(id, category) {
+      const def = TEST_DEFINITIONS_MAP.get(id);
+      if (!supportsTransport(def, transport.kind)) return false;
+      if (options.only && options.only.length > 0) {
+        return options.only.includes(category) || options.only.includes(id);
+      }
+      if (options.skip && options.skip.length > 0) {
+        return !options.skip.includes(category) && !options.skip.includes(id);
+      }
+      return true;
+    }, looksRejected2 = function(text, isErrorFlag) {
+      if (isErrorFlag) return true;
+      return REJECTION_PATTERNS.some((p) => p.test(text));
+    };
+    var buildHeaders = buildHeaders2, shouldRun = shouldRun2, looksRejected = looksRejected2;
+    const backendUrl = resolvedTarget.type === "http" ? resolvedTarget.url : "";
+    const userHeaders = resolvedTarget.type === "http" ? resolvedTarget.headers ?? options.headers ?? {} : {};
+    const displayUrl = resolvedTarget.type === "http" ? resolvedTarget.url : `stdio:${resolvedTarget.command}${resolvedTarget.args?.length ? ` ${resolvedTarget.args.join(" ")}` : ""}`;
+    let serverReachable = true;
+    if (resolvedTarget.type === "http") {
+      try {
+        const preflightTimeout = options.preflightTimeout ?? Math.min(options.timeout || 15e3, 1e4);
+        const preflight = await request2(resolvedTarget.url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            ...userHeaders
+          },
+          body: JSON.stringify({ jsonrpc: "2.0", id: 0, method: "ping" }),
+          signal: AbortSignal.timeout(preflightTimeout)
+        });
+        await preflight.body.text();
+      } catch {
+        serverReachable = false;
+      }
+    }
+    const tests = [];
+    const warnings = [];
+    if (!serverReachable) {
+      warnings.push(
+        `Server at ${displayUrl} is unreachable \u2014 all tests will fail. Check the URL or command and ensure the server is running.`
+      );
+    }
+    const nextId = createIdCounter(1e3);
+    const timeout = options.timeout || 15e3;
+    const retries = options.retries || 0;
+    let sessionId = null;
+    let negotiatedProtocolVersion = null;
+    async function mcpRequest(_backendUrl, method, params, idCounter, extraHeaders, timeoutMs) {
+      const res = await transport.request(method, params, idCounter, {
+        timeout: timeoutMs,
+        headers: extraHeaders
+      });
+      return {
+        statusCode: res.statusCode ?? 200,
+        body: res.body,
+        headers: res.headers ?? {},
+        requestId: res.requestId
+      };
+    }
+    async function mcpNotification(_backendUrl, method, params, extraHeaders, timeoutMs) {
+      const res = await transport.notify(method, params, {
+        timeout: timeoutMs,
+        headers: extraHeaders
+      });
+      return { statusCode: res.statusCode ?? 200, headers: res.headers ?? {} };
+    }
+    const rpc = (method, params) => mcpRequest(backendUrl, method, params, nextId, buildHeaders2(), timeout);
+    const serverInfo = {
+      protocolVersion: null,
+      name: null,
+      version: null,
+      capabilities: {}
+    };
+    let toolCount = 0;
+    let toolNames = [];
+    let resourceCount = 0;
+    let resourceNames = [];
+    let promptCount = 0;
+    let promptNames = [];
+    async function test(id, name, category, required, specRef, fn) {
+      if (!shouldRun2(id, category)) return;
+      const start = Date.now();
+      let lastResult = { passed: false, details: "" };
+      for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+          lastResult = await fn();
+          if (lastResult.passed) break;
+          if (attempt < retries) await new Promise((r) => setTimeout(r, 1e3 * (attempt + 1)));
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          lastResult = { passed: false, details: `Error: ${message}` };
+          if (attempt < retries) await new Promise((r) => setTimeout(r, 1e3 * (attempt + 1)));
+        }
+      }
+      tests.push({
+        id,
+        name,
+        category,
+        required,
+        passed: lastResult.passed,
+        details: lastResult.details,
+        durationMs: Date.now() - start,
+        specRef: `${SPEC_BASE}/${specRef}`
+      });
+      options.onProgress?.(id, lastResult.passed, lastResult.details);
+    }
+    await test(
+      "transport-post",
+      "HTTP POST accepted",
+      "transport",
+      true,
+      "basic/transports#streamable-http",
+      async () => {
+        const res = await request2(backendUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            ...userHeaders
+          },
+          body: JSON.stringify({ jsonrpc: "2.0", id: 99901, method: "ping" }),
+          signal: AbortSignal.timeout(timeout)
+        });
+        const text = await res.body.text();
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          return { passed: true, details: `HTTP ${res.statusCode}` };
+        }
+        if (res.statusCode === 401 || res.statusCode === 403) {
+          return { passed: false, details: `HTTP ${res.statusCode} (auth required \u2014 pass --auth)` };
+        }
+        if (res.statusCode === 400) {
+          try {
+            const body = JSON.parse(text);
+            if (body?.error || body?.jsonrpc) {
+              return {
+                passed: true,
+                details: "HTTP 400 with JSON-RPC response (server requires initialization first)"
+              };
+            }
+          } catch {
+          }
+        }
+        return { passed: false, details: `HTTP ${res.statusCode}` };
+      }
+    );
+    await test(
+      "transport-content-type",
+      "Responds with JSON or SSE",
+      "transport",
+      true,
+      "basic/transports#streamable-http",
+      async () => {
+        const res = await request2(backendUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            ...userHeaders
+          },
+          body: JSON.stringify({ jsonrpc: "2.0", id: 99902, method: "ping" }),
+          signal: AbortSignal.timeout(timeout)
+        });
+        await res.body.text();
+        const rawCt = res.headers["content-type"];
+        const ct = (Array.isArray(rawCt) ? rawCt[0] : rawCt || "").toLowerCase();
+        const valid = ct.includes("application/json") || ct.includes("text/event-stream");
+        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 request2(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",
+      "transport",
+      false,
+      "basic/transports#streamable-http",
+      async () => {
+        const getHeaders = { Accept: "text/event-stream", ...buildHeaders2() };
+        const res = await request2(backendUrl, {
+          method: "GET",
+          headers: getHeaders,
+          signal: AbortSignal.timeout(timeout)
+        });
+        const body = await res.body.text();
+        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)" };
+        }
+        if (ct.includes("text/event-stream")) {
+          if (body.trim().length > 0) {
+            const hasDataFields = body.includes("data:");
+            const hasEventFields = body.includes("event:");
+            if (!hasDataFields && !hasEventFields) {
+              return {
+                passed: false,
+                details: "Content-Type is text/event-stream but body has no SSE data: or event: fields"
+              };
+            }
+          }
+          return { passed: true, details: "Returns text/event-stream with valid SSE format" };
+        }
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          return { passed: true, details: `HTTP ${res.statusCode} (accepted)` };
+        }
+        return { passed: false, details: `HTTP ${res.statusCode}, Content-Type: ${ct}` };
+      }
+    );
+    await test(
+      "transport-batch-reject",
+      "Rejects JSON-RPC batch requests",
+      "transport",
+      true,
+      "basic/transports#streamable-http",
+      async () => {
+        const res = await request2(backendUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            ...userHeaders
+          },
+          body: JSON.stringify([
+            { jsonrpc: "2.0", id: 99903, method: "ping" },
+            { jsonrpc: "2.0", id: 99904, method: "ping" }
+          ]),
+          signal: AbortSignal.timeout(timeout)
+        });
+        const text = await res.body.text();
+        if (res.statusCode >= 400 && res.statusCode < 500) {
+          return { passed: true, details: `HTTP ${res.statusCode} (batch rejected)` };
+        }
+        try {
+          const body = JSON.parse(text);
+          if (body?.error) {
+            return { passed: true, details: `JSON-RPC error: ${body.error.code} \u2014 ${body.error.message}` };
+          }
+          if (Array.isArray(body)) {
+            return { passed: false, details: "Server processed batch request (MCP forbids batch)" };
+          }
+        } catch {
+        }
+        return { passed: false, details: `HTTP ${res.statusCode} \u2014 expected error or 4xx for batch request` };
+      }
+    );
+    let initRes = null;
+    try {
+      initRes = await rpc("initialize", {
+        protocolVersion: SPEC_VERSION,
+        capabilities: {},
+        clientInfo: { name: "mcp-compliance", version: TOOL_VERSION }
+      });
+      const result = initRes?.body?.result;
+      if (result) {
+        serverInfo.protocolVersion = result.protocolVersion || null;
+        serverInfo.name = result.serverInfo?.name || null;
+        serverInfo.version = result.serverInfo?.version || null;
+        serverInfo.capabilities = result.capabilities || {};
+        const sid = initRes.headers["mcp-session-id"];
+        if (sid) {
+          sessionId = sid;
+          transport.setSessionId(sid);
+        }
+        if (result.protocolVersion) {
+          negotiatedProtocolVersion = result.protocolVersion;
+          transport.setProtocolVersion(result.protocolVersion);
+        }
+      }
+    } catch {
+    }
+    try {
+      await mcpNotification(backendUrl, "notifications/initialized", void 0, buildHeaders2(), timeout);
+    } catch {
+    }
+    const hasTools = !!serverInfo.capabilities.tools;
+    const hasResources = !!serverInfo.capabilities.resources;
+    const hasPrompts = !!serverInfo.capabilities.prompts;
+    await test(
+      "lifecycle-init",
+      "Initialize handshake",
+      "lifecycle",
+      true,
+      "basic/lifecycle#initialization",
+      async () => {
+        if (!initRes) return { passed: false, details: "Initialize request failed" };
+        const result = initRes.body?.result;
+        if (!result) return { passed: false, details: "No result in response" };
+        return { passed: !!result.protocolVersion, details: `Protocol: ${result.protocolVersion || "missing"}` };
+      }
+    );
+    await test(
+      "lifecycle-proto-version",
+      "Returns valid protocol version",
+      "lifecycle",
+      true,
+      "basic/lifecycle#version-negotiation",
+      async () => {
+        const version = initRes?.body?.result?.protocolVersion;
+        if (!version) return { passed: false, details: "No protocolVersion" };
+        const valid = /^\d{4}-\d{2}-\d{2}$/.test(version);
+        if (valid && version !== SPEC_VERSION) {
+          warnings.push(`Server negotiated protocol version ${version} (latest is ${SPEC_VERSION})`);
+        }
+        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",
+      "lifecycle",
+      false,
+      "basic/lifecycle#initialization",
+      async () => {
+        const info = initRes?.body?.result?.serverInfo;
+        return { passed: !!info?.name, details: info ? `${info.name} v${info.version || "?"}` : "Missing serverInfo" };
+      }
+    );
+    await test(
+      "lifecycle-capabilities",
+      "Returns capabilities object",
+      "lifecycle",
+      true,
+      "basic/lifecycle#capability-negotiation",
+      async () => {
+        const caps = initRes?.body?.result?.capabilities;
+        if (!caps || typeof caps !== "object") return { passed: false, details: "No capabilities object in response" };
+        const declared = Object.keys(caps).filter((k) => caps[k] !== void 0);
+        return {
+          passed: true,
+          details: declared.length > 0 ? `Capabilities: ${declared.join(", ")}` : "Empty capabilities (valid)"
+        };
+      }
+    );
+    await test("lifecycle-jsonrpc", "Response is valid JSON-RPC 2.0", "lifecycle", true, "basic", async () => {
+      const body = initRes?.body;
+      const valid = body?.jsonrpc === "2.0" && body?.id !== void 0 && (body?.result !== void 0 || body?.error !== void 0);
+      return {
+        passed: valid,
+        details: valid ? "Valid JSON-RPC 2.0 response" : `Missing fields: jsonrpc=${body?.jsonrpc}, id=${body?.id}`
+      };
+    });
+    await test("lifecycle-ping", "Responds to ping", "lifecycle", true, "basic/utilities#ping", async () => {
+      const res = await rpc("ping");
+      const body = res.body;
+      if (body?.error) return { passed: false, details: `Error: ${body.error.message}` };
+      if (body?.result !== void 0) return { passed: true, details: "Ping responded successfully" };
+      return { passed: false, details: "No result in ping response" };
+    });
+    await test(
+      "lifecycle-instructions",
+      "Instructions field is valid",
+      "lifecycle",
+      false,
+      "basic/lifecycle#initialization",
+      async () => {
+        const result = initRes?.body?.result;
+        if (!result) return { passed: false, details: "No init result" };
+        if (result.instructions === void 0) {
+          return { passed: true, details: "No instructions field (optional)" };
+        }
+        if (typeof result.instructions === "string") {
+          const preview = result.instructions.length > 80 ? result.instructions.slice(0, 80) + "..." : result.instructions;
+          return { passed: true, details: `Instructions: "${preview}"` };
+        }
+        return { passed: false, details: `instructions should be a string, got ${typeof result.instructions}` };
+      }
+    );
+    await test("lifecycle-id-match", "Response ID matches request ID", "lifecycle", true, "basic", async () => {
+      const res = await rpc("ping");
+      const body = res.body;
+      if (body?.id === void 0) return { passed: false, details: "No id in response" };
+      const match = body.id === res.requestId;
+      return {
+        passed: match,
+        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 request2(backendUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json, text/event-stream",
+          ...buildHeaders2()
+        },
+        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",
+      "logging/setLevel accepted",
+      "lifecycle",
+      hasLogging,
+      "server/utilities#logging",
+      async () => {
+        if (!hasLogging) return { passed: true, details: "Server does not declare logging capability (skipped)" };
+        const res = await rpc("logging/setLevel", { level: "info" });
+        if (res.body?.error) {
+          return { passed: false, details: `Error: ${res.body.error.code} \u2014 ${res.body.error.message}` };
+        }
+        const invalidRes = await rpc("logging/setLevel", { level: "__invalid_level__" });
+        const validatesInput = !!invalidRes.body?.error;
+        const validLevels = ["debug", "warning", "error"];
+        const accepted = [];
+        for (const level of validLevels) {
+          const r = await rpc("logging/setLevel", { level });
+          if (!r.body?.error) accepted.push(level);
+        }
+        const details = validatesInput ? `logging/setLevel accepted (validates levels, ${accepted.length + 1} levels accepted)` : "logging/setLevel accepted (warning: server does not reject invalid log levels)";
+        if (!validatesInput) warnings.push("Server accepts invalid log levels without error");
+        return { passed: true, details };
+      }
+    );
+    const hasCompletions = !!serverInfo.capabilities.completions;
+    await test(
+      "lifecycle-completions",
+      "completion/complete accepted",
+      "lifecycle",
+      hasCompletions,
+      "server/utilities#completion",
+      async () => {
+        if (!hasCompletions)
+          return { passed: true, details: "Server does not declare completions capability (skipped)" };
+        const res = await rpc("completion/complete", {
+          ref: { type: "ref/prompt", name: "__test__" },
+          argument: { name: "test", value: "" }
+        });
+        if (res.body?.error) {
+          if (res.body.error.code === -32602) {
+            return { passed: true, details: "InvalidParams for test ref (acceptable)" };
+          }
+          return { passed: false, details: `Error: ${res.body.error.code} \u2014 ${res.body.error.message}` };
+        }
+        const values = res.body?.result?.completion?.values;
+        if (Array.isArray(values)) {
+          return { passed: true, details: `Returned ${values.length} completion(s)` };
+        }
+        return { passed: true, details: "completion/complete accepted" };
+      }
+    );
+    await test(
+      "lifecycle-cancellation",
+      "Handles cancellation notifications",
+      "lifecycle",
+      false,
+      "basic/utilities#cancellation",
+      async () => {
+        const res = await mcpNotification(
+          backendUrl,
+          "notifications/cancelled",
+          { requestId: 99999, reason: "compliance test" },
+          buildHeaders2(),
+          timeout
+        );
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          return { passed: true, details: `HTTP ${res.statusCode} (cancellation accepted)` };
+        }
+        return { passed: false, details: `HTTP ${res.statusCode} \u2014 server should accept cancellation notifications` };
+      }
+    );
+    await test(
+      "lifecycle-progress",
+      "Handles progress notifications gracefully",
+      "lifecycle",
+      false,
+      "basic/utilities#progress",
+      async () => {
+        const res = await mcpNotification(
+          backendUrl,
+          "notifications/progress",
+          { progressToken: "compliance-test-token", progress: 50, total: 100 },
+          buildHeaders2(),
+          timeout
+        );
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          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, buildHeaders2(), 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 request2(backendUrl, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Accept: "text/event-stream",
+              ...buildHeaders2()
+            },
+            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)"
+          };
+        }
+      }
+    );
+    await test(
+      "transport-content-type-init",
+      "Initialize response has valid content type",
+      "transport",
+      false,
+      "basic/transports#streamable-http",
+      async () => {
+        if (!initRes) return { passed: false, details: "No init response to check" };
+        const ct = (initRes.headers["content-type"] || "").toLowerCase();
+        const valid = ct.includes("application/json") || ct.includes("text/event-stream");
+        return { passed: valid, details: `Content-Type: ${ct || "missing"}` };
+      }
+    );
+    await test(
+      "transport-notification-202",
+      "Notification returns 202 Accepted",
+      "transport",
+      false,
+      "basic/transports#streamable-http",
+      async () => {
+        const res = await request2(backendUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            ...buildHeaders2()
+          },
+          body: JSON.stringify({
+            jsonrpc: "2.0",
+            method: "notifications/cancelled",
+            params: { requestId: "nonexistent", reason: "compliance test" }
+          }),
+          signal: AbortSignal.timeout(timeout)
+        });
+        await res.body.text();
+        if (res.statusCode === 202) {
+          return { passed: true, details: "HTTP 202 Accepted (correct)" };
+        }
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          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` };
+      }
+    );
+    await test(
+      "transport-session-id",
+      "Enforces MCP-Session-Id after init",
+      "transport",
+      false,
+      "basic/transports#streamable-http",
+      async () => {
+        if (!sessionId) {
+          warnings.push("Server did not issue MCP-Session-Id header");
+          return { passed: true, details: "Server did not issue session ID (test not applicable)" };
+        }
+        const headersWithout = { ...userHeaders };
+        if (negotiatedProtocolVersion) headersWithout["mcp-protocol-version"] = negotiatedProtocolVersion;
+        const res = await mcpRequest(backendUrl, "ping", void 0, createIdCounter(99910), headersWithout, timeout);
+        if (res.statusCode === 400) {
+          return { passed: true, details: "HTTP 400 for missing session ID (correct)" };
+        }
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          return {
+            passed: false,
+            details: `HTTP ${res.statusCode} \u2014 server should return 400 when session ID is missing`
+          };
+        }
+        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",
+      "transport",
+      false,
+      "basic/transports#streamable-http",
+      async () => {
+        if (!sessionId) {
+          return { passed: true, details: "No session ID \u2014 server-initiated messages not applicable" };
+        }
+        const res = await request2(backendUrl, {
+          method: "GET",
+          headers: { Accept: "text/event-stream", ...buildHeaders2() },
+          signal: AbortSignal.timeout(Math.min(timeout, 3e3))
+        });
+        const body = await res.body.text();
+        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)" };
+        }
+        if (ct.includes("text/event-stream")) {
+          if (body.trim().length > 0) {
+            const hasSSEFields = body.includes("data:") || body.includes("event:");
+            if (!hasSSEFields) {
+              return { passed: false, details: "Content-Type is text/event-stream but body has no SSE fields" };
+            }
+          }
+          return { passed: true, details: "GET with session returns SSE stream for server-initiated messages" };
+        }
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          return { passed: true, details: `HTTP ${res.statusCode} (accepted)` };
+        }
+        return { passed: false, details: `HTTP ${res.statusCode}, Content-Type: ${ct}` };
+      }
+    );
+    await test(
+      "transport-concurrent",
+      "Handles concurrent requests",
+      "transport",
+      false,
+      "basic/transports#streamable-http",
+      async () => {
+        const ids = [createIdCounter(99930)(), createIdCounter(99931)(), createIdCounter(99932)()];
+        const promises = ids.map(
+          (id) => request2(backendUrl, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Accept: "application/json, text/event-stream",
+              ...buildHeaders2()
+            },
+            body: JSON.stringify({ jsonrpc: "2.0", id, method: "ping" }),
+            signal: AbortSignal.timeout(timeout)
+          }).then(async (res) => {
+            const text = await res.body.text();
+            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);
+            }
+            if (!body) {
+              try {
+                body = JSON.parse(text);
+              } catch {
+              }
+            }
+            return { statusCode: res.statusCode, body, requestId: id };
+          })
+        );
+        const results = await Promise.all(promises);
+        const issues = [];
+        for (const r of results) {
+          if (r.statusCode < 200 || r.statusCode >= 300) {
+            issues.push(`Request id=${r.requestId}: HTTP ${r.statusCode}`);
+          } else if (r.body?.id !== r.requestId) {
+            issues.push(`Request id=${r.requestId}: response id=${r.body?.id} (mismatch)`);
+          }
+        }
+        if (issues.length > 0) return { passed: false, details: issues.join("; ") };
+        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 request2(backendUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "text/event-stream",
+            ...buildHeaders2()
+          },
+          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" };
+      }
+    );
+    let cachedToolsList = null;
+    await test(
+      "tools-list",
+      "tools/list returns valid response",
+      "tools",
+      hasTools,
+      "server/tools#listing-tools",
+      async () => {
+        const res = await rpc("tools/list");
+        const tools = res.body?.result?.tools;
+        if (!Array.isArray(tools)) return { passed: false, details: "No tools array in result" };
+        cachedToolsList = tools;
+        toolCount = tools.length;
+        toolNames = tools.map((t) => t.name).filter(Boolean);
+        return {
+          passed: true,
+          details: `${toolCount} tool(s): ${toolNames.slice(0, 5).join(", ")}${toolCount > 5 ? "..." : ""}`
+        };
+      }
+    );
+    const toolsListOk = cachedToolsList !== null;
+    await test(
+      "tools-schema",
+      "All tools have name and inputSchema",
+      "schema",
+      hasTools,
+      "server/tools#data-types",
+      async () => {
+        if (!toolsListOk) return { passed: false, details: "Skipped: tools/list failed" };
+        const tools = cachedToolsList ?? [];
+        const issues = [];
+        for (const tool of tools) {
+          if (!tool.name) {
+            issues.push("Tool missing name");
+            continue;
+          }
+          if (tool.name.length > 128 || !/^[A-Za-z0-9_.\-]+$/.test(tool.name)) {
+            issues.push(`${tool.name}: name format invalid`);
+          }
+          if (!tool.description) warnings.push(`Tool "${tool.name}" missing description`);
+          if (!tool.inputSchema) {
+            issues.push(`${tool.name}: missing inputSchema (required)`);
+          } else if (typeof tool.inputSchema !== "object" || tool.inputSchema === null) {
+            issues.push(`${tool.name}: inputSchema must be a valid JSON Schema object`);
+          } else if (tool.inputSchema.type !== "object") {
+            issues.push(
+              `${tool.name}: inputSchema.type must be "object" (got "${tool.inputSchema.type || "undefined"}")`
+            );
+          }
+        }
+        const detail = issues.length === 0 ? "All tools have valid schemas" : issues.join("; ");
+        return { passed: issues.length === 0, details: detail };
+      }
+    );
+    await test(
+      "tools-annotations",
+      "Tool annotations are valid",
+      "schema",
+      false,
+      "server/tools#annotations",
+      async () => {
+        if (!toolsListOk) return { passed: false, details: "Skipped: tools/list failed" };
+        const tools = cachedToolsList ?? [];
+        if (tools.length === 0) return { passed: true, details: "No tools to validate" };
+        const issues = [];
+        let annotatedCount = 0;
+        for (const tool of tools) {
+          const ann = tool.annotations;
+          if (!ann) continue;
+          annotatedCount++;
+          if (typeof ann !== "object" || ann === null) {
+            issues.push(`${tool.name}: annotations must be an object`);
+            continue;
+          }
+          const boolFields = ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"];
+          for (const field of boolFields) {
+            if (ann[field] !== void 0 && typeof ann[field] !== "boolean") {
+              issues.push(`${tool.name}: annotations.${field} should be boolean, got ${typeof ann[field]}`);
+            }
+          }
+        }
+        if (issues.length > 0) return { passed: false, details: issues.join("; ") };
+        return {
+          passed: true,
+          details: annotatedCount > 0 ? `${annotatedCount} tool(s) with valid annotations` : "No tools have annotations (optional)"
+        };
+      }
+    );
+    await test(
+      "tools-title-field",
+      "Tools include title field",
+      "schema",
+      false,
+      "server/tools#data-types",
+      async () => {
+        if (!toolsListOk) return { passed: false, details: "Skipped: tools/list failed" };
+        const tools = cachedToolsList ?? [];
+        if (tools.length === 0) return { passed: true, details: "No tools to validate" };
+        const withTitle = tools.filter((t) => typeof t.title === "string");
+        const issues = [];
+        for (const tool of tools) {
+          if (tool.title !== void 0 && typeof tool.title !== "string") {
+            issues.push(`${tool.name}: title should be a string`);
+          }
+        }
+        if (issues.length > 0) return { passed: false, details: issues.join("; ") };
+        if (withTitle.length === 0) {
+          return { passed: true, details: "No tools have title field (optional, added in 2025-11-25)" };
+        }
+        return { passed: true, details: `${withTitle.length}/${tools.length} tool(s) have title field` };
+      }
+    );
+    await test(
+      "tools-output-schema",
+      "Tools with outputSchema are valid",
+      "schema",
+      false,
+      "server/tools#structured-content",
+      async () => {
+        if (!toolsListOk) return { passed: false, details: "Skipped: tools/list failed" };
+        const tools = cachedToolsList ?? [];
+        if (tools.length === 0) return { passed: true, details: "No tools to validate" };
+        const issues = [];
+        let withSchema = 0;
+        for (const tool of tools) {
+          if (tool.outputSchema === void 0) continue;
+          withSchema++;
+          if (typeof tool.outputSchema !== "object" || tool.outputSchema === null) {
+            issues.push(`${tool.name}: outputSchema must be a JSON Schema object`);
+          } else if (tool.outputSchema.type !== "object") {
+            issues.push(
+              `${tool.name}: outputSchema.type must be "object" (got "${tool.outputSchema.type || "undefined"}")`
+            );
+          }
+        }
+        if (issues.length > 0) return { passed: false, details: issues.join("; ") };
+        return {
+          passed: true,
+          details: withSchema > 0 ? `${withSchema} tool(s) with valid outputSchema` : "No tools have outputSchema (optional)"
+        };
+      }
+    );
+    if (toolNames.length > 0) {
+      await test(
+        "tools-call",
+        "tools/call responds correctly",
+        "tools",
+        false,
+        "server/tools#calling-tools",
+        async () => {
+          const res = await rpc("tools/call", { name: toolNames[0], arguments: {} });
+          const result = res.body?.result;
+          const error = res.body?.error;
+          if (error) {
+            const code = error.code;
+            if (code === -32602 || code === -32600) {
+              return { passed: true, details: `Invalid params error (acceptable): code ${code}` };
+            }
+            return { passed: true, details: `Protocol error: code ${code} \u2014 ${error.message}` };
+          }
+          if (result?.content && Array.isArray(result.content)) {
+            if (result.isError) {
+              return { passed: true, details: "Tool returned execution error with content (valid)" };
+            }
+            const badItems = result.content.filter((c) => !c.type);
+            if (badItems.length > 0)
+              return { passed: false, details: `${badItems.length} content item(s) missing 'type' field` };
+            return { passed: true, details: `Returned ${result.content.length} content item(s)` };
+          }
+          return { passed: false, details: "Response missing content array" };
+        }
+      );
+      await test(
+        "tools-content-types",
+        "Tool content items have valid types",
+        "tools",
+        false,
+        "server/tools#calling-tools",
+        async () => {
+          const res = await rpc("tools/call", { name: toolNames[0], arguments: {} });
+          const result = res.body?.result;
+          const error = res.body?.error;
+          if (error) {
+            return { passed: true, details: `Tool returned error (content types not applicable): code ${error.code}` };
+          }
+          const content = result?.content;
+          if (!Array.isArray(content) || content.length === 0) {
+            return { passed: true, details: "No content items to validate" };
+          }
+          const issues = [];
+          const types = /* @__PURE__ */ new Set();
+          for (const item of content) {
+            if (!item.type) {
+              issues.push("Content item missing type field");
+            } else if (!VALID_CONTENT_TYPES.includes(item.type)) {
+              issues.push(`Unknown content type: "${item.type}"`);
+            } else {
+              types.add(item.type);
+            }
+          }
+          if (issues.length > 0) return { passed: false, details: issues.join("; ") };
+          return { passed: true, details: `Content types: ${[...types].join(", ")}` };
+        }
+      );
+    }
+    if (hasTools) {
+      await test(
+        "tools-pagination",
+        "tools/list supports pagination",
+        "tools",
+        false,
+        "server/tools#listing-tools",
+        async () => {
+          const res = await rpc("tools/list");
+          const result = res.body?.result;
+          if (!result) return { passed: false, details: "No result from tools/list" };
+          if (!Array.isArray(result.tools)) return { passed: false, details: "No tools array" };
+          if (result.nextCursor !== void 0) {
+            if (typeof result.nextCursor !== "string") {
+              return { passed: false, details: `nextCursor should be string, got ${typeof result.nextCursor}` };
+            }
+            const nextRes = await rpc("tools/list", { cursor: result.nextCursor });
+            const nextResult = nextRes.body?.result;
+            if (!nextResult || !Array.isArray(nextResult.tools)) {
+              return { passed: false, details: "Next page failed to return tools array" };
+            }
+            return {
+              passed: true,
+              details: `Pagination works: page 1 had ${result.tools.length} tools, page 2 had ${nextResult.tools.length} tools`
+            };
+          }
+          return { passed: true, details: `${result.tools.length} tool(s), no nextCursor (single page)` };
+        }
+      );
+      await test(
+        "tools-call-unknown",
+        "Returns error for unknown tool name",
+        "errors",
+        false,
+        "server/tools#error-handling",
+        async () => {
+          const res = await rpc("tools/call", { name: "__nonexistent_tool_compliance_test__", arguments: {} });
+          const error = res.body?.error;
+          const isError = res.body?.result?.isError;
+          if (error) return { passed: true, details: `Error code: ${error.code} \u2014 ${error.message}` };
+          if (isError) return { passed: true, details: "Tool execution error with isError=true (valid)" };
+          return { passed: false, details: "No error returned for nonexistent tool" };
+        }
+      );
+    }
+    const resourcesCap = serverInfo.capabilities.resources;
+    const hasSubscribe = !!(typeof resourcesCap === "object" && resourcesCap !== null && "subscribe" in resourcesCap && resourcesCap.subscribe);
+    if (hasResources) {
+      let cachedResourcesList = null;
+      await test(
+        "resources-list",
+        "resources/list returns valid response",
+        "resources",
+        true,
+        "server/resources#listing-resources",
+        async () => {
+          const res = await rpc("resources/list");
+          const resources = res.body?.result?.resources;
+          if (!Array.isArray(resources)) return { passed: false, details: "No resources array" };
+          cachedResourcesList = resources;
+          resourceCount = resources.length;
+          resourceNames = resources.map((r) => r.name).filter(Boolean);
+          return { passed: true, details: `${resourceCount} resource(s)` };
+        }
+      );
+      const resourcesListOk = cachedResourcesList !== null;
+      await test(
+        "resources-schema",
+        "Resources have uri and name",
+        "schema",
+        true,
+        "server/resources#data-types",
+        async () => {
+          if (!resourcesListOk) return { passed: false, details: "Skipped: resources/list failed" };
+          const resources = cachedResourcesList ?? [];
+          const issues = [];
+          for (const r of resources) {
+            if (!r.uri) issues.push("Resource missing uri");
+            else {
+              try {
+                new URL(r.uri);
+              } catch {
+                issues.push(`${r.uri}: invalid URI format`);
+              }
+            }
+            if (!r.name) issues.push(`${r.uri || "?"}: missing name`);
+            if (!r.description) warnings.push(`Resource "${r.name || r.uri}" missing description`);
+            if (!r.mimeType) warnings.push(`Resource "${r.name || r.uri}" missing mimeType`);
+          }
+          return {
+            passed: issues.length === 0,
+            details: issues.length === 0 ? "All resources valid" : issues.join("; ")
+          };
+        }
+      );
+      if (resourceCount > 0) {
+        await test(
+          "resources-read",
+          "resources/read returns content",
+          "resources",
+          false,
+          "server/resources#reading-resources",
+          async () => {
+            const resources = cachedResourcesList ?? [];
+            const firstUri = resources[0]?.uri;
+            if (!firstUri) return { passed: false, details: "No resource URI to test" };
+            const readRes = await rpc("resources/read", { uri: firstUri });
+            const contents = readRes.body?.result?.contents;
+            if (!Array.isArray(contents)) return { passed: false, details: "No contents array" };
+            const issues = [];
+            for (const c of contents) {
+              if (!c.uri) issues.push("Content item missing uri");
+              if (!c.text && !c.blob) issues.push(`Content item for ${c.uri || "?"} missing both text and blob`);
+            }
+            if (issues.length > 0) return { passed: false, details: issues.join("; ") };
+            return { passed: true, details: `Read ${contents.length} content item(s) from ${firstUri}` };
+          }
+        );
+      }
+      await test(
+        "resources-templates",
+        "resources/templates/list returns valid response",
+        "resources",
+        false,
+        "server/resources#resource-templates",
+        async () => {
+          const res = await rpc("resources/templates/list");
+          const error = res.body?.error;
+          if (error) {
+            if (error.code === -32601) return { passed: true, details: "Method not supported (acceptable)" };
+            return { passed: false, details: `Error: ${error.message}` };
+          }
+          const templates = res.body?.result?.resourceTemplates;
+          if (!Array.isArray(templates)) return { passed: false, details: "No resourceTemplates array" };
+          const issues = [];
+          for (const t of templates) {
+            if (!t.uriTemplate) {
+              issues.push("Template missing uriTemplate");
+            } else if (typeof t.uriTemplate !== "string") {
+              issues.push(`uriTemplate should be a string, got ${typeof t.uriTemplate}`);
+            } else if (!t.uriTemplate.includes("{") || !t.uriTemplate.includes("}")) {
+              warnings.push(`Template "${t.name || t.uriTemplate}" has no URI template parameters (e.g., {id})`);
+            }
+            if (!t.name) issues.push(`${t.uriTemplate || "?"}: missing name`);
+            if (!t.description) warnings.push(`Template "${t.name || t.uriTemplate || "?"}" missing description`);
+          }
+          if (issues.length > 0) return { passed: false, details: issues.join("; ") };
+          return { passed: true, details: `${templates.length} resource template(s)` };
+        }
+      );
+      await test(
+        "resources-pagination",
+        "resources/list supports pagination",
+        "resources",
+        false,
+        "server/resources#listing-resources",
+        async () => {
+          const res = await rpc("resources/list");
+          const result = res.body?.result;
+          if (!result) return { passed: false, details: "No result from resources/list" };
+          if (!Array.isArray(result.resources)) return { passed: false, details: "No resources array" };
+          if (result.nextCursor !== void 0) {
+            if (typeof result.nextCursor !== "string") {
+              return { passed: false, details: `nextCursor should be string, got ${typeof result.nextCursor}` };
+            }
+            const nextRes = await rpc("resources/list", { cursor: result.nextCursor });
+            const nextResult = nextRes.body?.result;
+            if (!nextResult || !Array.isArray(nextResult.resources)) {
+              return { passed: false, details: "Next page failed to return resources array" };
+            }
+            return {
+              passed: true,
+              details: `Pagination works: page 1 had ${result.resources.length}, page 2 had ${nextResult.resources.length}`
+            };
+          }
+          return { passed: true, details: `${result.resources.length} resource(s), no nextCursor (single page)` };
+        }
+      );
+      if (hasSubscribe && resourceCount > 0) {
+        await test(
+          "resources-subscribe",
+          "Resource subscribe/unsubscribe",
+          "resources",
+          true,
+          "server/resources#subscriptions",
+          async () => {
+            const resources = cachedResourcesList ?? [];
+            const firstUri = resources[0]?.uri;
+            if (!firstUri) return { passed: false, details: "No resource URI for subscribe test" };
+            const subRes = await rpc("resources/subscribe", { uri: firstUri });
+            if (subRes.body?.error) {
+              return {
+                passed: false,
+                details: `Subscribe error: ${subRes.body.error.code} \u2014 ${subRes.body.error.message}`
+              };
+            }
+            const unsubRes = await rpc("resources/unsubscribe", { uri: firstUri });
+            if (unsubRes.body?.error) {
+              return {
+                passed: false,
+                details: `Unsubscribe error: ${unsubRes.body.error.code} \u2014 ${unsubRes.body.error.message}`
+              };
+            }
+            return { passed: true, details: `Subscribe/unsubscribe for ${firstUri} succeeded` };
+          }
+        );
+      }
+    }
+    if (hasPrompts) {
+      let cachedPromptsList = null;
+      await test(
+        "prompts-list",
+        "prompts/list returns valid response",
+        "prompts",
+        true,
+        "server/prompts#listing-prompts",
+        async () => {
+          const res = await rpc("prompts/list");
+          const prompts = res.body?.result?.prompts;
+          if (!Array.isArray(prompts)) return { passed: false, details: "No prompts array" };
+          cachedPromptsList = prompts;
+          promptCount = prompts.length;
+          promptNames = prompts.map((p) => p.name).filter(Boolean);
+          return {
+            passed: true,
+            details: `${promptCount} prompt(s): ${promptNames.slice(0, 5).join(", ")}${promptCount > 5 ? "..." : ""}`
+          };
+        }
+      );
+      const promptsListOk = cachedPromptsList !== null;
+      await test("prompts-schema", "Prompts have name field", "schema", true, "server/prompts#data-types", async () => {
+        if (!promptsListOk) return { passed: false, details: "Skipped: prompts/list failed" };
+        const prompts = cachedPromptsList ?? [];
+        const issues = [];
+        for (const p of prompts) {
+          if (!p.name) issues.push("Prompt missing name");
+          if (!p.description) warnings.push(`Prompt "${p.name || "?"}" missing description`);
+          if (p.arguments && !Array.isArray(p.arguments)) issues.push(`${p.name || "?"}: arguments must be an array`);
+          if (Array.isArray(p.arguments)) {
+            for (const arg of p.arguments) {
+              if (!arg.name) issues.push(`${p.name}: argument missing name`);
+            }
+          }
+        }
+        return { passed: issues.length === 0, details: issues.length === 0 ? "All prompts valid" : issues.join("; ") };
+      });
+      if (promptNames.length > 0) {
+        await test(
+          "prompts-get",
+          "prompts/get returns valid messages",
+          "prompts",
+          false,
+          "server/prompts#getting-a-prompt",
+          async () => {
+            const res = await rpc("prompts/get", { name: promptNames[0] });
+            const error = res.body?.error;
+            if (error) return { passed: true, details: `Error (may need arguments): code ${error.code}` };
+            const messages = res.body?.result?.messages;
+            if (!Array.isArray(messages)) return { passed: false, details: "No messages array in result" };
+            const issues = [];
+            for (const msg of messages) {
+              if (!msg.role || !["user", "assistant"].includes(msg.role)) issues.push(`Invalid role: ${msg.role}`);
+              if (!msg.content) issues.push("Message missing content");
+            }
+            if (issues.length > 0) return { passed: false, details: issues.join("; ") };
+            return { passed: true, details: `${messages.length} message(s) from ${promptNames[0]}` };
+          }
+        );
+      }
+      await test(
+        "prompts-pagination",
+        "prompts/list supports pagination",
+        "prompts",
+        false,
+        "server/prompts#listing-prompts",
+        async () => {
+          const res = await rpc("prompts/list");
+          const result = res.body?.result;
+          if (!result) return { passed: false, details: "No result from prompts/list" };
+          if (!Array.isArray(result.prompts)) return { passed: false, details: "No prompts array" };
+          if (result.nextCursor !== void 0) {
+            if (typeof result.nextCursor !== "string") {
+              return { passed: false, details: `nextCursor should be string, got ${typeof result.nextCursor}` };
+            }
+            const nextRes = await rpc("prompts/list", { cursor: result.nextCursor });
+            const nextResult = nextRes.body?.result;
+            if (!nextResult || !Array.isArray(nextResult.prompts)) {
+              return { passed: false, details: "Next page failed to return prompts array" };
+            }
+            return {
+              passed: true,
+              details: `Pagination works: page 1 had ${result.prompts.length}, page 2 had ${nextResult.prompts.length}`
+            };
+          }
+          return { passed: true, details: `${result.prompts.length} prompt(s), no nextCursor (single page)` };
+        }
+      );
+    }
+    await test(
+      "error-unknown-method",
+      "Returns JSON-RPC error for unknown method",
+      "errors",
+      true,
+      "basic",
+      async () => {
+        const res = await rpc("nonexistent/method");
+        const error = res.body?.error;
+        if (!error) return { passed: false, details: "No JSON-RPC error returned for unknown method" };
+        const correctCode = error.code === -32601;
+        return {
+          passed: true,
+          details: `Error code: ${error.code}${correctCode ? " (correct: Method not found)" : " (expected -32601)"} \u2014 ${error.message}`
+        };
+      }
+    );
+    await test(
+      "error-method-code",
+      "Uses correct JSON-RPC error code for unknown method",
+      "errors",
+      false,
+      "basic",
+      async () => {
+        const res = await rpc("nonexistent/method");
+        const error = res.body?.error;
+        if (!error) return { passed: false, details: "No error returned" };
+        return { passed: error.code === -32601, details: `Expected -32601, got ${error.code}` };
+      }
+    );
+    await test("error-invalid-jsonrpc", "Handles malformed JSON-RPC", "errors", true, "basic", async () => {
+      const res = await request2(backendUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json, text/event-stream",
+          ...buildHeaders2()
+        },
+        body: JSON.stringify({ not: "a valid jsonrpc message" }),
+        signal: AbortSignal.timeout(timeout)
+      });
+      const text = await res.body.text();
+      try {
+        const body = JSON.parse(text);
+        if (body?.error) {
+          const correctCode = body.error.code === -32600;
+          return {
+            passed: true,
+            details: `Error code: ${body.error.code}${correctCode ? " (correct: Invalid Request)" : ""} \u2014 ${body.error.message}`
+          };
+        }
+      } catch {
+      }
+      if (res.statusCode >= 400 && res.statusCode < 500)
+        return { passed: true, details: `HTTP ${res.statusCode} (acceptable)` };
+      return { passed: false, details: `HTTP ${res.statusCode} \u2014 expected JSON-RPC error or 4xx status` };
+    });
+    await test("error-invalid-json", "Handles invalid JSON body", "errors", false, "basic", async () => {
+      const res = await request2(backendUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json, text/event-stream",
+          ...buildHeaders2()
+        },
+        body: "{this is not valid json!!!",
+        signal: AbortSignal.timeout(timeout)
+      });
+      const text = await res.body.text();
+      try {
+        const body = JSON.parse(text);
+        if (body?.error) return { passed: true, details: `Error code: ${body.error.code} \u2014 ${body.error.message}` };
+      } catch {
+      }
+      if (res.statusCode >= 400 && res.statusCode < 500)
+        return { passed: true, details: `HTTP ${res.statusCode} (acceptable)` };
+      return { passed: false, details: `HTTP ${res.statusCode} \u2014 expected parse error or 4xx status` };
+    });
+    await test(
+      "error-missing-params",
+      "Returns error for tools/call without name",
+      "errors",
+      false,
+      "server/tools#error-handling",
+      async () => {
+        const res = await rpc("tools/call", {});
+        const error = res.body?.error;
+        const isError = res.body?.result?.isError;
+        if (error) {
+          const correctCode = error.code === -32602;
+          return {
+            passed: true,
+            details: `Error code: ${error.code}${correctCode ? " (correct: Invalid params)" : ""} \u2014 ${error.message}`
+          };
+        }
+        if (isError) return { passed: true, details: "Tool execution error (valid)" };
+        return { passed: false, details: "No error for tools/call without name" };
+      }
+    );
+    await test("error-parse-code", "Returns -32700 for invalid JSON", "errors", false, "basic", async () => {
+      const res = await request2(backendUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json, text/event-stream",
+          ...buildHeaders2()
+        },
+        body: "<<<not json>>>",
+        signal: AbortSignal.timeout(timeout)
+      });
+      const text = await res.body.text();
+      try {
+        const body = JSON.parse(text);
+        if (body?.error?.code === -32700) {
+          return { passed: true, details: `Error code: -32700 (Parse error) \u2014 ${body.error.message}` };
+        }
+        if (body?.error) {
+          return { passed: false, details: `Expected -32700, got ${body.error.code} \u2014 ${body.error.message}` };
+        }
+      } catch {
+      }
+      if (res.statusCode >= 400 && res.statusCode < 500) {
+        return { passed: false, details: `HTTP ${res.statusCode} \u2014 server should return JSON-RPC error code -32700` };
+      }
+      return { passed: false, details: `HTTP ${res.statusCode} \u2014 expected error code -32700` };
+    });
+    await test(
+      "error-invalid-request-code",
+      "Returns -32600 for invalid request",
+      "errors",
+      false,
+      "basic",
+      async () => {
+        const res = await request2(backendUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            ...buildHeaders2()
+          },
+          body: JSON.stringify({ jsonrpc: "2.0", id: 99999 }),
+          signal: AbortSignal.timeout(timeout)
+        });
+        const text = await res.body.text();
+        try {
+          const body = JSON.parse(text);
+          if (body?.error?.code === -32600) {
+            return { passed: true, details: `Error code: -32600 (Invalid Request) \u2014 ${body.error.message}` };
+          }
+          if (body?.error) {
+            return { passed: false, details: `Expected -32600, got ${body.error.code} \u2014 ${body.error.message}` };
+          }
+        } catch {
+        }
+        if (res.statusCode >= 400 && res.statusCode < 500) {
+          return { passed: false, details: `HTTP ${res.statusCode} \u2014 server should return JSON-RPC error code -32600` };
+        }
+        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",
+      "Rejects unauthenticated requests",
+      "security",
+      false,
+      "basic/authorization",
+      async () => {
+        if (!hasAuth) {
+          return {
+            passed: false,
+            details: "Server does not require auth (no --auth provided and server accepted unauthenticated requests)"
+          };
+        }
+        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 || res.statusCode === 403) {
+            return { passed: true, details: `HTTP ${res.statusCode} (unauthenticated request rejected)` };
+          }
+          return { passed: false, details: `HTTP ${res.statusCode} \u2014 server accepted unauthenticated request` };
+        } catch (err) {
+          return { passed: true, details: "Connection rejected (acceptable)" };
+        }
+      }
+    );
+    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",
+      "security",
+      false,
+      "basic/authorization",
+      async () => {
+        if (!hasAuth) {
+          return { passed: false, details: "Skipped: server does not require auth" };
+        }
+        const malformedHeaders = {
+          Authorization: "Bearer INVALID_GARBAGE_TOKEN_!@#$%^&*()"
+        };
+        if (sessionId) malformedHeaders["mcp-session-id"] = sessionId;
+        try {
+          const res = await mcpRequest(backendUrl, "ping", void 0, nextId, malformedHeaders, timeout);
+          if (res.statusCode === 401 || res.statusCode === 403) {
+            return { passed: true, details: `HTTP ${res.statusCode} (malformed auth rejected)` };
+          }
+          return { passed: false, details: `HTTP ${res.statusCode} \u2014 server accepted malformed auth token` };
+        } catch (err) {
+          return { passed: true, details: "Connection rejected (acceptable)" };
+        }
+      }
+    );
+    await test("security-tls-required", "Enforces HTTPS/TLS", "security", false, "basic/authorization", async () => {
+      const parsedUrl = new URL(backendUrl);
+      if (parsedUrl.protocol !== "https:") {
+        return {
+          passed: false,
+          details: `Server URL uses ${parsedUrl.protocol} \u2014 production servers should use HTTPS`
+        };
+      }
+      const httpUrl = backendUrl.replace(/^https:/, "http:");
+      try {
+        const res = await request2(httpUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", Accept: "application/json" },
+          body: JSON.stringify({ jsonrpc: "2.0", id: 99950, method: "ping" }),
+          signal: AbortSignal.timeout(Math.min(timeout, 5e3))
+        });
+        await res.body.text();
+        if (res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 308) {
+          return { passed: true, details: `HTTP ${res.statusCode} redirect to HTTPS (good)` };
+        }
+        if (res.statusCode >= 400) {
+          return { passed: true, details: `HTTP ${res.statusCode} (plaintext rejected)` };
+        }
+        return { passed: false, details: `HTTP ${res.statusCode} \u2014 server accepts plaintext HTTP connections` };
+      } catch {
+        return { passed: true, details: "HTTP connection refused (HTTPS enforced)" };
+      }
+    });
+    await test(
+      "security-session-entropy",
+      "Session IDs are high-entropy",
+      "security",
+      false,
+      "basic/transports#streamable-http",
+      async () => {
+        if (!sessionId) {
+          return { passed: true, details: "Server does not issue session IDs (skipped)" };
+        }
+        if (sessionId.length < 16) {
+          return {
+            passed: false,
+            details: `Session ID too short (${sessionId.length} chars): "${sessionId}" \u2014 should be \u226516 chars`
+          };
+        }
+        if (/^\d+$/.test(sessionId)) {
+          return {
+            passed: false,
+            details: `Session ID is purely numeric: "${sessionId}" \u2014 likely sequential, not random`
+          };
+        }
+        const uniqueChars = new Set(sessionId.toLowerCase()).size;
+        if (uniqueChars < 8) {
+          return {
+            passed: false,
+            details: `Session ID has low character diversity (${uniqueChars} unique chars): "${sessionId}"`
+          };
+        }
+        return {
+          passed: true,
+          details: `Session ID has good entropy (${sessionId.length} chars, ${uniqueChars} unique): "${sessionId.substring(0, 16)}..."`
+        };
+      }
+    );
+    await test(
+      "security-session-not-auth",
+      "Session ID does not bypass auth",
+      "security",
+      false,
+      "basic/transports#streamable-http",
+      async () => {
+        if (!hasAuth) {
+          return { passed: true, details: "Skipped: server does not require auth" };
+        }
+        if (!sessionId) {
+          return { passed: true, details: "Skipped: server does not issue session IDs" };
+        }
+        const sessionOnlyHeaders = {
+          "mcp-session-id": sessionId
+        };
+        try {
+          const res = await mcpRequest(backendUrl, "ping", void 0, nextId, sessionOnlyHeaders, timeout);
+          if (res.statusCode === 401 || res.statusCode === 403) {
+            return { passed: true, details: `HTTP ${res.statusCode} (session ID alone not sufficient for auth)` };
+          }
+          return {
+            passed: false,
+            details: `HTTP ${res.statusCode} \u2014 server accepted session ID without auth (spec: MUST NOT use sessions for authentication)`
+          };
+        } catch {
+          return { passed: true, details: "Connection rejected (acceptable)" };
+        }
+      }
+    );
+    await test(
+      "security-oauth-metadata",
+      "Protected Resource Metadata endpoint exists",
+      "security",
+      false,
+      "basic/authorization",
+      async () => {
+        if (!hasAuth) {
+          return { passed: true, details: "Skipped: server does not require auth" };
+        }
+        const parsedUrl = new URL(backendUrl);
+        const prmUrl = `${parsedUrl.protocol}//${parsedUrl.host}/.well-known/oauth-protected-resource`;
+        try {
+          const res = await request2(prmUrl, {
+            method: "GET",
+            headers: { Accept: "application/json" },
+            signal: AbortSignal.timeout(Math.min(timeout, 5e3))
+          });
+          const text = await res.body.text();
+          if (res.statusCode === 200) {
+            try {
+              const meta = JSON.parse(text);
+              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: true,
+                details: `Protected Resource Metadata found: resource=${meta.resource}, ${meta.authorization_servers.length} auth server(s)`
+              };
+            } catch {
+              return { passed: false, details: "PRM endpoint returned non-JSON response" };
+            }
+          }
+          const legacyUrl = `${parsedUrl.protocol}//${parsedUrl.host}/.well-known/oauth-authorization-server`;
+          try {
+            const legacyRes = await request2(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: "PRM endpoint unreachable" };
+        }
+      }
+    );
+    await test(
+      "security-token-in-uri",
+      "Rejects auth tokens in query string",
+      "security",
+      false,
+      "basic/authorization",
+      async () => {
+        if (!hasAuth) {
+          return { passed: true, details: "Skipped: server does not require auth" };
+        }
+        const authValue = userHeaders.Authorization || userHeaders.authorization || "";
+        const token = authValue.replace(/^Bearer\s+/i, "");
+        if (!token) {
+          return { passed: true, details: "Skipped: could not extract token from auth header" };
+        }
+        const uriWithToken = `${backendUrl}${backendUrl.includes("?") ? "&" : "?"}access_token=${encodeURIComponent(token)}`;
+        try {
+          const noAuthHeaders = {};
+          if (sessionId) noAuthHeaders["mcp-session-id"] = sessionId;
+          const res = await mcpRequest(uriWithToken, "ping", void 0, nextId, noAuthHeaders, timeout);
+          if (res.statusCode === 401 || res.statusCode === 403) {
+            return { passed: true, details: `HTTP ${res.statusCode} (token in query string rejected)` };
+          }
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            return {
+              passed: false,
+              details: "Server accepted auth token in query string (spec: MUST NOT transmit credentials in URIs)"
+            };
+          }
+          return { passed: true, details: `HTTP ${res.statusCode} (token in query string not accepted)` };
+        } catch {
+          return { passed: true, details: "Connection rejected (acceptable)" };
+        }
+      }
+    );
+    await test(
+      "security-cors-headers",
+      "CORS headers are restrictive",
+      "security",
+      false,
+      "basic/transports#streamable-http",
+      async () => {
+        try {
+          const res = await request2(backendUrl, {
+            method: "OPTIONS",
+            headers: {
+              Origin: "https://evil.example.com",
+              "Access-Control-Request-Method": "POST",
+              ...buildHeaders2()
+            },
+            signal: AbortSignal.timeout(Math.min(timeout, 5e3))
+          });
+          await res.body.text();
+          const acao = res.headers["access-control-allow-origin"];
+          if (!acao) {
+            return { passed: true, details: "No CORS headers returned (server-to-server only, acceptable)" };
+          }
+          if (acao === "*") {
+            return {
+              passed: false,
+              details: 'Access-Control-Allow-Origin is "*" (wildcard) \u2014 allows cross-origin credential theft'
+            };
+          }
+          if (acao === "https://evil.example.com") {
+            return { passed: false, details: "Server reflects arbitrary Origin in CORS \u2014 effectively wildcard" };
+          }
+          return { passed: true, details: `CORS restricted to: ${acao}` };
+        } catch {
+          return { passed: true, details: "OPTIONS request failed (no CORS, acceptable)" };
+        }
+      }
+    );
+    await test(
+      "security-origin-validation",
+      "Validates Origin header on requests",
+      "security",
+      false,
+      "basic/transports#streamable-http",
+      async () => {
+        try {
+          const res = await request2(backendUrl, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Accept: "application/json, text/event-stream",
+              Origin: "https://evil-rebinding-attack.example.com",
+              ...buildHeaders2()
+            },
+            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)" };
+        }
+      }
+    );
+    const REJECTION_PATTERNS = [
+      /access denied/i,
+      /permission denied/i,
+      /not allowed/i,
+      /not permitted/i,
+      /outside (allowed|permitted)/i,
+      /forbidden/i,
+      /unauthorized/i,
+      /invalid (path|input|argument|parameter|request)/i,
+      /(payload|request) (rejected|blocked|refused)/i,
+      /enoent|eacces|eperm/i,
+      /sandbox(ed)?/i,
+      /(no such file|file not found)/i,
+      /\binvalid\b.*\b(input|json|argument|parameter|character)/i
+    ];
+    async function runInjectionTest(toolName, paramName, payloads, detectPattern, label) {
+      const issues = [];
+      let defended = 0;
+      for (const payload of payloads) {
+        try {
+          const res = await rpc("tools/call", { name: toolName, arguments: { [paramName]: payload } });
+          const result = res.body?.result;
+          const content = result?.content;
+          const isErrorFlag = result?.isError === true;
+          if (Array.isArray(content)) {
+            const text = content.map((c) => c.text || "").join(" ");
+            if (detectPattern.test(text)) {
+              if (looksRejected2(text, isErrorFlag)) {
+                defended++;
+              } else {
+                issues.push(`Payload "${payload}" ${label} (output: ${text.substring(0, 100)})`);
+              }
+            } else {
+              defended++;
+            }
+          }
+        } catch {
+          defended++;
+        }
+      }
+      if (issues.length > 0) return { passed: false, details: issues.join("; ") };
+      return {
+        passed: true,
+        details: defended === payloads.length ? `Tested ${payloads.length} payloads against ${toolName}.${paramName} \u2014 server defended (rejected or sanitized)` : `Tested ${payloads.length} payloads against ${toolName}.${paramName} \u2014 no ${label.split(" ")[0]} detected`
+      };
+    }
+    if (toolNames.length > 0) {
+      const allTools = cachedToolsList ?? [];
+      const toolsWithStringParams = allTools.filter((t) => {
+        const props = t.inputSchema?.properties;
+        if (!props) return false;
+        return Object.values(props).some((p) => p.type === "string");
+      });
+      const injectionTarget = toolsWithStringParams[0] || allTools[0];
+      const targetStringParam = injectionTarget?.inputSchema?.properties ? Object.entries(injectionTarget.inputSchema.properties).find(
+        ([_, v]) => v.type === "string"
+      )?.[0] ?? null : null;
+      await test(
+        "security-command-injection",
+        "Resists command injection in tool params",
+        "security",
+        false,
+        "server/tools#calling-tools",
+        async () => {
+          if (!injectionTarget || !targetStringParam)
+            return { passed: true, details: "No tools with string parameters to test" };
+          return runInjectionTest(
+            injectionTarget.name,
+            targetStringParam,
+            INJECTION_PAYLOADS.command,
+            /root:.*:\d+:\d+:.*:\/|uid=\d+\(\w+\)|drwxr|pwned/i,
+            "appears to have executed"
+          );
+        }
+      );
+      await test(
+        "security-sql-injection",
+        "Resists SQL injection in tool params",
+        "security",
+        false,
+        "server/tools#calling-tools",
+        async () => {
+          if (!injectionTarget || !targetStringParam)
+            return { passed: true, details: "No tools with string parameters to test" };
+          return runInjectionTest(
+            injectionTarget.name,
+            targetStringParam,
+            INJECTION_PAYLOADS.sql,
+            /syntax error|sql|mysql|postgres|sqlite|information_schema|table_name/i,
+            "triggered database error"
+          );
+        }
+      );
+      await test(
+        "security-path-traversal",
+        "Resists path traversal in tool params",
+        "security",
+        false,
+        "server/tools#calling-tools",
+        async () => {
+          if (!injectionTarget || !targetStringParam)
+            return { passed: true, details: "No tools with string parameters to test" };
+          return runInjectionTest(
+            injectionTarget.name,
+            targetStringParam,
+            INJECTION_PAYLOADS.pathTraversal,
+            /root:.*:0:0|\[boot loader\]|\[extensions\]/i,
+            "returned sensitive file content"
+          );
+        }
+      );
+      await test(
+        "security-ssrf-internal",
+        "Resists SSRF to internal networks",
+        "security",
+        false,
+        "server/tools#calling-tools",
+        async () => {
+          const urlParamTool = allTools.find((t) => {
+            const props = t.inputSchema?.properties;
+            if (!props) return false;
+            return Object.entries(props).some(
+              ([k, v]) => v.type === "string" && /url|uri|endpoint|link|href/i.test(k)
+            );
+          });
+          if (!urlParamTool) return { passed: true, details: "No tools with URL parameters found (skipped)" };
+          const urlParam = Object.entries(urlParamTool.inputSchema.properties).find(
+            ([k, v]) => v.type === "string" && /url|uri|endpoint|link|href/i.test(k)
+          )?.[0];
+          if (!urlParam) return { passed: true, details: "No URL parameter found" };
+          return runInjectionTest(
+            urlParamTool.name,
+            urlParam,
+            INJECTION_PAYLOADS.ssrf,
+            /ami-|instance-id|hostname|iam|security-credentials/i,
+            "returned internal data"
+          );
+        }
+      );
+    } else {
+      for (const testId of [
+        "security-command-injection",
+        "security-sql-injection",
+        "security-path-traversal",
+        "security-ssrf-internal"
+      ]) {
+        await test(
+          testId,
+          TEST_DEFINITIONS_MAP.get(testId)?.name || testId,
+          "security",
+          false,
+          "server/tools#calling-tools",
+          async () => ({ passed: true, details: "No tools available to test (skipped)" })
+        );
+      }
+    }
+    await test(
+      "security-oversized-input",
+      "Handles oversized inputs gracefully",
+      "security",
+      false,
+      "server/tools#calling-tools",
+      async () => {
+        const largeValue = "A".repeat(1048576);
+        try {
+          const res = await request2(backendUrl, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Accept: "application/json, text/event-stream",
+              ...buildHeaders2()
+            },
+            body: JSON.stringify({
+              jsonrpc: "2.0",
+              id: nextId(),
+              method: "tools/call",
+              params: { name: toolNames[0] || "test", arguments: { data: largeValue } }
+            }),
+            signal: AbortSignal.timeout(timeout)
+          });
+          await res.body.text();
+          if (res.statusCode === 413) {
+            return { passed: true, details: "HTTP 413 Payload Too Large (good)" };
+          }
+          if (res.statusCode >= 400) {
+            return { passed: true, details: `HTTP ${res.statusCode} (oversized input rejected)` };
+          }
+          return { passed: true, details: `HTTP ${res.statusCode} \u2014 server handled 1MB payload without crashing` };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (msg.includes("timeout") || msg.includes("abort")) {
+            return { passed: false, details: "Request timed out \u2014 server may be struggling with oversized input" };
+          }
+          return { passed: true, details: "Connection rejected (acceptable for oversized input)" };
+        }
+      }
+    );
+    await test(
+      "security-extra-params",
+      "Rejects or ignores extra tool params",
+      "security",
+      false,
+      "server/tools#calling-tools",
+      async () => {
+        if (toolNames.length === 0) {
+          return { passed: true, details: "No tools available to test (skipped)" };
+        }
+        try {
+          const res = await rpc("tools/call", {
+            name: toolNames[0],
+            arguments: { __injected_param__: "malicious_value", __proto__: { admin: true } }
+          });
+          const error = res.body?.error;
+          if (error) {
+            return { passed: true, details: `Extra params rejected with error: ${error.code} \u2014 ${error.message}` };
+          }
+          return { passed: true, details: "Server processed request (extra params likely ignored)" };
+        } catch {
+          return { passed: true, details: "Request rejected (acceptable)" };
+        }
+      }
+    );
+    await test(
+      "security-tool-schema-defined",
+      "All tools define inputSchema",
+      "security",
+      false,
+      "server/tools#data-types",
+      async () => {
+        if (!toolsListOk) return { passed: true, details: "Skipped: tools/list not available" };
+        const tools = cachedToolsList ?? [];
+        if (tools.length === 0) return { passed: true, details: "No tools to validate" };
+        const missing = tools.filter((t) => !t.inputSchema || t.inputSchema.type !== "object");
+        if (missing.length > 0) {
+          return {
+            passed: false,
+            details: `${missing.length} tool(s) missing inputSchema: ${missing.map((t) => t.name).join(", ")}`
+          };
+        }
+        return { passed: true, details: `All ${tools.length} tool(s) have inputSchema defined` };
+      }
+    );
+    await test(
+      "security-tool-rug-pull",
+      "Tool definitions are stable across calls",
+      "security",
+      false,
+      "server/tools#listing-tools",
+      async () => {
+        if (!toolsListOk) return { passed: true, details: "Skipped: tools/list not available" };
+        try {
+          const res = await rpc("tools/list");
+          const tools2 = res.body?.result?.tools;
+          if (!Array.isArray(tools2)) return { passed: false, details: "Second tools/list call failed" };
+          const tools1 = cachedToolsList ?? [];
+          if (tools1.length !== tools2.length) {
+            return {
+              passed: false,
+              details: `Tool count changed: ${tools1.length} \u2192 ${tools2.length} (possible rug-pull)`
+            };
+          }
+          const names1 = tools1.map((t) => t.name).sort().join(",");
+          const names2 = tools2.map((t) => t.name).sort().join(",");
+          if (names1 !== names2) {
+            return { passed: false, details: "Tool names changed between calls (possible rug-pull)" };
+          }
+          for (const t1 of tools1) {
+            const t2 = tools2.find((t) => t.name === t1.name);
+            if (t2 && t1.description !== t2.description) {
+              return {
+                passed: false,
+                details: `Tool "${t1.name}" description changed between calls (possible rug-pull)`
+              };
+            }
+          }
+          return { passed: true, details: `${tools1.length} tool(s) consistent across 2 calls` };
+        } catch {
+          return { passed: false, details: "Second tools/list call threw an error" };
+        }
+      }
+    );
+    await test(
+      "security-tool-description-poisoning",
+      "Tool descriptions free of injection patterns",
+      "security",
+      false,
+      "server/tools#data-types",
+      async () => {
+        if (!toolsListOk) return { passed: true, details: "Skipped: tools/list not available" };
+        const tools = cachedToolsList ?? [];
+        if (tools.length === 0) return { passed: true, details: "No tools to validate" };
+        const suspiciousPatterns = [
+          { pattern: /ignore\s+(all\s+)?previous/i, label: "ignore previous instructions" },
+          { pattern: /override\s+(system|instructions|rules)/i, label: "override instructions" },
+          { pattern: /system\s+prompt/i, label: "system prompt reference" },
+          { pattern: /you\s+must\s+(always|never)/i, label: "behavioral override" },
+          { pattern: /do\s+not\s+(tell|inform|mention)/i, label: "concealment instruction" },
+          { pattern: /\b[A-Za-z0-9+/]{40,}={0,2}\b/, label: "possible Base64-encoded payload" },
+          // Zero-width characters (U+200B, U+200C, U+200D, U+FEFF)
+          { pattern: /\u200B|\u200C|\u200D|\uFEFF/, label: "hidden Unicode characters" }
+        ];
+        const issues = [];
+        for (const tool of tools) {
+          const textsToCheck = [
+            tool.description || "",
+            ...tool.inputSchema?.properties ? Object.values(tool.inputSchema.properties).map((p) => p.description || "") : []
+          ];
+          const combined = textsToCheck.join(" ");
+          for (const { pattern, label } of suspiciousPatterns) {
+            if (pattern.test(combined)) {
+              issues.push(`Tool "${tool.name}": ${label}`);
+            }
+          }
+        }
+        if (issues.length > 0) return { passed: false, details: issues.join("; ") };
+        return { passed: true, details: `${tools.length} tool(s) scanned \u2014 no injection patterns found` };
+      }
+    );
+    await test(
+      "security-tool-cross-reference",
+      "Tools do not reference other tools by name",
+      "security",
+      false,
+      "server/tools#data-types",
+      async () => {
+        if (!toolsListOk) return { passed: true, details: "Skipped: tools/list not available" };
+        const tools = cachedToolsList ?? [];
+        if (tools.length < 2)
+          return { passed: true, details: "Fewer than 2 tools \u2014 cross-reference check not applicable" };
+        const names = tools.map((t) => t.name).filter(Boolean);
+        const issues = [];
+        for (const tool of tools) {
+          const desc = (tool.description || "").toLowerCase();
+          for (const otherName of names) {
+            if (otherName === tool.name) continue;
+            if (desc.includes(otherName.toLowerCase())) {
+              issues.push(`Tool "${tool.name}" description references "${otherName}"`);
+            }
+          }
+        }
+        if (issues.length > 0) {
+          warnings.push(`Cross-tool references found: ${issues.join("; ")}`);
+          return { passed: false, details: issues.join("; ") };
+        }
+        return { passed: true, details: `${tools.length} tool(s) checked \u2014 no cross-references found` };
+      }
+    );
+    await test(
+      "security-error-no-stacktrace",
+      "Error responses do not leak stack traces",
+      "security",
+      false,
+      "basic",
+      async () => {
+        const errorResponses = [];
+        const errorPayloads = [
+          "{this is not valid json!!!",
+          JSON.stringify({ jsonrpc: "2.0", id: nextId(), method: "nonexistent/___crash___test___" }),
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: nextId(),
+            method: "tools/call",
+            params: { name: "___nonexistent___tool___" }
+          })
+        ];
+        for (const payload of errorPayloads) {
+          try {
+            const res = await request2(backendUrl, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json, text/event-stream",
+                ...buildHeaders2()
+              },
+              body: payload,
+              signal: AbortSignal.timeout(timeout)
+            });
+            const text = await res.body.text();
+            errorResponses.push(text);
+          } catch {
+          }
+        }
+        const issues = [];
+        for (const text of errorResponses) {
+          for (const pattern of STACK_TRACE_PATTERNS) {
+            if (pattern.test(text)) {
+              issues.push(`Response contains: ${pattern.source} (matched in: ${text.substring(0, 80)}...)`);
+              break;
+            }
+          }
+        }
+        if (issues.length > 0) return { passed: false, details: issues.slice(0, 3).join("; ") };
+        return {
+          passed: true,
+          details: `${errorResponses.length} error responses checked \u2014 no stack traces or sensitive data found`
+        };
+      }
+    );
+    await test(
+      "security-error-no-internal-ip",
+      "Error responses do not leak internal IPs",
+      "security",
+      false,
+      "basic",
+      async () => {
+        try {
+          const res = await request2(backendUrl, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Accept: "application/json, text/event-stream",
+              ...buildHeaders2()
+            },
+            body: JSON.stringify({ jsonrpc: "2.0", id: nextId(), method: "___trigger_error___" }),
+            signal: AbortSignal.timeout(timeout)
+          });
+          const text = await res.body.text();
+          for (const pattern of INTERNAL_IP_PATTERNS) {
+            const match = text.match(pattern);
+            if (match) {
+              return { passed: false, details: `Error response contains internal IP: ${match[0]}` };
+            }
+          }
+          return { passed: true, details: "No internal IP addresses found in error responses" };
+        } catch {
+          return { passed: true, details: "No response to check (connection error)" };
+        }
+      }
+    );
+    await test(
+      "security-rate-limiting",
+      "Rate limiting is enforced",
+      "security",
+      false,
+      "basic/transports#streamable-http",
+      async () => {
+        const burstSize = 50;
+        let got429 = false;
+        const promises = Array.from(
+          { length: burstSize },
+          () => mcpRequest(backendUrl, "ping", void 0, nextId, buildHeaders2(), timeout).then((res) => {
+            if (res.statusCode === 429) got429 = true;
+            return res.statusCode;
+          }).catch(() => 0)
+        );
+        const statusCodes = await Promise.all(promises);
+        if (got429) {
+          return { passed: true, details: `Rate limiting detected (429 returned after ${burstSize} rapid requests)` };
+        }
+        const errorCount = statusCodes.filter((c) => c >= 500).length;
+        if (errorCount > burstSize / 2) {
+          return {
+            passed: false,
+            details: `Server returned ${errorCount}/${burstSize} 5xx errors under load \u2014 should return 429 instead of crashing`
+          };
+        }
+        return {
+          passed: false,
+          details: `No rate limiting detected (${burstSize} rapid requests all returned ${[...new Set(statusCodes)].join(",")})`
+        };
+      }
+    );
+    await test(
+      "transport-delete",
+      "DELETE accepted or returns 405",
+      "transport",
+      false,
+      "basic/transports#streamable-http",
+      async () => {
+        const deleteHeaders = { ...buildHeaders2() };
+        const res = await request2(backendUrl, {
+          method: "DELETE",
+          headers: deleteHeaders,
+          signal: AbortSignal.timeout(timeout)
+        });
+        await res.body.text();
+        if (res.statusCode === 405) {
+          return { passed: true, details: "HTTP 405 Method Not Allowed (acceptable)" };
+        }
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          if (sessionId) {
+            try {
+              const verifyRes = await mcpRequest(
+                backendUrl,
+                "ping",
+                void 0,
+                createIdCounter(99920),
+                deleteHeaders,
+                timeout
+              );
+              if (verifyRes.statusCode === 400 || verifyRes.statusCode === 404 || verifyRes.statusCode === 409) {
+                return {
+                  passed: true,
+                  details: `HTTP ${res.statusCode} (session terminated, post-delete request correctly rejected with ${verifyRes.statusCode})`
+                };
+              }
+            } catch {
+              return {
+                passed: true,
+                details: `HTTP ${res.statusCode} (session terminated, post-delete request rejected)`
+              };
+            }
+          }
+          return { passed: true, details: `HTTP ${res.statusCode} (session termination supported)` };
+        }
+        if (res.statusCode === 400 || res.statusCode === 404) {
+          return { passed: true, details: `HTTP ${res.statusCode} (no active session, acceptable)` };
+        }
+        return { passed: false, details: `HTTP ${res.statusCode}` };
+      }
+    );
+    await test(
+      "stdio-framing",
+      "Newline-delimited JSON framing",
+      "transport",
+      true,
+      "basic/transports#stdio",
+      async () => {
+        const results = await Promise.all(
+          Array.from({ length: 5 }, () => rpc("ping").catch((e) => ({ _err: e.message })))
+        );
+        const failed = results.filter((r) => "_err" in r);
+        if (failed.length) {
+          return { passed: false, details: `${failed.length}/5 rapid pings failed \u2014 framing likely broken` };
+        }
+        return { passed: true, details: "5/5 rapid pings returned cleanly" };
+      }
+    );
+    await test("stdio-unicode", "UTF-8 unicode roundtrip", "transport", false, "basic/transports#stdio", async () => {
+      const probe = "h\xE9llo \u4E16\u754C \u{1F680}";
+      if (hasTools && toolNames.length > 0) {
+        try {
+          const res2 = await rpc("tools/call", {
+            name: toolNames[0],
+            arguments: { message: probe, text: probe, input: probe, query: probe }
+          });
+          const serialized = JSON.stringify(res2.body);
+          if (serialized.includes(probe)) {
+            return { passed: true, details: "Unicode string round-tripped through tool call" };
+          }
+          return { passed: true, details: "Tool echoed something, but not the exact probe \u2014 likely still UTF-8-safe" };
+        } catch (err) {
+          return { passed: false, details: `tools/call threw \u2014 ${err instanceof Error ? err.message : String(err)}` };
+        }
+      }
+      const res = await rpc("tools/list");
+      if (res.body.error) {
+        return { passed: false, details: "tools/list returned error" };
+      }
+      return { passed: true, details: "tools/list returned successfully (no tools to probe with unicode)" };
+    });
+    await test(
+      "stdio-unknown-method-recovers",
+      "Recovers after unknown method",
+      "transport",
+      false,
+      "basic/transports#stdio",
+      async () => {
+        const errRes = await rpc("this/method/does/not/exist-xyzzy");
+        const errBody = errRes.body;
+        if (!errBody.error) {
+          return { passed: false, details: "Unknown method did not produce a JSON-RPC error" };
+        }
+        const okRes = await rpc("ping");
+        const okBody = okRes.body;
+        if (okBody.error) {
+          return {
+            passed: false,
+            details: "Server responded with error to ping after unknown method \u2014 may have desynced"
+          };
+        }
+        return { passed: true, details: "Unknown method returned JSON-RPC error; subsequent ping succeeded" };
+      }
+    );
+    const MAX_WARNINGS = 100;
+    if (warnings.length > MAX_WARNINGS) {
+      const truncated = warnings.length - MAX_WARNINGS;
+      warnings.splice(MAX_WARNINGS, truncated, `... and ${truncated} more warning(s) suppressed`);
+    }
+    const { score, grade, overall, summary, categories } = computeScore(tests);
+    const badge = generateBadge(displayUrl);
+    return {
+      specVersion: SPEC_VERSION,
+      toolVersion: TOOL_VERSION,
+      url: displayUrl,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      score,
+      grade,
+      overall,
+      summary,
+      categories,
+      tests,
+      warnings,
+      serverInfo,
+      toolCount,
+      toolNames,
+      resourceCount,
+      resourceNames,
+      promptCount,
+      promptNames,
+      badge
+    };
+  } finally {
+    await transport.close().catch(() => {
+    });
+  }
+}
+
+export {
+  generateBadge,
+  computeGrade,
+  computeScore,
+  parseSSEResponse,
+  TEST_DEFINITIONS,
+  SPEC_VERSION,
+  SPEC_BASE,
+  previewTests,
+  runComplianceSuite
+};