@agentwares/agentguard 0.1.9 → 0.1.10

package/dist/{chunk-ZSLWPKXI.js → chunk-IS3DAHZI.js}

@@ -1,4 +1,4 @@
-// ../../packages/mcp-kit/dist/chunk-7LRFDQNC.js
+// ../../packages/mcp-kit/dist/chunk-VX7P4M7P.js
 import { completable } from "@modelcontextprotocol/sdk/server/completable.js";
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import {
@@ -112,9 +112,12 @@ var StubVerifier = class {
   }
 };
 
-// ../../packages/mcp-kit/dist/chunk-7LRFDQNC.js
+// ../../packages/mcp-kit/dist/chunk-VX7P4M7P.js
 import { z as z2 } from "zod";
 import { z as z3 } from "zod";
+import {
+  SUPPORTED_PROTOCOL_VERSIONS
+} from "@modelcontextprotocol/sdk/types.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import {
   CallToolRequestSchema,
@@ -669,6 +672,379 @@ var examplePaidLookup = withPayment(
   }),
   { priceUsd: 0.05, description: "One record lookup" }
 );
+var MODERN_PROTOCOL_VERSION = "2026-07-28";
+var MODERN_PROTOCOL_VERSIONS = [MODERN_PROTOCOL_VERSION];
+var LEGACY_PROTOCOL_VERSIONS = [...SUPPORTED_PROTOCOL_VERSIONS];
+var SERVED_PROTOCOL_VERSIONS = [
+  ...MODERN_PROTOCOL_VERSIONS,
+  ...LEGACY_PROTOCOL_VERSIONS
+];
+var MODERN_META = {
+  protocolVersion: "io.modelcontextprotocol/protocolVersion",
+  clientInfo: "io.modelcontextprotocol/clientInfo",
+  clientCapabilities: "io.modelcontextprotocol/clientCapabilities",
+  logLevel: "io.modelcontextprotocol/logLevel",
+  serverInfo: "io.modelcontextprotocol/serverInfo"
+};
+var MODERN_ERROR_CODES = {
+  HeaderMismatch: -32020,
+  MissingRequiredClientCapability: -32021,
+  UnsupportedProtocolVersion: -32022
+};
+var INVALID_REQUEST = -32600;
+var METHOD_NOT_FOUND = -32601;
+var INVALID_PARAMS = -32602;
+var INTERNAL_ERROR = -32603;
+var NOT_MODERN = /* @__PURE__ */ new Set([
+  "initialize",
+  "ping",
+  "logging/setLevel",
+  "resources/subscribe",
+  "resources/unsubscribe",
+  "subscriptions/listen"
+]);
+var CACHEABLE = /* @__PURE__ */ new Set([
+  "server/discover",
+  "tools/list",
+  "prompts/list",
+  "resources/list",
+  "resources/read",
+  "resources/templates/list"
+]);
+var LOG_LEVELS = [
+  "debug",
+  "info",
+  "notice",
+  "warning",
+  "error",
+  "critical",
+  "alert",
+  "emergency"
+];
+var STATIC_TTL_MS = 3e5;
+var STATIC_LISTING = /* @__PURE__ */ Symbol.for("@agentwares/mcp-kit/static-listing");
+function markStaticListing(server) {
+  server[STATIC_LISTING] = true;
+}
+function hasStaticListing(server) {
+  return server[STATIC_LISTING] === true;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requestId(value) {
+  return typeof value === "string" || typeof value === "number" ? value : null;
+}
+function modernClaim(message) {
+  if (!isObject(message) || !isObject(message["params"])) return void 0;
+  const meta = message["params"]["_meta"];
+  return isObject(meta) ? meta[MODERN_META.protocolVersion] : void 0;
+}
+function unsupportedVersionError(requested) {
+  return {
+    code: MODERN_ERROR_CODES.UnsupportedProtocolVersion,
+    message: `Unsupported protocol version: ${requested}. Supported: ${SERVED_PROTOCOL_VERSIONS.join(", ")}`,
+    data: { supported: [...SERVED_PROTOCOL_VERSIONS], requested }
+  };
+}
+function routeModern(message) {
+  if (!isObject(message) || typeof message["method"] !== "string") return { kind: "legacy" };
+  const claim = modernClaim(message);
+  if (claim === void 0) return { kind: "legacy" };
+  const method = message["method"];
+  const hasId = "id" in message;
+  const id = requestId(message["id"]);
+  if (typeof claim !== "string") {
+    return {
+      kind: "reject",
+      id,
+      status: 400,
+      error: { code: INVALID_PARAMS, message: `${MODERN_META.protocolVersion} must be a string` }
+    };
+  }
+  if (LEGACY_PROTOCOL_VERSIONS.includes(claim)) return { kind: "legacy" };
+  if (!MODERN_PROTOCOL_VERSIONS.includes(claim)) {
+    return { kind: "reject", id, status: 400, error: unsupportedVersionError(claim) };
+  }
+  if (!hasId) return { kind: "notification" };
+  if (id === null) {
+    return {
+      kind: "reject",
+      id: null,
+      status: 400,
+      error: { code: INVALID_REQUEST, message: "a request id must be a string or a number" }
+    };
+  }
+  const meta = message["params"]["_meta"];
+  if (!isObject(meta[MODERN_META.clientCapabilities])) {
+    return {
+      kind: "reject",
+      id,
+      status: 400,
+      error: {
+        code: INVALID_PARAMS,
+        message: `Missing required _meta field ${MODERN_META.clientCapabilities} (an object; {} when the client declares none)`
+      }
+    };
+  }
+  if (method === "server/discover") return { kind: "discover", id, method, version: claim };
+  if (NOT_MODERN.has(method)) {
+    return {
+      kind: "reject",
+      id,
+      status: 404,
+      error: {
+        code: METHOD_NOT_FOUND,
+        message: method === "initialize" ? `Method not found: initialize is not part of ${claim}; call server/discover, or send initialize without the ${MODERN_META.protocolVersion} _meta field to open a 2025-era session` : `Method not found: ${method} is not served at ${claim}`
+      }
+    };
+  }
+  const level = meta[MODERN_META.logLevel];
+  return {
+    kind: "dispatch",
+    id,
+    method,
+    version: claim,
+    ...typeof level === "string" ? { logLevel: level } : {}
+  };
+}
+function nameSource(method, params) {
+  if (!isObject(params)) return void 0;
+  const field = method === "tools/call" || method === "prompts/get" ? "name" : method === "resources/read" ? "uri" : void 0;
+  const value = field ? params[field] : void 0;
+  return typeof value === "string" ? value : void 0;
+}
+function decodeHeaderValue(value) {
+  const match = /^=\?base64\?(.*)\?=$/.exec(value);
+  if (!match) return value;
+  try {
+    const bytes = Uint8Array.from(atob(match[1] ?? ""), (c) => c.charCodeAt(0));
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return void 0;
+  }
+}
+function headerMismatch(id, message) {
+  return {
+    kind: "reject",
+    id,
+    status: 400,
+    error: { code: MODERN_ERROR_CODES.HeaderMismatch, message: `Header mismatch: ${message}` }
+  };
+}
+function checkModernHeaders(headers, message, version) {
+  const { id, method } = message;
+  const protocolHeader = headers.get("mcp-protocol-version")?.trim();
+  if (protocolHeader === void 0) {
+    return headerMismatch(id, "the required MCP-Protocol-Version header is missing");
+  }
+  if (protocolHeader !== version) {
+    return headerMismatch(
+      id,
+      `MCP-Protocol-Version header value '${protocolHeader}' does not match body value '${version}'`
+    );
+  }
+  const methodHeader = headers.get("mcp-method")?.trim();
+  if (methodHeader === void 0) {
+    return headerMismatch(id, "the required Mcp-Method header is missing");
+  }
+  if (methodHeader !== method) {
+    return headerMismatch(
+      id,
+      `Mcp-Method header value '${methodHeader}' does not match body value '${method}'`
+    );
+  }
+  const bodyName = nameSource(method, message.params);
+  if (bodyName === void 0) return void 0;
+  const nameHeader = headers.get("mcp-name")?.trim();
+  if (nameHeader === void 0) {
+    return headerMismatch(id, `the required Mcp-Name header is missing (body value '${bodyName}')`);
+  }
+  const decoded = decodeHeaderValue(nameHeader);
+  if (decoded === void 0) {
+    return headerMismatch(id, "the Mcp-Name header carries an invalid =?base64?\u2026?= value");
+  }
+  if (decoded !== bodyName) {
+    return headerMismatch(
+      id,
+      `Mcp-Name header value '${decoded}' does not match body value '${bodyName}'`
+    );
+  }
+  return void 0;
+}
+function checkLegacyHeader(headers, message) {
+  if (!isObject(message) || message["method"] === "initialize") return void 0;
+  const header = headers.get("mcp-protocol-version")?.trim();
+  if (!header || LEGACY_PROTOCOL_VERSIONS.includes(header)) return void 0;
+  const id = requestId(message["id"]);
+  if (MODERN_PROTOCOL_VERSIONS.includes(header)) {
+    return {
+      kind: "reject",
+      id,
+      status: 400,
+      error: {
+        code: INVALID_PARAMS,
+        message: `Missing required _meta field ${MODERN_META.protocolVersion}: MCP-Protocol-Version says ${header}, which carries its version in each request's params._meta`
+      }
+    };
+  }
+  return { kind: "reject", id, status: 400, error: unsupportedVersionError(header) };
+}
+function internals(server) {
+  return server.server;
+}
+function serverInfoOf(server) {
+  const info = internals(server)._serverInfo;
+  return info ? { ...info } : { name: "mcp-server", version: "0.0.0" };
+}
+function modernCapabilities(capabilities) {
+  const out = {};
+  for (const [key, value] of Object.entries(capabilities)) {
+    if (key === "tasks" || value === void 0) continue;
+    if (isObject(value) && (key === "tools" || key === "prompts" || key === "resources")) {
+      const { listChanged: _listChanged, subscribe: _subscribe, ...rest } = value;
+      out[key] = rest;
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function cacheHints(server, method) {
+  const isStatic = hasStaticListing(server) && (method === "server/discover" || method === "tools/list");
+  return isStatic ? { ttlMs: STATIC_TTL_MS, cacheScope: "public" } : { ttlMs: 0, cacheScope: "private" };
+}
+function discoverResult(server) {
+  const instructions = internals(server)._instructions;
+  return {
+    resultType: "complete",
+    supportedVersions: [...SERVED_PROTOCOL_VERSIONS],
+    capabilities: modernCapabilities(internals(server).getCapabilities()),
+    ...instructions ? { instructions } : {},
+    ...cacheHints(server, "server/discover"),
+    _meta: { [MODERN_META.serverInfo]: serverInfoOf(server) }
+  };
+}
+function decorateResult(server, method, result) {
+  const meta = isObject(result["_meta"]) ? { ...result["_meta"] } : {};
+  if (meta[MODERN_META.serverInfo] === void 0) {
+    meta[MODERN_META.serverInfo] = serverInfoOf(server);
+  }
+  const out = { resultType: "complete", ...result, _meta: meta };
+  if (CACHEABLE.has(method)) {
+    const hints = cacheHints(server, method);
+    if (out["ttlMs"] === void 0) out["ttlMs"] = hints.ttlMs;
+    if (out["cacheScope"] === void 0) out["cacheScope"] = hints.cacheScope;
+  }
+  return out;
+}
+function logAllowed(requested, level) {
+  if (requested === void 0) return false;
+  const floor = LOG_LEVELS.indexOf(requested);
+  const at = LOG_LEVELS.indexOf(String(level));
+  return floor !== -1 && at !== -1 && at >= floor;
+}
+function errorMessage(id, error) {
+  return { jsonrpc: "2.0", id, error };
+}
+function messageId(message) {
+  const id = message.id;
+  return typeof id === "string" || typeof id === "number" ? id : void 0;
+}
+function isResponse(message) {
+  return !("method" in message) && ("result" in message || "error" in message);
+}
+var DualEraTransport = class {
+  constructor(inner, server) {
+    this.inner = inner;
+    this.server = server;
+  }
+  inner;
+  server;
+  onclose;
+  onerror;
+  onmessage;
+  modern = /* @__PURE__ */ new Map();
+  get sessionId() {
+    return this.inner.sessionId;
+  }
+  setProtocolVersion(version) {
+    this.inner.setProtocolVersion?.(version);
+  }
+  async start() {
+    this.inner.onmessage = (message, extra) => this.receive(message, extra);
+    this.inner.onclose = () => this.onclose?.();
+    this.inner.onerror = (error) => this.onerror?.(error);
+    await this.inner.start();
+  }
+  async close() {
+    await this.inner.close();
+  }
+  write(message) {
+    this.inner.send(message).catch((error) => {
+      this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+    });
+  }
+  receive(message, extra) {
+    const route = routeModern(message);
+    switch (route.kind) {
+      case "legacy":
+      case "notification":
+        this.onmessage?.(message, extra);
+        return;
+      case "reject":
+        if ("id" in message) this.write(errorMessage(route.id, route.error));
+        return;
+      case "discover":
+        this.write({
+          jsonrpc: "2.0",
+          id: route.id,
+          result: discoverResult(this.server)
+        });
+        return;
+      case "dispatch":
+        this.modern.set(route.id, {
+          method: route.method,
+          ...route.logLevel !== void 0 ? { logLevel: route.logLevel } : {}
+        });
+        this.onmessage?.(message, extra);
+        return;
+    }
+  }
+  async send(message, options) {
+    const id = messageId(message);
+    if (id !== void 0 && isResponse(message)) {
+      const request = this.modern.get(id);
+      if (request) {
+        this.modern.delete(id);
+        const result = message.result;
+        if (isObject(result)) {
+          message = {
+            ...message,
+            result: decorateResult(this.server, request.method, result)
+          };
+        }
+      }
+      return this.inner.send(message, options);
+    }
+    const related = options?.relatedRequestId !== void 0 ? this.modern.get(options.relatedRequestId) : void 0;
+    if (related && "method" in message) {
+      if (id !== void 0) {
+        const refusal = errorMessage(id, {
+          code: INTERNAL_ERROR,
+          message: `${message.method} cannot reach a ${MODERN_PROTOCOL_VERSION} client from this server (multi round-trip requests are not served); call this tool from a 2025-era session (initialize) instead`
+        });
+        queueMicrotask(() => this.onmessage?.(refusal));
+        return;
+      }
+      if (message.method === "notifications/message") {
+        const level = message.params?.level;
+        if (!logAllowed(related.logLevel, level)) return;
+      }
+    }
+    return this.inner.send(message, options);
+  }
+};
 function isZodObject(schema) {
   return schema instanceof z4.ZodObject;
 }
@@ -749,6 +1125,7 @@ function createMcpServer(opts) {
       return tool.invoke(request.params.arguments ?? {}, contextFromExtra(extra));
     });
   }
+  markStaticListing(server);
   return server;
 }
 function toJsonSchema(schema, io = "input") {
@@ -774,7 +1151,7 @@ function listToolManifest(tools) {
 var DEFAULT_CORS = {
   origin: "*",
   methods: "GET, POST, DELETE, OPTIONS",
-  headers: "Content-Type, Accept, Authorization, Mcp-Session-Id, Mcp-Protocol-Version, Last-Event-ID, PAYMENT, X-PAYMENT",
+  headers: "Content-Type, Accept, Authorization, Mcp-Session-Id, Mcp-Protocol-Version, Mcp-Method, Mcp-Name, Last-Event-ID, PAYMENT, X-PAYMENT",
   exposeHeaders: "Mcp-Session-Id, Mcp-Protocol-Version, WWW-Authenticate, X-Payment-Requirements, PAYMENT-REQUIRED",
   maxAge: 86400
 };
@@ -801,7 +1178,7 @@ function methodNotAllowed(method, allow, cors) {
     {
       code: "METHOD_NOT_ALLOWED",
       cause: `${method} is not supported here without a session`,
-      fix: "send JSON-RPC over POST with `Accept: application/json, text/event-stream` (start with `initialize`)",
+      fix: `send JSON-RPC over POST with \`Accept: application/json, text/event-stream\`: at ${MODERN_PROTOCOL_VERSION}, any request with its version in params._meta (start with \`server/discover\`); on a 2025-era client, start with \`initialize\``,
       retryable: false
     },
     405,
@@ -908,7 +1285,7 @@ function createStatefulHandler({ factory, cors, transportBase }, options) {
           {
             code: "NOT_FOUND",
             cause: "unknown or expired Mcp-Session-Id",
-            fix: "send `initialize` again without an Mcp-Session-Id header and use the id from the response",
+            fix: `send \`initialize\` again without an Mcp-Session-Id header and use the id from the response, or drop the header and send the request at ${MODERN_PROTOCOL_VERSION} (version in params._meta), which needs no session`,
             retryable: true
           },
           404,
@@ -951,6 +1328,173 @@ function createStatefulHandler({ factory, cors, transportBase }, options) {
     }
   };
 }
+function rpcErrorResponse(route, cors) {
+  return jsonResponse(errorMessage(route.id, route.error), route.status, cors);
+}
+function rebindingError(request, base) {
+  if (!base.enableDnsRebindingProtection) return void 0;
+  if (base.allowedHosts?.length) {
+    const host = request.headers.get("host");
+    if (!host || !base.allowedHosts.includes(host)) return `Invalid Host header: ${host}`;
+  }
+  if (base.allowedOrigins?.length) {
+    const origin = request.headers.get("origin");
+    if (origin && !base.allowedOrigins.includes(origin)) return `Invalid Origin header: ${origin}`;
+  }
+  return void 0;
+}
+async function peek(request) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await request.clone().text());
+  } catch {
+    return { kind: "legacy" };
+  }
+  if (Array.isArray(parsed)) {
+    if (!parsed.some((element) => modernClaim(element) !== void 0)) return { kind: "legacy" };
+    return {
+      kind: "reject",
+      route: {
+        kind: "reject",
+        id: null,
+        status: 400,
+        error: { code: -32600, message: "a JSON-RPC batch cannot carry 2026-07-28 requests" }
+      }
+    };
+  }
+  const route = routeModern(parsed);
+  if (route.kind === "legacy") {
+    const refused = checkLegacyHeader(request.headers, parsed);
+    return refused?.kind === "reject" ? { kind: "reject", route: refused } : { kind: "legacy" };
+  }
+  return { kind: "modern", message: parsed, route };
+}
+var SinkTransport = class {
+  constructor(out) {
+    this.out = out;
+  }
+  out;
+  onclose;
+  onerror;
+  onmessage;
+  async start() {
+  }
+  async send(message) {
+    this.out(message);
+  }
+  async close() {
+    this.onclose?.();
+  }
+};
+var encoder = new TextEncoder();
+function sseEvent(message) {
+  return encoder.encode(`event: message
+data: ${JSON.stringify(message)}
+
+`);
+}
+function statusFor(message) {
+  return message.error?.code === -32601 ? 404 : 200;
+}
+async function serveModern(request, message, route, { factory, cors, transportBase }) {
+  const rebinding = rebindingError(request, transportBase);
+  if (rebinding) {
+    return jsonResponse(errorMessage(null, { code: -32600, message: rebinding }), 403, cors);
+  }
+  if (route.kind === "reject") return rpcErrorResponse(route, cors);
+  if (route.kind === "notification") return new Response(null, { status: 202, headers: cors });
+  if (route.kind === "legacy") throw new Error("unreachable: legacy requests take the SDK path");
+  const headerError = checkModernHeaders(
+    request.headers,
+    { method: route.method, id: route.id, params: message["params"] },
+    route.version
+  );
+  if (headerError?.kind === "reject") return rpcErrorResponse(headerError, cors);
+  const server = factory();
+  const streams = !transportBase.enableJsonResponse && (request.headers.get("accept") ?? "").includes("text/event-stream");
+  let closed = false;
+  const cleanup = async () => {
+    if (closed) return;
+    closed = true;
+    await server.close().catch(() => void 0);
+  };
+  let settle;
+  const first = new Promise((resolve) => settle = resolve);
+  let settled = false;
+  let controller;
+  let ended = false;
+  const deliver = (out) => {
+    const final = !("method" in out) && out.id === route.id;
+    if (!settled) {
+      if (final) {
+        settled = true;
+        settle({ kind: "json", message: out });
+        return;
+      }
+      if (!streams) return;
+      settled = true;
+      const body = new ReadableStream({
+        start: (c) => {
+          controller = c;
+        },
+        cancel: () => cleanup()
+      });
+      controller?.enqueue(sseEvent(out));
+      settle({ kind: "sse", body });
+      return;
+    }
+    if (ended || !controller) return;
+    controller.enqueue(sseEvent(out));
+    if (final) {
+      ended = true;
+      controller.close();
+      void cleanup();
+    }
+  };
+  const sink = new SinkTransport(deliver);
+  const era = new DualEraTransport(sink, server);
+  request.signal?.addEventListener(
+    "abort",
+    () => {
+      void cleanup();
+      if (!settled) {
+        settled = true;
+        settle({
+          kind: "json",
+          message: errorMessage(route.id, { code: -32603, message: "request aborted" })
+        });
+      }
+    },
+    { once: true }
+  );
+  try {
+    await server.connect(era);
+    const headers = {};
+    request.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    sink.onmessage?.(message, {
+      requestInfo: { headers, url: new URL(request.url) }
+    });
+    const answer = await first;
+    if (answer.kind === "json") {
+      await cleanup();
+      return jsonResponse(answer.message, statusFor(answer.message), cors);
+    }
+    return new Response(answer.body, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "X-Accel-Buffering": "no",
+        ...cors
+      }
+    });
+  } catch (err) {
+    await cleanup();
+    return errorResponse(err, cors);
+  }
+}
 function createHttpHandler(opts, transportOptions = {}) {
   const { factory, transport: t } = splitOptions(opts, transportOptions);
   const cors = corsHeaders(t.cors);
@@ -971,6 +1515,13 @@ function createHttpHandler(opts, transportOptions = {}) {
     if (request.method === "OPTIONS") {
       return new Response(null, { status: 204, headers: { Allow: allow, ...cors } });
     }
+    if (request.method === "POST") {
+      const peeked = await peek(request);
+      if (peeked.kind === "reject") return rpcErrorResponse(peeked.route, cors);
+      if (peeked.kind === "modern") {
+        return serveModern(request, peeked.message, peeked.route, context);
+      }
+    }
     return handler(request);
   };
 }
@@ -1114,10 +1665,13 @@ async function readAllPages(fetchPage, opts = {}) {
 
 // ../../packages/mcp-kit/dist/index.js
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
-async function serveStdio(serverOrOpts) {
+async function serveStdio(serverOrOpts, streams = {}) {
   const server = serverOrOpts instanceof McpServer2 ? serverOrOpts : createMcpServer(serverOrOpts);
   const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
-  const transport = new StdioServerTransport();
+  const transport = new DualEraTransport(
+    new StdioServerTransport(streams.stdin, streams.stdout),
+    server
+  );
   await server.connect(transport);
   await new Promise((resolve) => {
     const previous = transport.onclose;
@@ -1141,4 +1695,4 @@ export {
   readAllPages,
   serveStdio
 };
-//# sourceMappingURL=chunk-ZSLWPKXI.js.map
+//# sourceMappingURL=chunk-IS3DAHZI.js.map