@modelcontextprotocol/inspector 2.6.0 → 2.7.0

package/clients/web/build/index.js

@@ -91,6 +91,7 @@ async function deleteStoreFile(filePath) {
 
 // ../../core/mcp/types.ts
 var DEFAULT_TASK_TTL_MS = 6e4;
+var DEFAULT_CONNECTION_TIMEOUT_MS = 3e4;
 var DEFAULT_MAX_FETCH_REQUESTS = 1e3;
 var DEFAULT_PROTOCOL_ERA = "legacy";
 var DEFAULT_MODERN_LOG_LEVEL = "debug";
@@ -109,6 +110,139 @@ function isModernLogLevel(value) {
   return typeof value === "string" && MODERN_LOG_LEVELS.includes(value);
 }
 
+// ../../core/mcp/skillsSchemas.ts
+import { z } from "zod/v4";
+import { ResourceSchema } from "@modelcontextprotocol/core";
+var DYNAMIC_RESOURCES = "dynamic";
+var SkillFrontmatterSchema = z.looseObject({
+  name: z.string().optional(),
+  description: z.string().optional()
+});
+var SkillResourceSchema = z.looseObject({
+  uri: z.string(),
+  digest: z.string().optional(),
+  size: z.number().optional()
+});
+var SkillEntrySchema = z.looseObject({
+  uri: z.string(),
+  frontmatter: SkillFrontmatterSchema,
+  resources: z.union([
+    z.literal(DYNAMIC_RESOURCES),
+    z.array(SkillResourceSchema)
+  ])
+});
+var ListSkillsResultSchema = z.looseObject({
+  skills: z.array(SkillEntrySchema),
+  nextCursor: z.string().optional()
+});
+var ModernListSkillsResultSchema = ListSkillsResultSchema.extend({
+  // A non-negative INTEGER, matching the codec: `ttlMs: -1` or `0.5` is an
+  // envelope violation, and accepting it here would hide exactly the kind of
+  // defect this schema exists to surface.
+  ttlMs: z.int().min(0),
+  cacheScope: z.enum(["public", "private"])
+});
+var GetSkillEnvelopeSchema = z.looseObject({
+  skill: SkillEntrySchema
+});
+var GetSkillResultSchema = GetSkillEnvelopeSchema.transform(
+  (result) => result.skill
+);
+var DirectoryChildSchema = ResourceSchema;
+var DirectoryReadResultSchema = z.looseObject({
+  resources: z.array(DirectoryChildSchema),
+  nextCursor: z.string().optional()
+});
+
+// ../../core/mcp/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var H0 = new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// ../../core/mcp/skillFile.ts
+import { parse as parseYaml } from "yaml";
+
+// ../../core/mcp/skills.ts
+var SKILL_MAX_TOTAL_BYTES = 16 * 1024 * 1024;
+var SKILL_MAX_CATALOG_SKILLS = 256;
+var SKILL_MAX_CATALOG_BYTES = 64 * 1024 * 1024;
+function isSkillCatalogLimit(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+
 // ../../core/auth/secret-fields.ts
 var SECRET_FIELD_OAUTH_CLIENT_SECRET = "oauth-client-secret";
 var SECRET_FIELD_IDP_CLIENT_SECRET = "idp-client-secret";
@@ -290,16 +424,19 @@ function cleanEndpointOverride(value, field) {
   return value.trim() || void 0;
 }
 function storedFieldsToInspectorSettings(stored) {
-  const hasAny = stored.headers !== void 0 || stored.metadata !== void 0 || stored.connectionTimeout !== void 0 || stored.requestTimeout !== void 0 || stored.taskTtl !== void 0 || stored.autoRefreshOnListChanged !== void 0 || stored.paginatedLists !== void 0 || stored.advertisedExtensions !== void 0 || stored.maxFetchRequests !== void 0 || stored.oauth !== void 0 || stored.roots !== void 0 || stored.protocolEra !== void 0 || stored.modernLogLevel !== void 0 || stored.env !== void 0 || stored.cwd !== void 0;
+  const hasAny = stored.headers !== void 0 || stored.metadata !== void 0 || stored.connectionTimeout !== void 0 || stored.requestTimeout !== void 0 || stored.taskTtl !== void 0 || stored.autoRefreshOnListChanged !== void 0 || stored.paginatedLists !== void 0 || stored.advertisedExtensions !== void 0 || stored.maxFetchRequests !== void 0 || stored.skillCatalogMaxSkills !== void 0 || stored.skillCatalogMaxBytes !== void 0 || stored.oauth !== void 0 || stored.roots !== void 0 || stored.protocolEra !== void 0 || stored.modernLogLevel !== void 0 || stored.env !== void 0 || stored.cwd !== void 0;
   if (!hasAny) return void 0;
   const headersPairs = stored.headers ? Object.entries(stored.headers).map(([key, value]) => ({ key, value })) : [];
   const settings = {
     headers: headersPairs,
     env: envRecordToPairs(stored.env),
     metadata: normalizeStoredMetadata(stored.metadata),
-    connectionTimeout: stored.connectionTimeout ?? 0,
+    // Concrete product default, like taskTtl below: an absent field reads back
+    // as 30 s so the form shows the bound that will actually apply. An explicit
+    // 0 is preserved as-is — it is the user's opt-out, not a sentinel (#2320).
+    connectionTimeout: stored.connectionTimeout ?? DEFAULT_CONNECTION_TIMEOUT_MS,
     requestTimeout: stored.requestTimeout ?? 0,
-    // Unlike the timeouts (0 = "SDK default"), task TTL has a concrete product
+    // Unlike requestTimeout (0 = "SDK default"), task TTL has a concrete product
     // default so the form shows it and "Run as task" has a value to send.
     taskTtl: stored.taskTtl ?? DEFAULT_TASK_TTL_MS,
     autoRefreshOnListChanged: stored.autoRefreshOnListChanged ?? false,
@@ -313,6 +450,12 @@ function storedFieldsToInspectorSettings(stored) {
     // `[]`, which `inspectorSettingsToStoredFields` then omits on write.
     roots: stored.roots ?? []
   };
+  if (isSkillCatalogLimit(stored.skillCatalogMaxSkills)) {
+    settings.skillCatalogMaxSkills = stored.skillCatalogMaxSkills;
+  }
+  if (isSkillCatalogLimit(stored.skillCatalogMaxBytes)) {
+    settings.skillCatalogMaxBytes = stored.skillCatalogMaxBytes;
+  }
   if (isProtocolEra(stored.protocolEra)) {
     settings.protocolEra = stored.protocolEra;
   }
@@ -367,7 +510,7 @@ function inspectorSettingsToStoredFields(settings) {
   if (Object.keys(settings.metadata).length > 0) {
     out.metadata = settings.metadata;
   }
-  if (settings.connectionTimeout > 0) {
+  if (settings.connectionTimeout !== DEFAULT_CONNECTION_TIMEOUT_MS) {
     out.connectionTimeout = settings.connectionTimeout;
   }
   if (settings.requestTimeout > 0) {
@@ -394,6 +537,12 @@ function inspectorSettingsToStoredFields(settings) {
   if (settings.maxFetchRequests !== DEFAULT_MAX_FETCH_REQUESTS) {
     out.maxFetchRequests = settings.maxFetchRequests;
   }
+  if (isSkillCatalogLimit(settings.skillCatalogMaxSkills) && settings.skillCatalogMaxSkills !== SKILL_MAX_CATALOG_SKILLS) {
+    out.skillCatalogMaxSkills = settings.skillCatalogMaxSkills;
+  }
+  if (isSkillCatalogLimit(settings.skillCatalogMaxBytes) && settings.skillCatalogMaxBytes !== SKILL_MAX_CATALOG_BYTES) {
+    out.skillCatalogMaxBytes = settings.skillCatalogMaxBytes;
+  }
   const oauthFields = {};
   if (settings.oauthClientId) oauthFields.clientId = settings.oauthClientId;
   if (settings.oauthClientSecret)
@@ -444,6 +593,8 @@ var INSPECTOR_FIELD_KEY_MAP = {
   paginatedLists: true,
   advertisedExtensions: true,
   maxFetchRequests: true,
+  skillCatalogMaxSkills: true,
+  skillCatalogMaxBytes: true,
   oauth: true,
   roots: true
 };
@@ -565,6 +716,14 @@ function parseHeaderPair(value, previous = {}) {
   }
   return { ...previous, [key]: val };
 }
+function parseProtocolEra(value) {
+  if (!isProtocolEra(value)) {
+    throw new Error(
+      `Invalid protocol era: ${value}. Valid eras are: legacy, auto, modern`
+    );
+  }
+  return value;
+}
 var EMPTY_CATALOG_CONTENT = `${JSON.stringify({ mcpServers: {} }, null, 2)}
 `;
 function seedEmptyCatalog(resolvedPath) {
@@ -924,10 +1083,25 @@ function sandboxFrameAncestors(allowedOrigins) {
   return frameAncestorsDirective(allowedOrigins);
 }
 function frameAncestorsDirective(origins) {
-  const valid = (origins ?? []).filter((o) => CSP_HOST_SOURCE.test(o));
+  const valid = validHostSources(origins);
   const sources = valid.length > 0 ? valid : LOOPBACK_FRAME_ANCESTORS;
   return `frame-ancestors ${sources.join(" ")}`;
 }
+function validHostSources(origins) {
+  return (origins ?? []).filter((o) => CSP_HOST_SOURCE.test(o));
+}
+var EMBEDDER_ORIGINS_PLACEHOLDER = "/*INSPECTOR_EMBEDDER_ORIGINS*/ null";
+function embedderOriginsLiteral(origins) {
+  const valid = validHostSources(origins);
+  if (valid.length === 0) return "null";
+  return JSON.stringify(valid).replace(/</g, "\\u003c");
+}
+function renderSandboxProxyHtml(html, origins) {
+  return html.replace(
+    EMBEDDER_ORIGINS_PLACEHOLDER,
+    () => embedderOriginsLiteral(origins)
+  );
+}
 function parseListenPort(raw) {
   const v = raw?.trim();
   if (!v || !/^\d+$/.test(v)) return void 0;
@@ -945,22 +1119,25 @@ function resolveSandboxPort() {
   return fromSandbox ?? parseListenPort(process.env.SERVER_PORT) ?? DEFAULT_SANDBOX_PORT;
 }
 function createSandboxController(options) {
-  const { port, host = DEFAULT_BIND_HOST, allowedOrigins } = options;
+  const { port, host = DEFAULT_BIND_HOST, allowedOrigins, publicUrl } = options;
   let server = null;
   let sandboxUrl = null;
+  let boundPort = 0;
   const SANDBOX_PROXY_CSP = sandboxFrameAncestors(allowedOrigins);
   let sandboxHtml;
   try {
     const sandboxHtmlPath = join3(__dirname, "../static/sandbox_proxy.html");
-    sandboxHtml = readFileSync3(sandboxHtmlPath, "utf-8");
+    sandboxHtml = renderSandboxProxyHtml(
+      readFileSync3(sandboxHtmlPath, "utf-8"),
+      allowedOrigins
+    );
   } catch (e) {
     sandboxHtml = "<!DOCTYPE html><html><body>Sandbox not loaded: " + String(e.message) + "</body></html>";
   }
   return {
     async start() {
       if (server && sandboxUrl) {
-        const p = parseInt(new URL(sandboxUrl).port, 10);
-        return { port: p, url: sandboxUrl };
+        return { port: boundPort, url: sandboxUrl };
       }
       return new Promise((resolve9) => {
         let settled = false;
@@ -1014,7 +1191,15 @@ function createSandboxController(options) {
           );
           const canonicalHost = canonicalUrlHost(host);
           const urlHost = isAllInterfacesHost(canonicalHost) ? "localhost" : canonicalHost;
-          sandboxUrl = `http://${urlHost}:${actualPort}/sandbox`;
+          const derivedUrl = `http://${urlHost}:${actualPort}/sandbox`;
+          const onFixedPort = port !== 0 && !retriedDynamic;
+          if (publicUrl && !onFixedPort) {
+            console.warn(
+              `Sandbox: not advertising MCP_SANDBOX_FULL_ADDRESS, since the sandbox is not on a fixed port for it to route to; advertising ${derivedUrl} instead.`
+            );
+          }
+          sandboxUrl = publicUrl && onFixedPort ? publicUrl : derivedUrl;
+          boundPort = actualPort;
           settle({ port: actualPort, url: sandboxUrl });
         });
       });
@@ -1075,9 +1260,15 @@ function parseDocumentId(url) {
   return /^[0-9a-f]{32}$/.test(id ?? "") ? id ?? null : null;
 }
 function createAppOriginController(options) {
-  const { port, host = DEFAULT_BIND_HOST, embedderOrigins } = options;
+  const {
+    port,
+    host = DEFAULT_BIND_HOST,
+    embedderOrigins,
+    publicOrigin
+  } = options;
   let server = null;
   let origin = null;
+  let boundPort = 0;
   const documents = /* @__PURE__ */ new Map();
   let retainedChars = 0;
   function drop(id) {
@@ -1095,7 +1286,7 @@ function createAppOriginController(options) {
   return {
     async start() {
       if (server && origin) {
-        return { port: parseInt(new URL(origin).port, 10), url: origin };
+        return { port: boundPort, url: origin };
       }
       return new Promise((resolve9) => {
         let settled = false;
@@ -1129,6 +1320,22 @@ function createAppOriginController(options) {
           res.end(doc.html);
         });
         let retriedDynamic = false;
+        const adoptedOrigin = (derived) => {
+          if (!publicOrigin) return derived;
+          if (port === 0 || retriedDynamic) {
+            console.warn(
+              `App origin: not using MCP_APP_ORIGIN_FULL_ADDRESS, since the listener is not on a fixed port for it to route to; serving app documents from ${derived} instead.`
+            );
+            return derived;
+          }
+          if (embedderOrigins?.includes(publicOrigin)) {
+            console.warn(
+              `App origin: not using MCP_APP_ORIGIN_FULL_ADDRESS=${publicOrigin}: it is the sandbox's or the Inspector UI's origin, and a dedicated app origin must differ from both; serving app documents from ${derived} instead.`
+            );
+            return derived;
+          }
+          return publicOrigin;
+        };
         server.on("error", (err) => {
           if (err.code === "EADDRINUSE") {
             if (!retriedDynamic && port !== 0) {
@@ -1160,7 +1367,8 @@ function createAppOriginController(options) {
           const actualPort = addr.port;
           const canonicalHost = canonicalUrlHost(host);
           const urlHost = isAllInterfacesHost(canonicalHost) ? "localhost" : canonicalHost;
-          origin = `http://${urlHost}:${actualPort}`;
+          origin = adoptedOrigin(`http://${urlHost}:${actualPort}`);
+          boundPort = actualPort;
           settle({ port: actualPort, url: origin });
         });
       });
@@ -1198,6 +1406,107 @@ function createAppOriginController(options) {
   };
 }
 
+// server/public-address.ts
+var SANDBOX_FULL_ADDRESS_ENV = "MCP_SANDBOX_FULL_ADDRESS";
+var APP_ORIGIN_FULL_ADDRESS_ENV = "MCP_APP_ORIGIN_FULL_ADDRESS";
+var SANDBOX_PATH = "/sandbox";
+function parsePublicUrl(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return { reason: "it is not an absolute URL" };
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return { reason: "it needs an http:// or https:// scheme" };
+  }
+  if (url.username || url.password) {
+    return { reason: "it must not carry credentials" };
+  }
+  if (url.hostname.includes("*")) {
+    return { reason: "it must not contain a wildcard" };
+  }
+  if (url.hostname.startsWith("[")) {
+    return {
+      reason: "a bracketed IPv6 literal is not a valid CSP host-source \u2014 use a hostname or an IPv4 address"
+    };
+  }
+  if (url.search || url.hash) {
+    return { reason: "it must not carry a query string or fragment" };
+  }
+  return { url };
+}
+function describeForLog(raw) {
+  try {
+    const u = new URL(raw);
+    return `"${u.protocol}${u.host ? `//${u.host}` : ""}"`;
+  } catch {
+    return "(unparseable value, not echoed)";
+  }
+}
+function warnIgnored(env, raw, reason) {
+  console.warn(
+    `Ignoring ${env}=${describeForLog(raw)}: ${reason}. Advertising the bind-derived address instead.`
+  );
+}
+function warnMixedContent(env, url, allowedOrigins) {
+  if (url.protocol === "http:" && allowedOrigins.some((o) => o.startsWith("https:"))) {
+    console.warn(
+      `${env} is plain http (${url.origin}) but ALLOWED_ORIGINS includes an https origin: a browser on the https UI blocks it as mixed content and MCP Apps will not render there.`
+    );
+  }
+}
+function resolveSandboxPublicUrl(raw, allowedOrigins) {
+  const value = raw?.trim();
+  if (!value) return void 0;
+  const parsed = parsePublicUrl(value);
+  if ("reason" in parsed) {
+    warnIgnored(SANDBOX_FULL_ADDRESS_ENV, value, parsed.reason);
+    return void 0;
+  }
+  const { url } = parsed;
+  if (url.pathname === "/") url.pathname = SANDBOX_PATH;
+  if (allowedOrigins.includes(url.origin)) {
+    warnIgnored(
+      SANDBOX_FULL_ADDRESS_ENV,
+      value,
+      `its origin ${url.origin} is also an Inspector UI origin (ALLOWED_ORIGINS), and the MCP Apps sandbox must be on a different origin from its host \u2014 route it to its own hostname or port`
+    );
+    return void 0;
+  }
+  warnMixedContent(SANDBOX_FULL_ADDRESS_ENV, url, allowedOrigins);
+  return url.href;
+}
+function resolveAppOriginPublicOrigin(raw, allowedOrigins, sandboxUrl) {
+  const value = raw?.trim();
+  if (!value) return void 0;
+  const parsed = parsePublicUrl(value);
+  if ("reason" in parsed) {
+    warnIgnored(APP_ORIGIN_FULL_ADDRESS_ENV, value, parsed.reason);
+    return void 0;
+  }
+  const { url } = parsed;
+  if (url.pathname !== "/") {
+    warnIgnored(
+      APP_ORIGIN_FULL_ADDRESS_ENV,
+      value,
+      "it must be an origin only, with no path \u2014 app documents are served at <origin>/app-document/<id>"
+    );
+    return void 0;
+  }
+  const trusted = sandboxUrl ? [...allowedOrigins, new URL(sandboxUrl).origin] : allowedOrigins;
+  if (trusted.includes(url.origin)) {
+    warnIgnored(
+      APP_ORIGIN_FULL_ADDRESS_ENV,
+      value,
+      `its origin ${url.origin} is also the Inspector UI's or the sandbox's, and a dedicated app origin must differ from both \u2014 route it to its own hostname or port`
+    );
+    return void 0;
+  }
+  warnMixedContent(APP_ORIGIN_FULL_ADDRESS_ENV, url, allowedOrigins);
+  return url.origin;
+}
+
 // server/web-server-config.ts
 var inspectorVersion = readInspectorVersionSafe(import.meta.url);
 function defaultEnvironmentFromProcess(extra) {
@@ -1382,6 +1691,16 @@ function buildWebServerConfig(options = {}) {
       return null;
     }
   }).filter((o) => o !== null);
+  const allowedOrigins = configuredOrigins?.length ? configuredOrigins : defaultAllowedOrigins(hostname, port);
+  const sandboxPublicUrl = resolveSandboxPublicUrl(
+    process.env[SANDBOX_FULL_ADDRESS_ENV],
+    allowedOrigins
+  );
+  const appOriginPublicOrigin = resolveAppOriginPublicOrigin(
+    process.env[APP_ORIGIN_FULL_ADDRESS_ENV],
+    allowedOrigins,
+    sandboxPublicUrl
+  );
   return {
     port,
     hostname,
@@ -1392,10 +1711,12 @@ function buildWebServerConfig(options = {}) {
     writable,
     initialServers,
     storageDir: process.env.MCP_STORAGE_DIR,
-    allowedOrigins: configuredOrigins?.length ? configuredOrigins : defaultAllowedOrigins(hostname, port),
+    allowedOrigins,
     sandboxPort,
     sandboxHost: hostname,
     appOriginPort,
+    sandboxPublicUrl,
+    appOriginPublicOrigin,
     logger,
     autoOpen: resolveAutoOpen()
   };
@@ -1547,6 +1868,7 @@ function redactBody(body, contentType) {
   return body;
 }
 function findHeader(headers, name) {
+  if (!headers) return void 0;
   const target = name.toLowerCase();
   for (const [key, value] of Object.entries(headers)) {
     if (key.toLowerCase() === target) return value;
@@ -1554,9 +1876,146 @@ function findHeader(headers, name) {
   return void 0;
 }
 function isLongLivedStreamResponse(method, contentType) {
-  if (method !== "GET") return false;
+  if (method.toUpperCase() !== "GET") return false;
   if (!contentType) return false;
-  return contentType.includes("text/event-stream") || contentType.includes("application/x-ndjson");
+  const type = contentType.toLowerCase();
+  return type.includes("text/event-stream") || type.includes("application/x-ndjson");
+}
+var CHALLENGE_BODY_MAX_BYTES = 64 * 1024;
+var CHALLENGE_BODY_READ_MS = 2e3;
+var TRUNCATED_BODY_SUFFIX = "\n[truncated]";
+var WITHHELD_TRUNCATED_JSON_BODY = "[truncated JSON body withheld: an incomplete body cannot be redacted]";
+function recordableChallengeBody(read, contentType) {
+  if (!read.truncated) return redactBody(read.text, contentType);
+  const looksLikeJson = (contentType ?? "").toLowerCase().includes("json") || /^\s*[{[]/.test(read.text);
+  if (looksLikeJson) return WITHHELD_TRUNCATED_JSON_BODY;
+  return redactBody(read.text, contentType) + TRUNCATED_BODY_SUFFIX;
+}
+async function readChallengeBody(response) {
+  let reader;
+  try {
+    const body = response.clone().body;
+    if (!body) return void 0;
+    reader = body.getReader();
+  } catch {
+    return void 0;
+  }
+  const decoder = new TextDecoder();
+  let text = "";
+  let bytes = 0;
+  let timer;
+  const deadline = new Promise((resolve9) => {
+    timer = setTimeout(() => resolve9("timeout"), CHALLENGE_BODY_READ_MS);
+  });
+  try {
+    while (bytes < CHALLENGE_BODY_MAX_BYTES) {
+      const next = await Promise.race([reader.read(), deadline]);
+      if (next === "timeout") break;
+      if (next.done) return { text: text + decoder.decode(), truncated: false };
+      const chunk = next.value.subarray(0, CHALLENGE_BODY_MAX_BYTES - bytes);
+      bytes += chunk.byteLength;
+      text += decoder.decode(chunk, { stream: true });
+    }
+    reader.cancel().catch(() => {
+    });
+    return { text: text + decoder.decode(), truncated: true };
+  } catch {
+    return void 0;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var DEFAULT_STREAM_UPDATE_INTERVAL_MS = 250;
+function longLivedStreamFraming(contentType) {
+  return contentType?.toLowerCase().includes("application/x-ndjson") ? "ndjson" : "sse";
+}
+function watchLongLivedStream(response, id, framing, callbacks) {
+  const listener = callbacks.updateStream;
+  if (!listener) return;
+  const report = (state) => {
+    try {
+      listener(id, state);
+    } catch {
+    }
+  };
+  const intervalMs = callbacks.streamUpdateIntervalMs ?? DEFAULT_STREAM_UPDATE_INTERVAL_MS;
+  let body;
+  try {
+    body = response.clone().body;
+  } catch {
+    return;
+  }
+  if (!body) return;
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let eventCount = 0;
+  let pending = "";
+  let blockHasData = false;
+  let reportTimer = null;
+  const reportCount = () => {
+    if (intervalMs <= 0) {
+      report({ eventCount });
+      return;
+    }
+    if (reportTimer !== null) return;
+    reportTimer = setTimeout(() => {
+      reportTimer = null;
+      report({ eventCount });
+    }, intervalMs);
+  };
+  report({ eventCount });
+  const consumeLine = (line) => {
+    if (framing === "ndjson") {
+      if (line.trim() === "") return;
+      eventCount += 1;
+      reportCount();
+      return;
+    }
+    if (line === "") {
+      if (blockHasData) {
+        eventCount += 1;
+        blockHasData = false;
+        reportCount();
+      }
+      return;
+    }
+    if (line === "data" || line.startsWith("data:")) blockHasData = true;
+  };
+  const consumeCompleteLines = () => {
+    for (; ; ) {
+      const cr = pending.indexOf("\r");
+      const lf = pending.indexOf("\n");
+      const end = cr === -1 ? lf : lf === -1 ? cr : Math.min(cr, lf);
+      if (end === -1) return;
+      if (pending[end] === "\r") {
+        if (end === pending.length - 1) return;
+        const width = pending[end + 1] === "\n" ? 2 : 1;
+        consumeLine(pending.slice(0, end));
+        pending = pending.slice(end + width);
+      } else {
+        consumeLine(pending.slice(0, end));
+        pending = pending.slice(end + 1);
+      }
+    }
+  };
+  const pump = async () => {
+    try {
+      for (; ; ) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        pending += decoder.decode(value, { stream: true });
+        consumeCompleteLines();
+      }
+      if (pending.endsWith("\r")) consumeLine(pending.slice(0, -1));
+    } catch {
+    }
+    if (reportTimer !== null) {
+      clearTimeout(reportTimer);
+      reportTimer = null;
+    }
+    report({ eventCount, closedAt: /* @__PURE__ */ new Date() });
+  };
+  void pump();
 }
 function createFetchTracker(baseFetch, callbacks) {
   return async (input, init) => {
@@ -1564,7 +2023,7 @@ function createFetchTracker(baseFetch, callbacks) {
     const timestamp = /* @__PURE__ */ new Date();
     const id = `${timestamp.getTime()}-${Math.random().toString(36).slice(2, 11)}`;
     const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-    const method = init?.method || "GET";
+    const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
     const rawRequestHeaders = {};
     if (input instanceof Request) {
       input.headers.forEach((value, key) => {
@@ -1644,7 +2103,21 @@ function createFetchTracker(baseFetch, callbacks) {
       responseBody: void 0,
       duration
     };
+    if ((responseStatus === 401 || responseStatus === 403) && response.body && !response.bodyUsed) {
+      const read = await readChallengeBody(response);
+      entry.responseBody = read === void 0 ? void 0 : recordableChallengeBody(read, response.headers.get("content-type"));
+      callbacks.trackRequest?.(entry);
+      return response;
+    }
     callbacks.trackRequest?.(entry);
+    if (isLongLivedStream && response.body && !response.bodyUsed) {
+      watchLongLivedStream(
+        response,
+        id,
+        longLivedStreamFraming(response.headers.get("content-type")),
+        callbacks
+      );
+    }
     if (!isLongLivedStream && response.body && !response.bodyUsed) {
       const responseContentType = response.headers.get("content-type");
       try {
@@ -1756,7 +2229,7 @@ function createAuthChallengeInterceptFetch(baseFetch) {
     if (!challenge) {
       return response;
     }
-    await response.body?.cancel().catch(() => {
+    void response.body?.cancel().catch(() => {
     });
     throw new AuthChallengeError(
       challenge,
@@ -1904,14 +2377,24 @@ function createTransportNode(config, options = {}) {
     pipeStderr = false,
     onFetchRequest,
     onFetchResponseBody,
+    onFetchStreamUpdate,
     authProvider,
     settings,
     interceptAuthChallenges = false,
     onAuthChallengeObserved
   } = options;
+  const wantsFetchTracking = Boolean(
+    onFetchRequest || onFetchResponseBody || onFetchStreamUpdate
+  );
   const baseFetch = optionsFetchFn ?? createProxyFetch() ?? globalThis.fetch;
   const withChallengeObserver = (inner) => onAuthChallengeObserved ? createAuthChallengeObserverFetch(inner, onAuthChallengeObserved) : inner;
-  const fetchWithOptionalAuthIntercept = interceptAuthChallenges ? createAuthChallengeInterceptFetch(withChallengeObserver(baseFetch)) : withChallengeObserver(baseFetch);
+  const withTracking = (inner) => wantsFetchTracking ? createFetchTracker(inner, {
+    trackRequest: onFetchRequest,
+    updateResponseBody: onFetchResponseBody,
+    updateStream: onFetchStreamUpdate
+  }) : inner;
+  const trackedBase = withTracking(withChallengeObserver(baseFetch));
+  const fetchWithOptionalAuthIntercept = interceptAuthChallenges ? createAuthChallengeInterceptFetch(trackedBase) : trackedBase;
   if (serverType === "stdio") {
     const stdioConfig = config;
     const transport = new StdioClientTransport({
@@ -1937,11 +2420,7 @@ function createTransportNode(config, options = {}) {
     const sseConfig = config;
     const url = new URL(sseConfig.url);
     const configuredSseFetch = sseConfig.eventSourceInit?.fetch;
-    const sseFetch = configuredSseFetch ? withChallengeObserver(configuredSseFetch) : fetchWithOptionalAuthIntercept;
-    const trackedFetch = onFetchRequest ? createFetchTracker(sseFetch, {
-      trackRequest: onFetchRequest,
-      updateResponseBody: onFetchResponseBody
-    }) : sseFetch;
+    const trackedFetch = configuredSseFetch ? withTracking(withChallengeObserver(configuredSseFetch)) : fetchWithOptionalAuthIntercept;
     const headers = headersFromSettings(settings);
     const eventSourceInit = {
       ...sseConfig.eventSourceInit,
@@ -1952,15 +2431,11 @@ function createTransportNode(config, options = {}) {
       ...sseConfig.requestInit,
       ...headers && { headers }
     };
-    const postFetch = onFetchRequest ? createFetchTracker(fetchWithOptionalAuthIntercept, {
-      trackRequest: onFetchRequest,
-      updateResponseBody: onFetchResponseBody
-    }) : fetchWithOptionalAuthIntercept;
     const transport = new SSEClientTransport(url, {
       authProvider,
       eventSourceInit,
       requestInit,
-      fetch: postFetch
+      fetch: fetchWithOptionalAuthIntercept
     });
     return { transport };
   } else {
@@ -1971,14 +2446,10 @@ function createTransportNode(config, options = {}) {
       ...httpConfig.requestInit,
       ...headers && { headers }
     };
-    const transportFetch = onFetchRequest ? createFetchTracker(fetchWithOptionalAuthIntercept, {
-      trackRequest: onFetchRequest,
-      updateResponseBody: onFetchResponseBody
-    }) : fetchWithOptionalAuthIntercept;
     const transport = new StreamableHTTPClientTransport(url, {
       authProvider,
       requestInit,
-      fetch: transportFetch,
+      fetch: fetchWithOptionalAuthIntercept,
       // SEP-2350: how the transport reacts to a `403 insufficient_scope`
       // challenge. Defaults to the SDK's `reauthorize` when unset.
       ...settings?.oauthOnInsufficientScope && {
@@ -1989,6 +2460,9 @@ function createTransportNode(config, options = {}) {
   }
 }
 
+// ../../core/auth/requestTimeout.ts
+var OAUTH_TIMEOUT_WIRE_CODE = "oauth_request_timeout";
+
 // ../../core/json/xMcpHeader.ts
 var MCP_PARAM_HEADER_PREFIX = "Mcp-Param-";
 
@@ -2141,6 +2615,20 @@ function resolveImportSource(type, platform, homeDir, readFile2) {
   return { type, found: false, searched };
 }
 
+// ../../core/mcp/remote/progressToken.ts
+import { ProgressTokenSchema } from "@modelcontextprotocol/core";
+function progressTokenOf(message) {
+  if ("method" in message && message.method === "notifications/progress" && "params" in message && typeof message.params === "object" && message.params !== null) {
+    const parsed = ProgressTokenSchema.safeParse(
+      message.params.progressToken
+    );
+    if (parsed.success) {
+      return parsed.data;
+    }
+  }
+  return void 0;
+}
+
 // ../../core/mcp/remote/node/remote-session.ts
 var RemoteSession = class _RemoteSession {
   sessionId;
@@ -2260,30 +2748,54 @@ var RemoteSession = class _RemoteSession {
    */
   waitForRequestResponse(requestId, timeoutMs = 6e4) {
     return new Promise((resolve9, reject) => {
-      const timer = timeoutMs > 0 ? setTimeout(() => {
-        this.requestWaits.delete(requestId);
-        reject(
-          new Error(
-            `MCP request ${String(requestId)} timed out after ${timeoutMs}ms`
-          )
-        );
-      }, timeoutMs) : void 0;
+      let timer;
+      const arm = () => {
+        if (timeoutMs <= 0) return;
+        timer = setTimeout(() => {
+          this.requestWaits.delete(requestId);
+          reject(
+            new Error(
+              `MCP request ${String(requestId)} timed out after ${timeoutMs}ms`
+            )
+          );
+        }, timeoutMs);
+      };
+      const clear = () => {
+        if (timer !== void 0) {
+          clearTimeout(timer);
+          timer = void 0;
+        }
+      };
+      arm();
       this.requestWaits.set(requestId, {
         resolve: () => {
-          if (timer !== void 0) {
-            clearTimeout(timer);
-          }
+          clear();
           resolve9();
         },
         reject: (error) => {
-          if (timer !== void 0) {
-            clearTimeout(timer);
-          }
+          clear();
           reject(error);
+        },
+        // A progress notification for this request re-arms the full window, so
+        // a tool that keeps reporting progress never trips the relay's own
+        // deadline — the same guarantee the SDK client's `resetTimeoutOnProgress`
+        // gives on a direct transport (#2028).
+        resetTimeout: () => {
+          if (timer === void 0) return;
+          clear();
+          arm();
         }
       });
     });
   }
+  /**
+   * Re-arm a pending request's wait timeout. Invoked from {@link onMessage} when
+   * a `notifications/progress` carrying this request's `progressToken` arrives.
+   * A no-op when no wait is pending for the id.
+   */
+  noteRequestProgress(requestId) {
+    this.requestWaits.get(requestId)?.resetTimeout();
+  }
   cancelRequestWait(requestId) {
     const wait = this.requestWaits.get(requestId);
     if (!wait) {
@@ -2338,6 +2850,10 @@ var RemoteSession = class _RemoteSession {
     if ("id" in message && message.id !== null && message.id !== void 0 && ("result" in message || "error" in message)) {
       this.settleRequestWait(message.id);
     }
+    const progressToken = progressTokenOf(message);
+    if (progressToken !== void 0) {
+      this.noteRequestProgress(progressToken);
+    }
     this.pushEvent({ type: "message", data: message });
   }
   onFetchRequest(entry) {
@@ -2355,6 +2871,16 @@ var RemoteSession = class _RemoteSession {
       data: { id, responseBody }
     });
   }
+  onFetchStreamUpdate(id, stream) {
+    this.pushEvent({
+      type: "fetch_stream_update",
+      data: {
+        id,
+        eventCount: stream.eventCount,
+        ...stream.closedAt && { closedAt: stream.closedAt.toISOString() }
+      }
+    });
+  }
   onStderr(entry) {
     this.pushEvent({
       type: "stdio_log",
@@ -3821,7 +4347,7 @@ function defaultSecretStore() {
 }
 
 // ../../core/client/config-parse.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 function isAbsoluteHttpUrl(value) {
   let url;
   try {
@@ -3838,17 +4364,21 @@ function isRealHost(hostname) {
   const labels = hostname.split(".");
   return labels.length >= 2 && labels.every((label) => label !== "");
 }
-var HttpUrlStringSchema = z.string().min(1).superRefine((val, ctx) => {
+var HttpUrlStringSchema = z2.string().min(1).superRefine((val, ctx) => {
   const trimmed = val.trim();
   if (!isAbsoluteHttpUrl(trimmed)) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: z2.ZodIssueCode.custom,
       message: `Invalid URL: "${trimmed}" \u2014 must be an http(s) URL (e.g. https://idp.example.com)`
     });
   }
 });
 var CIMD_METADATA_URL_INVALID_ERROR = "Must be a valid URL, like https://example.com/oauth/client.json";
-var CIMD_METADATA_URL_HTTPS_ERROR = "CIMD client metadata URL must use HTTPS";
+var CIMD_METADATA_URL_HTTPS_ERROR = "CIMD client metadata URL must use HTTPS, except on localhost, 127.0.0.1 or [::1]";
+var CIMD_HTTP_EXEMPT_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+function isCimdHttpExemptHost(hostname) {
+  return CIMD_HTTP_EXEMPT_HOSTS.has(hostname);
+}
 var CIMD_METADATA_URL_PATH_ERROR = "Must include a path (not the site root), like https://example.com/oauth/client.json";
 function getCimdClientMetadataUrlError(value) {
   const trimmed = value.trim();
@@ -3858,7 +4388,7 @@ function getCimdClientMetadataUrlError(value) {
   }
   try {
     const url = new URL(trimmed);
-    if (url.protocol !== "https:") {
+    if (url.protocol !== "https:" && !isCimdHttpExemptHost(url.hostname)) {
       return CIMD_METADATA_URL_HTTPS_ERROR;
     }
     if (url.pathname === "/" || url.pathname === "") {
@@ -3874,7 +4404,7 @@ function refineCimdMetadataUrl(val, ctx, required) {
   if (trimmed === "") {
     if (required) {
       ctx.addIssue({
-        code: z.ZodIssueCode.custom,
+        code: z2.ZodIssueCode.custom,
         message: "CIMD client metadata URL is required when CIMD is enabled"
       });
     }
@@ -3883,25 +4413,25 @@ function refineCimdMetadataUrl(val, ctx, required) {
   const error = getCimdClientMetadataUrlError(trimmed);
   if (error) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: z2.ZodIssueCode.custom,
       message: error
     });
   }
 }
-var CimdConfigSchema = z.object({
-  enabled: z.boolean(),
-  clientMetadataUrl: z.string()
+var CimdConfigSchema = z2.object({
+  enabled: z2.boolean(),
+  clientMetadataUrl: z2.string()
 }).superRefine((data, ctx) => {
   refineCimdMetadataUrl(data.clientMetadataUrl, ctx, data.enabled === true);
 });
-var EnterpriseManagedAuthIdpConfigSchema = z.object({
+var EnterpriseManagedAuthIdpConfigSchema = z2.object({
   issuer: HttpUrlStringSchema,
-  clientId: z.string().min(1),
-  clientSecret: z.string().optional()
+  clientId: z2.string().min(1),
+  clientSecret: z2.string().optional()
 });
-var ClientConfigSchema = z.object({
-  enterpriseManagedAuth: z.object({
-    enabled: z.boolean().optional(),
+var ClientConfigSchema = z2.object({
+  enterpriseManagedAuth: z2.object({
+    enabled: z2.boolean().optional(),
     idp: EnterpriseManagedAuthIdpConfigSchema
   }).optional(),
   cimd: CimdConfigSchema.optional()
@@ -3910,7 +4440,7 @@ function parseClientConfig(raw) {
   return ClientConfigSchema.parse(raw);
 }
 function formatClientConfigLoadError(error) {
-  if (error instanceof z.ZodError) {
+  if (error instanceof z2.ZodError) {
     const issue = error.issues[0];
     if (issue) {
       const field = issue.path.length > 0 ? issue.path.map(String).join(".") : "config";
@@ -4395,6 +4925,7 @@ function createRemoteApp(options) {
         onStderr: (entry) => session.onStderr(entry),
         onFetchRequest: (entry) => session.onFetchRequest(entry),
         onFetchResponseBody: (id, body2) => session.onFetchResponseBody(id, body2),
+        onFetchStreamUpdate: (id, stream) => session.onFetchStreamUpdate(id, stream),
         authProvider: authHandle?.provider,
         settings: body.settings,
         // Always intercept 401/403 on the node MCP transport. Without this, the
@@ -4629,15 +5160,36 @@ function createRemoteApp(options) {
     } catch {
       return c.json({ error: "Invalid JSON body" }, 400);
     }
-    const { url, method = "GET", headers = {}, body: reqBody } = body;
+    const {
+      url,
+      method = "GET",
+      headers = {},
+      body: reqBody,
+      timeoutMs: requestedTimeoutMs
+    } = body;
     if (!url) {
       return c.json({ error: "Missing url" }, 400);
     }
+    const controller = new AbortController();
+    let deadlineFired = false;
+    const clientSignal = c.req.raw.signal;
+    const signal = clientSignal ? AbortSignal.any([controller.signal, clientSignal]) : controller.signal;
+    const deadlineMs = typeof requestedTimeoutMs === "number" && Number.isFinite(requestedTimeoutMs) ? Math.min(2147483647, Math.max(0, Math.round(requestedTimeoutMs))) : void 0;
+    const safeUrl = redactUrlQuery(url);
+    const timer = deadlineMs === void 0 ? void 0 : setTimeout(() => {
+      deadlineFired = true;
+      controller.abort(
+        new Error(
+          `proxied request to ${safeUrl} timed out after ${deadlineMs}ms`
+        )
+      );
+    }, deadlineMs);
     try {
       const res = await (createProxyFetch() ?? fetch)(url, {
         method,
         headers: new Headers(headers),
-        body: reqBody
+        body: reqBody,
+        signal
       });
       const resHeaders = {};
       res.headers.forEach((v, k) => {
@@ -4648,6 +5200,9 @@ function createRemoteApp(options) {
       let resBody;
       if (!isStream && res.body) {
         resBody = await res.text();
+      } else if (isStream) {
+        void res.body?.cancel().catch(() => {
+        });
       }
       return c.json({
         ok: res.ok,
@@ -4658,7 +5213,20 @@ function createRemoteApp(options) {
       });
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
+      if (deadlineFired) {
+        return c.json(
+          {
+            error: msg,
+            code: OAUTH_TIMEOUT_WIRE_CODE,
+            url: safeUrl,
+            timeoutMs: deadlineMs
+          },
+          504
+        );
+      }
       return c.json({ error: msg }, 500);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
     }
   });
   app.post("/api/log", async (c) => {
@@ -4854,6 +5422,18 @@ function createRemoteApp(options) {
         );
         delete valObj.maxFetchRequests;
       }
+      for (const key of [
+        "skillCatalogMaxSkills",
+        "skillCatalogMaxBytes"
+      ]) {
+        if (key in valObj && !isSkillCatalogLimit(valObj[key])) {
+          logWarn(
+            { route: "/api/servers", id, droppedKey: key },
+            `Dropping malformed \`${key}\` field \u2014 expected a positive integer.`
+          );
+          delete valObj[key];
+        }
+      }
       if ("oauth" in valObj && !isOauthObject(valObj.oauth)) {
         logWarn(
           { route: "/api/servers", id, droppedKey: "oauth" },
@@ -5010,6 +5590,17 @@ function createRemoteApp(options) {
         error: "settings.maxFetchRequests must be a non-negative number"
       };
     }
+    for (const key of [
+      "skillCatalogMaxSkills",
+      "skillCatalogMaxBytes"
+    ]) {
+      if (obj[key] !== void 0 && !isSkillCatalogLimit(obj[key])) {
+        return {
+          ok: false,
+          error: `settings.${key} must be a positive integer`
+        };
+      }
+    }
     for (const optional of [
       "oauthClientId",
       "oauthClientSecret",
@@ -5105,6 +5696,12 @@ function createRemoteApp(options) {
       // writes no spurious `roots` field.
       roots: isRootArray(obj.roots) ? obj.roots : []
     };
+    if (isSkillCatalogLimit(obj.skillCatalogMaxSkills)) {
+      value.skillCatalogMaxSkills = obj.skillCatalogMaxSkills;
+    }
+    if (isSkillCatalogLimit(obj.skillCatalogMaxBytes)) {
+      value.skillCatalogMaxBytes = obj.skillCatalogMaxBytes;
+    }
     if (typeof obj.oauthClientId === "string" && obj.oauthClientId !== "") {
       value.oauthClientId = obj.oauthClientId;
     }
@@ -5667,12 +6264,14 @@ function honoMiddlewarePlugin(config) {
       const sandboxController = createSandboxController({
         port: config.sandboxPort,
         host: config.sandboxHost,
-        allowedOrigins: config.allowedOrigins
+        allowedOrigins: config.allowedOrigins,
+        publicUrl: config.sandboxPublicUrl
       });
       await sandboxController.start();
       const appOriginController = createAppOriginController({
         port: config.appOriginPort,
         host: config.sandboxHost,
+        publicOrigin: config.appOriginPublicOrigin,
         embedderOrigins: appDocumentEmbedders(
           sandboxController.getUrl(),
           config.allowedOrigins
@@ -5890,6 +6489,33 @@ function clearViteDepsCache(clientWebRoot) {
 // ../../vitest.shared.mts
 import path5 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
+var NO_RETRY_SETUP = path5.resolve(
+  path5.dirname(fileURLToPath3(import.meta.url)),
+  "vitest.setup.shared.mts"
+);
+var TIMEOUTS = Object.freeze({
+  /**
+   * 3x Vitest's default. Covers the measured load; past this a genuinely hung
+   * unit test costs the whole budget to discover. Both projects that had
+   * already answered this question by hand — `clients/cli` and web's
+   * `storybook` (#2292) — independently arrived at 15000, which is why it is
+   * the shared value rather than a new one.
+   */
+  testTimeout: 15e3,
+  /**
+   * Hooks do the setup and teardown a test's own budget never covers —
+   * spawning servers, provisioning temp dirs, unlinking filesystem-backed
+   * storage. They are also where the real-transitions auto-settle in
+   * `clients/web/src/test/renderWithMantine.tsx` awaits, so this is the one
+   * budget in the repo that actually governs a deliberate wait.
+   */
+  hookTimeout: 3e4,
+  teardownTimeout: 3e4
+});
+var INTEGRATION_TIMEOUTS = Object.freeze({
+  ...TIMEOUTS,
+  testTimeout: 3e4
+});
 function vitestSharedPaths(clientDir) {
   const dirname10 = path5.resolve(clientDir);
   const repoRoot = path5.resolve(dirname10, "../..");
@@ -6132,12 +6758,14 @@ async function startHonoServer(config) {
   const sandboxController = createSandboxController({
     port: config.sandboxPort,
     host: config.sandboxHost,
-    allowedOrigins: config.allowedOrigins
+    allowedOrigins: config.allowedOrigins,
+    publicUrl: config.sandboxPublicUrl
   });
   await sandboxController.start();
   const appOriginController = createAppOriginController({
     port: config.appOriginPort,
     host: config.sandboxHost,
+    publicOrigin: config.appOriginPublicOrigin,
     embedderOrigins: appDocumentEmbedders(
       sandboxController.getUrl(),
       config.allowedOrigins
@@ -6310,6 +6938,10 @@ async function runWeb(argv) {
     'HTTP headers as "HeaderName: Value" pairs (for HTTP/SSE transports)',
     parseHeaderPair,
     {}
+  ).option(
+    "--protocol-era <era>",
+    "protocol era for the ad-hoc server: legacy, auto, or modern (default legacy)",
+    parseProtocolEra
   ).option("--dev", "run in development mode (Vite)").parse(preArgs);
   const opts = program.opts();
   const args = program.args;
@@ -6319,8 +6951,9 @@ async function runWeb(argv) {
   const hasCatalog = !!catalogPath;
   const hasConfig = !!opts.config;
   const hasHeaders = !!opts.header && Object.keys(opts.header).length > 0;
+  const hasProtocolEra = opts.protocolEra !== void 0;
   const hasAdHocServer = target.length > 0 || !!opts.serverUrl || !!opts.transport && opts.transport !== "stdio";
-  const conflict = hasCatalog && hasConfig ? "--catalog and --config are mutually exclusive. --catalog is the writable catalog; --config is a read-only session file." : hasCatalog && hasAdHocServer ? "--catalog cannot be combined with an ad-hoc server URL/command." : hasCatalog && hasHeaders ? "--header cannot be combined with --catalog. Set per-server headers in the catalog file." : hasConfig && hasAdHocServer ? "--config cannot be combined with an ad-hoc server URL/command. --config selects a read-only session file." : hasConfig && hasHeaders ? "--header cannot be combined with --config. Set per-server headers inside the config file instead." : null;
+  const conflict = hasCatalog && hasConfig ? "--catalog and --config are mutually exclusive. --catalog is the writable catalog; --config is a read-only session file." : hasCatalog && hasAdHocServer ? "--catalog cannot be combined with an ad-hoc server URL/command." : hasCatalog && hasHeaders ? "--header cannot be combined with --catalog. Set per-server headers in the catalog file." : hasCatalog && hasProtocolEra ? "--protocol-era cannot be combined with --catalog. Set protocolEra per server in the catalog file." : hasConfig && hasAdHocServer ? "--config cannot be combined with an ad-hoc server URL/command. --config selects a read-only session file." : hasConfig && hasHeaders ? "--header cannot be combined with --config. Set per-server headers inside the config file instead." : hasConfig && hasProtocolEra ? "--protocol-era cannot be combined with --config. Set protocolEra per server inside the config file instead." : null;
   if (conflict) {
     console.error(`Error: ${conflict}`);
     process.exit(1);
@@ -6385,6 +7018,9 @@ async function runWeb(argv) {
     }
     initialMcpConfig = config;
     const entry = hasHeaders && config.type !== "stdio" && config.type !== void 0 ? { ...config, headers: opts.header } : { ...config };
+    if (opts.protocolEra !== void 0) {
+      entry.protocolEra = opts.protocolEra;
+    }
     initialServers = {
       mcpServers: { [deriveSeedServerId(config)]: entry }
     };
@@ -6394,6 +7030,11 @@ async function runWeb(argv) {
       "Error: --header requires an ad-hoc --server-url or command target."
     );
     process.exit(1);
+  } else if (hasProtocolEra) {
+    console.error(
+      "Error: --protocol-era requires an ad-hoc --server-url or command target."
+    );
+    process.exit(1);
   }
   let webConfig;
   try {