bridge-agent 0.17.1 → 0.18.1

package/dist/bridge-mcp.cjs

@@ -1299,21 +1299,21 @@ var require_errors = __commonJS({
     function extendErrors({ gen, keyword, schemaValue, data, errsCount, it }) {
       if (errsCount === void 0)
         throw new Error("ajv implementation error");
-      const err5 = gen.name("err");
+      const err6 = gen.name("err");
       gen.forRange("i", errsCount, names_1.default.errors, (i) => {
-        gen.const(err5, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`);
-        gen.if((0, codegen_1._)`${err5}.instancePath === undefined`, () => gen.assign((0, codegen_1._)`${err5}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
-        gen.assign((0, codegen_1._)`${err5}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`);
+        gen.const(err6, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`);
+        gen.if((0, codegen_1._)`${err6}.instancePath === undefined`, () => gen.assign((0, codegen_1._)`${err6}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
+        gen.assign((0, codegen_1._)`${err6}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`);
         if (it.opts.verbose) {
-          gen.assign((0, codegen_1._)`${err5}.schema`, schemaValue);
-          gen.assign((0, codegen_1._)`${err5}.data`, data);
+          gen.assign((0, codegen_1._)`${err6}.schema`, schemaValue);
+          gen.assign((0, codegen_1._)`${err6}.data`, data);
         }
       });
     }
     exports2.extendErrors = extendErrors;
     function addError(gen, errObj) {
-      const err5 = gen.const("err", errObj);
-      gen.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._)`[${err5}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err5})`);
+      const err6 = gen.const("err", errObj);
+      gen.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._)`[${err6}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err6})`);
       gen.code((0, codegen_1._)`${names_1.default.errors}++`);
     }
     function returnErrors(it, errs) {
@@ -6493,7 +6493,7 @@ var require_formats = __commonJS({
     }
     exports2.fullFormats = {
       // date: http://tools.ietf.org/html/rfc3339#section-5.6
-      date: fmtDef(date3, compareDate),
+      date: fmtDef(date4, compareDate),
       // date-time: http://tools.ietf.org/html/rfc3339#section-5.6
       time: fmtDef(getTime(true), compareTime),
       "date-time": fmtDef(getDateTime(true), compareDateTime),
@@ -6559,7 +6559,7 @@ var require_formats = __commonJS({
     }
     var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
     var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-    function date3(str) {
+    function date4(str) {
       const matches = DATE.exec(str);
       if (!matches)
         return false;
@@ -6628,7 +6628,7 @@ var require_formats = __commonJS({
       const time3 = getTime(strictTimeZone);
       return function date_time(str) {
         const dateTime = str.split(DATE_TIME_SEPARATOR);
-        return dateTime.length === 2 && date3(dateTime[0]) && time3(dateTime[1]);
+        return dateTime.length === 2 && date4(dateTime[0]) && time3(dateTime[1]);
       };
     }
     function compareDateTime(dt1, dt2) {
@@ -7541,8 +7541,8 @@ var ZodType = class {
         } : {
           issues: ctx.common.issues
         };
-      } catch (err5) {
-        if (err5?.message?.toLowerCase()?.includes("encountered")) {
+      } catch (err6) {
+        if (err6?.message?.toLowerCase()?.includes("encountered")) {
           this["~standard"].async = true;
         }
         ctx.common = {
@@ -11602,6 +11602,7 @@ var string = (params) => {
   const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
   return new RegExp(`^${regex}$`);
 };
+var bigint = /^\d+n?$/;
 var integer = /^\d+$/;
 var number = /^-?\d+(?:\.\d+)?/i;
 var boolean = /true|false/i;
@@ -12179,11 +12180,11 @@ var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
   inst._zod.check = (payload) => {
     try {
       const orig = payload.value;
-      const url = new URL(orig);
-      const href = url.href;
+      const url2 = new URL(orig);
+      const href = url2.href;
       if (def.hostname) {
         def.hostname.lastIndex = 0;
-        if (!def.hostname.test(url.hostname)) {
+        if (!def.hostname.test(url2.hostname)) {
           payload.issues.push({
             code: "invalid_format",
             format: "url",
@@ -12197,7 +12198,7 @@ var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
       }
       if (def.protocol) {
         def.protocol.lastIndex = 0;
-        if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) {
+        if (!def.protocol.test(url2.protocol.endsWith(":") ? url2.protocol.slice(0, -1) : url2.protocol)) {
           payload.issues.push({
             code: "invalid_format",
             format: "url",
@@ -12470,6 +12471,26 @@ var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
     return payload;
   };
 });
+var $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = bigint;
+  inst._zod.parse = (payload, _ctx) => {
+    if (def.coerce)
+      try {
+        payload.value = BigInt(payload.value);
+      } catch (_) {
+      }
+    if (typeof payload.value === "bigint")
+      return payload;
+    payload.issues.push({
+      expected: "bigint",
+      code: "invalid_type",
+      input: payload.value,
+      inst
+    });
+    return payload;
+  };
+});
 var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.pattern = _null;
@@ -12487,6 +12508,10 @@ var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
     return payload;
   };
 });
+var $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload) => payload;
+});
 var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload) => payload;
@@ -12503,6 +12528,30 @@ var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
     return payload;
   };
 });
+var $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, _ctx) => {
+    if (def.coerce) {
+      try {
+        payload.value = new Date(payload.value);
+      } catch (_err) {
+      }
+    }
+    const input = payload.value;
+    const isDate = input instanceof Date;
+    const isValidDate = isDate && !Number.isNaN(input.getTime());
+    if (isValidDate)
+      return payload;
+    payload.issues.push({
+      expected: "date",
+      code: "invalid_type",
+      input,
+      ...isDate ? { received: "Invalid Date" } : {},
+      inst
+    });
+    return payload;
+  };
+});
 function handleArrayResult(result, final, index) {
   if (result.issues.length) {
     final.issues.push(...prefixIssues(index, result.issues));
@@ -13448,6 +13497,13 @@ function _string(Class2, params) {
     ...normalizeParams(params)
   });
 }
+function _coercedString(Class2, params) {
+  return new Class2({
+    type: "string",
+    coerce: true,
+    ...normalizeParams(params)
+  });
+}
 function _email(Class2, params) {
   return new Class2({
     type: "string",
@@ -13692,6 +13748,14 @@ function _number(Class2, params) {
     ...normalizeParams(params)
   });
 }
+function _coercedNumber(Class2, params) {
+  return new Class2({
+    type: "number",
+    coerce: true,
+    checks: [],
+    ...normalizeParams(params)
+  });
+}
 function _int(Class2, params) {
   return new Class2({
     type: "number",
@@ -13707,12 +13771,31 @@ function _boolean(Class2, params) {
     ...normalizeParams(params)
   });
 }
+function _coercedBoolean(Class2, params) {
+  return new Class2({
+    type: "boolean",
+    coerce: true,
+    ...normalizeParams(params)
+  });
+}
+function _coercedBigint(Class2, params) {
+  return new Class2({
+    type: "bigint",
+    coerce: true,
+    ...normalizeParams(params)
+  });
+}
 function _null2(Class2, params) {
   return new Class2({
     type: "null",
     ...normalizeParams(params)
   });
 }
+function _any(Class2) {
+  return new Class2({
+    type: "any"
+  });
+}
 function _unknown(Class2) {
   return new Class2({
     type: "unknown"
@@ -13724,6 +13807,13 @@ function _never(Class2, params) {
     ...normalizeParams(params)
   });
 }
+function _coercedDate(Class2, params) {
+  return new Class2({
+    type: "date",
+    coerce: true,
+    ...normalizeParams(params)
+  });
+}
 function _lt(value, params) {
   return new $ZodCheckLessThan({
     check: "less_than",
@@ -15061,6 +15151,9 @@ var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
   $ZodURL.init(inst, def);
   ZodStringFormat.init(inst, def);
 });
+function url(params) {
+  return _url(ZodURL, params);
+}
 var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
   $ZodEmoji.init(inst, def);
   ZodStringFormat.init(inst, def);
@@ -15163,6 +15256,27 @@ var ZodBoolean2 = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
 function boolean2(params) {
   return _boolean(ZodBoolean2, params);
 }
+var ZodBigInt2 = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
+  $ZodBigInt.init(inst, def);
+  ZodType2.init(inst, def);
+  inst.gte = (value, params) => inst.check(_gte(value, params));
+  inst.min = (value, params) => inst.check(_gte(value, params));
+  inst.gt = (value, params) => inst.check(_gt(value, params));
+  inst.gte = (value, params) => inst.check(_gte(value, params));
+  inst.min = (value, params) => inst.check(_gte(value, params));
+  inst.lt = (value, params) => inst.check(_lt(value, params));
+  inst.lte = (value, params) => inst.check(_lte(value, params));
+  inst.max = (value, params) => inst.check(_lte(value, params));
+  inst.positive = (params) => inst.check(_gt(BigInt(0), params));
+  inst.negative = (params) => inst.check(_lt(BigInt(0), params));
+  inst.nonpositive = (params) => inst.check(_lte(BigInt(0), params));
+  inst.nonnegative = (params) => inst.check(_gte(BigInt(0), params));
+  inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
+  const bag = inst._zod.bag;
+  inst.minValue = bag.minimum ?? null;
+  inst.maxValue = bag.maximum ?? null;
+  inst.format = bag.format ?? null;
+});
 var ZodNull2 = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
   $ZodNull.init(inst, def);
   ZodType2.init(inst, def);
@@ -15170,6 +15284,13 @@ var ZodNull2 = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
 function _null3(params) {
   return _null2(ZodNull2, params);
 }
+var ZodAny2 = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
+  $ZodAny.init(inst, def);
+  ZodType2.init(inst, def);
+});
+function any() {
+  return _any(ZodAny2);
+}
 var ZodUnknown2 = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
   $ZodUnknown.init(inst, def);
   ZodType2.init(inst, def);
@@ -15184,6 +15305,15 @@ var ZodNever2 = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
 function never(params) {
   return _never(ZodNever2, params);
 }
+var ZodDate2 = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => {
+  $ZodDate.init(inst, def);
+  ZodType2.init(inst, def);
+  inst.min = (value, params) => inst.check(_gte(value, params));
+  inst.max = (value, params) => inst.check(_lte(value, params));
+  const c = inst._zod.bag;
+  inst.minDate = c.minimum ? new Date(c.minimum) : null;
+  inst.maxDate = c.maximum ? new Date(c.maximum) : null;
+});
 var ZodArray2 = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
   $ZodArray.init(inst, def);
   ZodType2.init(inst, def);
@@ -15529,6 +15659,46 @@ function preprocess(fn, schema) {
   return pipe(transform(fn), schema);
 }
 
+// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/classic/compat.js
+var ZodIssueCode2 = {
+  invalid_type: "invalid_type",
+  too_big: "too_big",
+  too_small: "too_small",
+  invalid_format: "invalid_format",
+  not_multiple_of: "not_multiple_of",
+  unrecognized_keys: "unrecognized_keys",
+  invalid_union: "invalid_union",
+  invalid_key: "invalid_key",
+  invalid_element: "invalid_element",
+  invalid_value: "invalid_value",
+  custom: "custom"
+};
+
+// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/classic/coerce.js
+var coerce_exports2 = {};
+__export(coerce_exports2, {
+  bigint: () => bigint2,
+  boolean: () => boolean3,
+  date: () => date3,
+  number: () => number3,
+  string: () => string3
+});
+function string3(params) {
+  return _coercedString(ZodString2, params);
+}
+function number3(params) {
+  return _coercedNumber(ZodNumber2, params);
+}
+function boolean3(params) {
+  return _coercedBoolean(ZodBoolean2, params);
+}
+function bigint2(params) {
+  return _coercedBigint(ZodBigInt2, params);
+}
+function date3(params) {
+  return _coercedDate(ZodDate2, params);
+}
+
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/classic/external.js
 config(en_default2());
 
@@ -15928,6 +16098,7 @@ var InitializedNotificationSchema = NotificationSchema.extend({
   method: literal("notifications/initialized"),
   params: NotificationsParamsSchema.optional()
 });
+var isInitializedNotification = (value) => InitializedNotificationSchema.safeParse(value).success;
 var PingRequestSchema = RequestSchema.extend({
   method: literal("ping"),
   params: BaseRequestParamsSchema.optional()
@@ -20955,7 +21126,7 @@ var newHeadersFromIncoming = (incoming) => {
   return new Headers(headerRecord);
 };
 var wrapBodyStream = /* @__PURE__ */ Symbol("wrapBodyStream");
-var newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
+var newRequestFromIncoming = (method, url2, headers, incoming, abortController) => {
   const init = {
     method,
     headers,
@@ -20963,7 +21134,7 @@ var newRequestFromIncoming = (method, url, headers, incoming, abortController) =
   };
   if (method === "TRACE") {
     init.method = "GET";
-    const req = new Request(url, init);
+    const req = new Request(url2, init);
     Object.defineProperty(req, "method", {
       get() {
         return "TRACE";
@@ -21000,7 +21171,7 @@ var newRequestFromIncoming = (method, url, headers, incoming, abortController) =
       init.body = import_stream.Readable.toWeb(incoming);
     }
   }
-  return new Request(url, init);
+  return new Request(url2, init);
 };
 var getRequestCache = /* @__PURE__ */ Symbol("getRequestCache");
 var requestCache = /* @__PURE__ */ Symbol("requestCache");
@@ -21072,8 +21243,8 @@ var newRequest = (incoming, defaultHostname) => {
       throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
     }
     try {
-      const url2 = new URL(incomingUrl);
-      req[urlKey] = url2.href;
+      const url22 = new URL(incomingUrl);
+      req[urlKey] = url22.href;
     } catch (e) {
       throw new RequestError("Invalid absolute URL", { cause: e });
     }
@@ -21092,11 +21263,11 @@ var newRequest = (incoming, defaultHostname) => {
   } else {
     scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
   }
-  const url = new URL(`${scheme}://${host}${incomingUrl}`);
-  if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
+  const url2 = new URL(`${scheme}://${host}${incomingUrl}`);
+  if (url2.hostname.length !== host.length && url2.hostname !== host.replace(/:\d+$/, "")) {
     throw new RequestError("Invalid host header");
   }
-  req[urlKey] = url.href;
+  req[urlKey] = url2.href;
   return req;
 };
 var responseCache = /* @__PURE__ */ Symbol("responseCache");
@@ -21132,14 +21303,14 @@ var Response2 = class _Response {
     }
   }
   get headers() {
-    const cache = this[cacheKey];
-    if (cache) {
-      if (!(cache[2] instanceof Headers)) {
-        cache[2] = new Headers(
-          cache[2] || { "content-type": "text/plain; charset=UTF-8" }
+    const cache2 = this[cacheKey];
+    if (cache2) {
+      if (!(cache2[2] instanceof Headers)) {
+        cache2[2] = new Headers(
+          cache2[2] || { "content-type": "text/plain; charset=UTF-8" }
         );
       }
-      return cache[2];
+      return cache2[2];
     }
     return this[getResponseCache]().headers;
   }
@@ -21243,16 +21414,16 @@ var handleFetchError = (e) => new Response(null, {
   status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
 });
 var handleResponseError = (e, outgoing) => {
-  const err5 = e instanceof Error ? e : new Error("unknown error", { cause: e });
-  if (err5.code === "ERR_STREAM_PREMATURE_CLOSE") {
+  const err6 = e instanceof Error ? e : new Error("unknown error", { cause: e });
+  if (err6.code === "ERR_STREAM_PREMATURE_CLOSE") {
     console.info("The user aborted a request.");
   } else {
     console.error(e);
     if (!outgoing.headersSent) {
       outgoing.writeHead(500, { "Content-Type": "text/plain" });
     }
-    outgoing.end(`Error: ${err5.message}`);
-    outgoing.destroy(err5);
+    outgoing.end(`Error: ${err6.message}`);
+    outgoing.destroy(err6);
   }
 };
 var flushHeaders = (outgoing) => {
@@ -21309,8 +21480,8 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
     if (options.errorHandler) {
       try {
         res = await res;
-      } catch (err5) {
-        const errRes = await options.errorHandler(err5);
+      } catch (err6) {
+        const errRes = await options.errorHandler(err6);
         if (!errRes) {
           return;
         }
@@ -22271,12 +22442,12 @@ function workspacePath(ctx, suffix = "") {
   return `${base}/api/workspaces/${ctx.workspaceId}${suffix}`;
 }
 var DEFAULT_TIMEOUT_MS = 3e4;
-async function request(ctx, method, url, body, opts) {
+async function request(ctx, method, url2, body, opts) {
   const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const res = await fetch(url, {
+    const res = await fetch(url2, {
       method,
       headers: {
         "Authorization": `Bearer ${ctx.token}`,
@@ -22300,19 +22471,23 @@ async function request(ctx, method, url, body, opts) {
       throw new Error(message || `HTTP ${res.status}`);
     }
     return res.json();
-  } catch (err5) {
+  } catch (err6) {
     clearTimeout(timer);
-    if (err5 instanceof Error && err5.name === "AbortError") {
-      throw new Error(`Request timed out after ${timeoutMs}ms: ${method} ${url}`);
+    if (err6 instanceof Error && err6.name === "AbortError") {
+      throw new Error(`Request timed out after ${timeoutMs}ms: ${method} ${url2}`);
     }
-    throw err5;
+    throw err6;
   }
 }
 async function getProject(ctx) {
   return request(ctx, "GET", projectPath(ctx));
 }
+async function getProjectDigest(ctx) {
+  return request(ctx, "GET", projectPath(ctx, "/digest"));
+}
 async function updateProject(ctx, description) {
-  return request(ctx, "PATCH", projectPath(ctx), { description });
+  const res = await request(ctx, "PATCH", projectPath(ctx), { description });
+  return res.project;
 }
 async function getTodos(ctx, scope) {
   const qs = scope === "active" ? "?scope=active" : "";
@@ -22341,8 +22516,8 @@ async function getProjectHistory(ctx, limit) {
 }
 async function getMyAssignment(ctx) {
   if (!ctx.agentId) throw new Error("agentId not set in BridgeContext");
-  const url = `${projectPath(ctx, "/assignment")}?agentId=${encodeURIComponent(ctx.agentId)}`;
-  return request(ctx, "GET", url);
+  const url2 = `${projectPath(ctx, "/assignment")}?agentId=${encodeURIComponent(ctx.agentId)}`;
+  return request(ctx, "GET", url2);
 }
 async function completeMyTask(ctx, todoId) {
   return request(ctx, "POST", projectPath(ctx, `/todos/${todoId}/done`));
@@ -22386,15 +22561,18 @@ async function spawnAgent(ctx, agentKey, daemonId, role, cmd, model) {
 }
 async function killAgent(ctx, agentId) {
   const base = ctx.serverUrl.replace(/\/$/, "");
-  const url = ctx.projectId && ctx.projectId !== "workspace" ? `${base}/api/workspaces/${ctx.workspaceId}/projects/${ctx.projectId}/agents/${agentId}` : `${base}/api/workspaces/${ctx.workspaceId}/agents/${agentId}`;
-  return request(ctx, "DELETE", url);
+  const url2 = ctx.projectId && ctx.projectId !== "workspace" ? `${base}/api/workspaces/${ctx.workspaceId}/projects/${ctx.projectId}/agents/${agentId}` : `${base}/api/workspaces/${ctx.workspaceId}/agents/${agentId}`;
+  return request(ctx, "DELETE", url2);
 }
 async function assignTask(ctx, todoId, agentId) {
   return request(ctx, "POST", projectPath(ctx, `/todos/${todoId}/assign`), { agentId });
 }
-async function getAgentOutput(ctx, agentId, lines) {
-  const qs = lines !== void 0 ? `?lines=${lines}` : "";
-  return request(ctx, "GET", projectPath(ctx, `/panels/${agentId}/output${qs}`));
+async function getAgentOutput(ctx, agentId, lines, cursor) {
+  const params = new URLSearchParams();
+  if (lines !== void 0) params.set("lines", String(lines));
+  if (cursor) params.set("cursor", cursor);
+  const qs = params.toString();
+  return request(ctx, "GET", projectPath(ctx, `/panels/${agentId}/output${qs ? `?${qs}` : ""}`));
 }
 async function sendAgentInput(ctx, agentId, text) {
   return request(ctx, "POST", workspacePath(ctx, `/agents/${agentId}/input`), { text });
@@ -22406,11 +22584,11 @@ async function recordProjectEvent(ctx, params) {
   const { projectId, ...body } = params;
   const explicitProjectId = projectId?.trim();
   const isWorkspaceScope = ctx.projectId === "workspace" && !explicitProjectId;
-  const url = isWorkspaceScope ? workspacePath(ctx, "/events") : projectPath(ctx, "/events", explicitProjectId);
+  const url2 = isWorkspaceScope ? workspacePath(ctx, "/events") : projectPath(ctx, "/events", explicitProjectId);
   return request(
     ctx,
     "POST",
-    url,
+    url2,
     { ...body, agentId: ctx.agentId }
   );
 }
@@ -22484,14 +22662,16 @@ async function applyPersona(ctx, params) {
   });
 }
 async function listRolePrompts(ctx) {
-  return request(ctx, "GET", workspacePath(ctx, "/prompts"));
+  const qs = ctx.projectId ? `?projectId=${encodeURIComponent(ctx.projectId)}` : "";
+  return request(ctx, "GET", workspacePath(ctx, `/prompts${qs}`));
 }
 async function getRolePrompt(ctx, role) {
   const start = Date.now();
+  const qs = ctx.projectId ? `?projectId=${encodeURIComponent(ctx.projectId)}` : "";
   const res = await request(
     ctx,
     "GET",
-    workspacePath(ctx, `/prompts/${encodeURIComponent(role)}`)
+    workspacePath(ctx, `/prompts/${encodeURIComponent(role)}${qs}`)
   );
   const latencyMs = Date.now() - start;
   const bytes = res.content.length;
@@ -22533,9 +22713,37 @@ function registerPlanTools(server, ctx) {
       return { content: [{ type: "text", text: JSON.stringify(data) }] };
     }
   );
+  server.tool(
+    "bridge_get_blueprint",
+    "Get the project blueprint \u2014 the architecture/conventions/features/decisions markdown doc for this project. Returns { blueprint, updatedAt }; updatedAt is null when the blueprint was never seeded.",
+    {},
+    async () => {
+      const project = await getProject(ctx);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ blueprint: project.description ?? "", updatedAt: project.blueprintUpdatedAt ?? null })
+        }]
+      };
+    }
+  );
+  server.tool(
+    "bridge_update_blueprint",
+    "Update the project blueprint markdown doc. Stored as the project description and immediately reflected in the Bridge UI. Returns { ok, blueprint, updatedAt }.",
+    { content: external_exports.string().describe("New blueprint content in Markdown") },
+    async ({ content }) => {
+      const project = await updateProject(ctx, content);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ ok: true, blueprint: project.description ?? "", updatedAt: project.blueprintUpdatedAt ?? null })
+        }]
+      };
+    }
+  );
   server.tool(
     "bridge_get_plan",
-    "Get the current plan / spec for this Bridge project. Returns the markdown content stored in the project description field.",
+    "DEPRECATED \u2014 use bridge_get_blueprint. Get the current plan / spec for this Bridge project (legacy { plan } response shape).",
     {},
     async () => {
       const project = await getProject(ctx);
@@ -22549,14 +22757,14 @@ function registerPlanTools(server, ctx) {
   );
   server.tool(
     "bridge_update_plan",
-    "Update the plan / spec for this Bridge project. The content will be stored as the project description and immediately reflected in the Bridge UI.",
+    "DEPRECATED \u2014 use bridge_update_blueprint. Update the plan / spec for this Bridge project (legacy response shape).",
     { content: external_exports.string().describe("New plan content in Markdown") },
     async ({ content }) => {
-      const result = await updateProject(ctx, content);
+      await updateProject(ctx, content);
       return {
         content: [{
           type: "text",
-          text: JSON.stringify(result)
+          text: JSON.stringify({ ok: true })
         }]
       };
     }
@@ -22672,65 +22880,89 @@ var EVENT_ROLES = [...AGENT_ROLES, "system"];
 // ../shared/dist/tool-registry.js
 var BRIDGE_TOOL_DOCS = {
   // Project / plan
-  bridge_get_project: "Project metadata: name, cwd, machineId",
-  bridge_get_plan: "Read project spec/description",
-  bridge_update_plan: "Update project spec/description",
-  bridge_get_project_history: "Past run history and failure patterns",
-  bridge_get_execution_status: "Run history with todo completion counts",
+  bridge_get_project: "Project metadata (name, cwd, machineId)",
+  bridge_get_project_digest: "Repo file-tree digest (capped), on demand",
+  bridge_get_blueprint: "Read project blueprint doc ({blueprint, updatedAt})",
+  bridge_update_blueprint: "Update project blueprint doc",
+  bridge_get_project_history: "Past runs + failure patterns",
+  bridge_get_execution_status: "Run history + todo completion counts",
   // Todos
-  bridge_get_todos: "List todos + session state for this project",
-  bridge_add_todo: "Create a new todo (title, todoType, dependsOn)",
-  bridge_update_todo: "Update a todo title or status",
-  bridge_cancel_run: "Cancel active run (use before restarting a stale plan)",
+  bridge_get_todos: "List todos + session state",
+  bridge_add_todo: "Create todo (title, todoType, dependsOn)",
+  bridge_update_todo: "Update todo title/status",
+  bridge_cancel_run: "Cancel active run (before restarting a stale plan)",
   // Panel management
-  bridge_list_agents: "All agents: role, status, inRun flag",
-  bridge_get_agent_status: "Single agent status check",
-  bridge_spawn_worker: "Spawn a new worker agent (agentKey, role)",
-  bridge_kill_agent: "Terminate a stuck or dead agent",
-  bridge_get_agent_output: "Read terminal output of any agent",
-  bridge_send_input: "Send text input to an agent PTY",
+  bridge_list_agents: "All agents: role, status, inRun",
+  bridge_get_agent_status: "Single agent status",
+  bridge_spawn_worker: "Spawn worker (agentKey, role)",
+  bridge_kill_agent: "Terminate stuck/dead agent",
+  bridge_get_agent_output: "Read agent terminal output (round-trip cursor = delta read)",
+  bridge_send_input: "Send text input to agent PTY",
   // Worker task lifecycle
-  bridge_get_my_task: "Get the task assigned to this agent",
+  bridge_get_my_task: "This agent's assigned task",
   bridge_complete_task: "Signal task completion",
-  bridge_fail_task: "Signal task failure with a specific reason",
-  bridge_get_todo_context: "Read todo output/error for a specific todo",
-  bridge_assign_task: "Assign a pending todo to a specific agent",
+  bridge_fail_task: "Signal failure with reason",
+  bridge_get_todo_context: "Read a todo's output/error",
+  bridge_assign_task: "Assign pending todo to an agent",
   // Workspace scope (Phase 6)
-  bridge_list_groups: "List all agent groups and their member agentIds",
-  bridge_get_group_status: "Get agents in a group with status and last output line",
-  bridge_dispatch_to_group: "Send a text message/command to every agent in a group",
-  bridge_list_workspace_projects: "List all workspace projects with name, cwd, active run count",
-  bridge_query_workspace: "Natural-language query about orchestration state",
-  bridge_list_active_runs: "All active orchestration runs across workspace projects",
-  bridge_peek_panel: "Read terminal output of any panel workspace-wide (no project boundary)",
-  bridge_status_panel: "Get status of any panel in the workspace regardless of project",
+  bridge_list_groups: "Groups + member agentIds",
+  bridge_get_group_status: "Group agents: status + last output line",
+  bridge_dispatch_to_group: "Send message to every agent in a group",
+  bridge_create_group: "Create group (name, optional color)",
+  bridge_update_group: "Rename/recolor a group",
+  bridge_delete_group: "Delete a group",
+  bridge_assign_agent_to_group: "Move agent into a group, or remove (groupId: null); orchestrators cannot join",
+  bridge_list_workspace_projects: "Workspace projects: name, cwd, active run count",
+  bridge_query_workspace: "Natural-language query of orchestration state",
+  bridge_list_active_runs: "Active runs across workspace projects",
+  bridge_peek_panel: "Read any panel output workspace-wide (cursor = delta read)",
+  bridge_status_panel: "Status of any panel workspace-wide",
   // Personas
-  bridge_get_persona: "Fetch a persona by id (name, systemPrompt, role, agentKey)",
-  bridge_list_personas: "List all personas visible to the caller (workspace + personal)",
-  bridge_create_persona: "Create a custom persona definition",
-  bridge_update_persona: "Update persona definition fields",
-  bridge_archive_persona: "Archive an outdated persona",
-  bridge_launch_persona: "Spawn a worker initialized with a specific persona",
-  bridge_apply_persona: "Apply persona configuration to an existing running worker",
+  bridge_get_persona: "Persona by id (name, systemPrompt, role, agentKey)",
+  bridge_list_personas: "Visible personas (workspace + personal)",
+  bridge_create_persona: "Create persona",
+  bridge_update_persona: "Update persona fields",
+  bridge_archive_persona: "Archive a persona",
+  bridge_launch_persona: "Spawn worker with a persona",
+  bridge_apply_persona: "Apply persona to a running worker",
+  // Group Schemas (reusable team templates)
+  bridge_list_group_schemas: "Reusable team/group schema templates",
+  bridge_create_group_schema: "Create group schema from current groups",
+  bridge_update_group_schema: "Update a group schema (name/slug/desc/color/groups/shared)",
+  bridge_apply_group_schema: "Spawn a schema's groups and agents",
+  // Agent Model Info
+  bridge_list_agent_models: "Available models for an agent key on a daemon",
   // Messaging
-  bridge_send_message: "Send direct message to peer agent conversation",
-  bridge_poll_messages: "Poll unread messages delivered to this agent",
+  bridge_send_message: "Direct message to a peer agent",
+  bridge_poll_messages: "Poll unread messages for this agent",
   // Role Prompts
-  bridge_list_role_prompts: "List available system role prompt templates",
-  bridge_get_role_prompt: "Fetch resolved system role prompt template",
-  bridge_update_role_prompt: "Update custom role prompt template",
-  bridge_delete_role_prompt: "Delete custom role prompt template",
-  // Events & Memory
-  bridge_agent_is_idle: "Check if agent terminal PTY is idle and ready for command injection",
-  bridge_record_event: "Record an event, constraint, or blocker for orchestration memory",
-  bridge_get_project_events: "Fetch recorded project events filtered by tags or permanence",
-  bridge_get_project_memory: "Fetch durable permanent guardrails and architectural constraints",
-  bridge_update_todo_status: "Update todo status directly without modifying title"
+  bridge_list_role_prompts: "Role prompt templates",
+  bridge_get_role_prompt: "Fetch resolved role prompt",
+  bridge_update_role_prompt: "Update custom role prompt",
+  bridge_delete_role_prompt: "Delete custom role prompt",
+  bridge_update_todo_status: "Update todo status only",
+  // Codegraph (structural code intelligence — PREFER over Read/Grep for structure)
+  bridge_codegraph_status: "Codegraph index status + resolution coverage",
+  bridge_codegraph_index: "Index/refresh a project for codegraph",
+  bridge_codegraph_find_symbol: "Find a symbol by name (where is X)",
+  bridge_codegraph_file_outline: "Structural outline of a single file",
+  bridge_codegraph_find_references: "All call/reference sites of a symbol (who calls X)",
+  bridge_codegraph_call_graph: "Call graph (in/out/both) around a symbol",
+  bridge_codegraph_get_symbol_source: "Source snippet of a qualified symbol",
+  bridge_codegraph_diff_impact: "Blast-radius of a git diff (changed exported symbols + transitive callers)"
 };
 if (Object.keys(BRIDGE_TOOL_DOCS).length === 0) {
   throw new Error("BRIDGE_TOOL_DOCS registry is empty at module load \u2014 fail fast");
 }
 
+// ../shared/dist/blueprint.js
+var BLUEPRINT_H1_AREAS = ["Frontend", "Backend", "Other"];
+var BLUEPRINT_H2_ASPECTS = ["Architecture", "Conventions", "Features", "Decisions"];
+var BLUEPRINT_DOC_TEMPLATE = BLUEPRINT_H1_AREAS.map((area) => `# ${area}
+
+` + BLUEPRINT_H2_ASPECTS.map((aspect) => `## ${aspect}
+`).join("\n")).join("\n");
+
 // ../mcp-server/src/tools/orchestration.ts
 function ok(data) {
   return { content: [{ type: "text", text: JSON.stringify(data) }] };
@@ -22815,12 +23047,13 @@ function registerOrchestrationTools(server, ctx) {
   );
   server.tool(
     "bridge_get_agent_output",
-    "Read the last N lines of a panel's terminal output (ANSI codes stripped). Use this to check a dev server for errors, verify a build succeeded, or read a shell panel's result. Works on any agent type \u2014 dev servers, shells, AI agents.",
+    "Read the last N lines of a panel's terminal output (ANSI codes stripped). Returns { output, cursor, cursor_reset }. Round-trip the returned cursor on the next call to get only new output (delta) \u2014 omit it for a full tail. cursor_reset: true means the cursor went stale (buffer evicted or panel respawned) and a full tail was returned. Use this to check a dev server for errors, verify a build succeeded, or read a shell panel's result. Works on any agent type \u2014 dev servers, shells, AI agents.",
     {
       agentId: external_exports.string().describe("The agent ID to read"),
-      lines: external_exports.number().int().min(1).max(300).optional().describe("Trailing lines to return (default 50, max 300)")
+      lines: external_exports.number().int().min(1).max(300).optional().describe("Trailing lines for full-tail reads (default 50, max 300); delta reads return all new lines"),
+      cursor: external_exports.string().optional().describe("Opaque cursor from a previous response \u2014 pass it back to receive only new output since that read")
     },
-    ({ agentId, lines }) => safe(() => getAgentOutput(ctx, agentId, lines))
+    ({ agentId, lines, cursor }) => safe(() => getAgentOutput(ctx, agentId, lines, cursor))
   );
   server.tool(
     "bridge_send_input",
@@ -22986,6 +23219,12 @@ function registerWorkspaceTools(server, ctx) {
     {},
     () => safe2(() => getProject(ctx))
   );
+  server.tool(
+    "bridge_get_project_digest",
+    "Get the repository file-tree digest for the current project (capped to preserve context budget). Use on demand for codebase orientation instead of expecting it at startup.",
+    {},
+    () => safe2(() => getProjectDigest(ctx))
+  );
   server.tool(
     "bridge_query_workspace",
     "Natural-language query about orchestration state (runs, todos, failures). No LLM involved \u2014 deterministic answer.",
@@ -23000,12 +23239,19 @@ function registerWorkspaceTools(server, ctx) {
   );
   server.tool(
     "bridge_peek_panel",
-    "Read the last N lines of a panel's terminal output. Project-scoped contexts may only peek at their own project's panels (403 cross_project_block otherwise); workspace scope has no project boundary. Use this to check what a specific agent is doing.",
+    "Read the last N lines of a panel's terminal output. Project-scoped contexts may only peek at their own project's panels (403 cross_project_block otherwise); workspace scope has no project boundary. Use this to check what a specific agent is doing. Returns { output, cursor, cursor_reset } \u2014 round-trip the cursor on the next call to get only new output (delta); omit it for a full tail.",
     {
       agentId: external_exports.string().describe("The panel/agent ID to peek at"),
-      lines: external_exports.number().int().min(1).max(300).optional().describe("Trailing lines to return (default 50, max 300)")
+      lines: external_exports.number().int().min(1).max(300).optional().describe("Trailing lines for full-tail reads (default 50, max 300); delta reads return all new lines"),
+      cursor: external_exports.string().optional().describe("Opaque cursor from a previous response \u2014 pass it back to receive only new output since that read")
     },
-    ({ agentId, lines }) => safe2(() => request(ctx, "GET", workspacePath(ctx, `/agents/${agentId}/output${lines !== void 0 ? `?lines=${lines}` : ""}`)))
+    ({ agentId, lines, cursor }) => safe2(() => {
+      const params = new URLSearchParams();
+      if (lines !== void 0) params.set("lines", String(lines));
+      if (cursor) params.set("cursor", cursor);
+      const qs = params.toString();
+      return request(ctx, "GET", workspacePath(ctx, `/agents/${agentId}/output${qs ? `?${qs}` : ""}`));
+    })
   );
   server.tool(
     "bridge_status_panel",
@@ -23013,6 +23259,49 @@ function registerWorkspaceTools(server, ctx) {
     { agentId: external_exports.string().describe("The panel/agent ID to inspect") },
     ({ agentId }) => safe2(() => request(ctx, "GET", workspacePath(ctx, `/agents/${agentId}`)))
   );
+  server.tool(
+    "bridge_create_group",
+    "Create a new agent group in the current project with an optional color.",
+    {
+      name: external_exports.string().min(1).max(64).describe("Human-readable group name"),
+      color: external_exports.string().regex(/^#[0-9a-fA-F]{6}$/).optional().describe("Hex color e.g. #6366f1")
+    },
+    ({ name, color }) => safe2(() => {
+      if (!ctx.projectId) throw new Error("Project-scoped context required");
+      return request(ctx, "POST", workspacePath(ctx, `/projects/${ctx.projectId}/groups`), { name, color });
+    })
+  );
+  server.tool(
+    "bridge_update_group",
+    "Rename or recolor an existing agent group.",
+    {
+      groupId: external_exports.string().describe("The group ID to update"),
+      name: external_exports.string().min(1).max(64).optional().describe("New group name"),
+      color: external_exports.string().regex(/^#[0-9a-fA-F]{6}$/).optional().describe("New hex color e.g. #6366f1")
+    },
+    ({ groupId, name, color }) => safe2(() => {
+      if (!ctx.projectId) throw new Error("Project-scoped context required");
+      return request(ctx, "PATCH", workspacePath(ctx, `/projects/${ctx.projectId}/groups/${groupId}`), { name, color });
+    })
+  );
+  server.tool(
+    "bridge_assign_agent_to_group",
+    "Assign a running agent to a group (team), or remove it with groupId:null. Orchestrator panels cannot join groups. Project-scoped context required; the group must already exist (use bridge_create_group first).",
+    { agentId: external_exports.string().min(1), groupId: external_exports.string().nullable() },
+    ({ agentId, groupId }) => safe2(() => {
+      if (!ctx.projectId) throw new Error("Project-scoped context required");
+      return request(ctx, "PATCH", workspacePath(ctx, `/projects/${ctx.projectId}/agents/${agentId}/group`), { groupId });
+    })
+  );
+  server.tool(
+    "bridge_delete_group",
+    "Delete an agent group. Members are detached but keep running.",
+    { groupId: external_exports.string().describe("The group ID to delete") },
+    ({ groupId }) => safe2(() => {
+      if (!ctx.projectId) throw new Error("Project-scoped context required");
+      return request(ctx, "DELETE", workspacePath(ctx, `/projects/${ctx.projectId}/groups/${groupId}`));
+    })
+  );
 }
 
 // ../mcp-server/src/tools/personas.ts
@@ -23188,17 +23477,2374 @@ function registerRolePromptTools(server, ctx) {
   );
 }
 
-// ../mcp-server/src/index.ts
-var sessions = /* @__PURE__ */ new Map();
-function buildMcpServer(ctx) {
-  const srv = new McpServer({ name: "bridge", version: "0.1.0" });
-  registerPlanTools(srv, ctx);
-  registerTodoTools(srv, ctx);
-  registerOrchestrationTools(srv, ctx);
-  registerMessagingTools(srv, ctx);
-  registerWorkspaceTools(srv, ctx);
-  registerPersonaTools(srv, ctx);
-  registerRolePromptTools(srv, ctx);
+// ../mcp-server/src/tools/group-schemas.ts
+function ok5(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+function err5(message) {
+  return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: message }) }] };
+}
+async function safe5(fn) {
+  try {
+    return ok5(await fn());
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    if (e instanceof Error && (e.name === "TypeError" || e.name === "ReferenceError")) {
+      console.error("[mcp-bridge] unexpected error in group-schema tool handler", { name: e.name, message, stack: e.stack });
+    }
+    return err5(message);
+  }
+}
+function registerGroupSchemaTools(server, ctx) {
+  server.tool(
+    "bridge_list_group_schemas",
+    "List reusable team/group schema templates saved in this workspace. Returns name, slug, color, groupsJson payload, and metadata for each schema.",
+    {
+      scope: external_exports.enum(["personal", "workspace", "project"]).optional().describe("Scope filter"),
+      projectId: external_exports.string().optional().describe("Filter to a specific project"),
+      q: external_exports.string().optional().describe("Substring search on name")
+    },
+    ({ scope, projectId, q }) => safe5(() => {
+      let path = "/group-schemas";
+      const params = new URLSearchParams();
+      if (scope) params.set("scope", scope);
+      if (projectId) params.set("projectId", projectId);
+      if (q) params.set("q", q);
+      const qs = params.toString();
+      if (qs) path += "?" + qs;
+      return request(ctx, "GET", workspacePath(ctx, path));
+    })
+  );
+  server.tool(
+    "bridge_apply_group_schema",
+    "Apply a group schema template to spawn all its groups and agents in one call. Validates model availability against the target daemon. Returns created groups + agent IDs and any partial failures.",
+    {
+      schemaId: external_exports.string().describe("The group schema ID to apply"),
+      projectId: external_exports.string().describe("Target project ID"),
+      daemonId: external_exports.string().optional().describe("Target daemon ID (auto-resolves if omitted)"),
+      mode: external_exports.enum(["auto-suffix", "replace"]).optional().describe("Name collision mode: auto-suffix (default) appends -2, -3, etc; replace reaps existing teams first")
+    },
+    ({ schemaId, projectId, daemonId, mode }) => safe5(
+      () => request(
+        ctx,
+        "POST",
+        workspacePath(ctx, `/group-schemas/${schemaId}/apply`),
+        { projectId, daemonId, mode }
+      )
+    )
+  );
+  server.tool(
+    "bridge_create_group_schema",
+    "Create a reusable group schema template from the current project group setup. Serializes groups and agent slots into a template that can be applied later with bridge_apply_group_schema.",
+    {
+      name: external_exports.string().min(1).max(80).describe("Display name for the schema"),
+      slug: external_exports.string().regex(/^[a-z][a-z0-9_]{1,62}$/).describe("Unique slug (lowercase, starts with letter, a-z0-9_ only, 2-63 chars)"),
+      description: external_exports.string().max(200).optional().describe("Optional description"),
+      color: external_exports.string().regex(/^#[0-9a-fA-F]{6}$/).optional().describe("Hex colour for the schema card"),
+      groupsJson: external_exports.any().optional().describe("GroupSchemaPayload: { version:1, groups:[{name, color?, slots:[{agentKey, model?, role?, count, cmd?}]}] }"),
+      scope: external_exports.enum(["personal", "workspace", "project"]).optional().describe("Visibility scope (default: workspace)"),
+      projectId: external_exports.string().optional().describe("Project ID (required if scope=project)")
+    },
+    ({ name, slug, description, color, groupsJson, scope, projectId }) => safe5(
+      () => request(
+        ctx,
+        "POST",
+        workspacePath(ctx, "/group-schemas"),
+        { name, slug, description, color, groupsJson, scope, projectId }
+      )
+    )
+  );
+  server.tool(
+    "bridge_update_group_schema",
+    "Update an existing (non-archived) group schema template. Pass schemaId plus only the fields to change (name, slug, description, color, groupsJson, shared). Returns the updated schema.",
+    {
+      schemaId: external_exports.string().describe("The group schema ID to update"),
+      name: external_exports.string().min(1).max(80).optional().describe("New display name"),
+      slug: external_exports.string().regex(/^[a-z][a-z0-9_]{1,62}$/).optional().describe("New unique slug (lowercase, starts with letter, a-z0-9_, 2-63 chars)"),
+      description: external_exports.string().max(200).optional().describe("New description"),
+      color: external_exports.string().regex(/^#[0-9a-fA-F]{6}$/).optional().describe("New hex colour e.g. #6366f1"),
+      groupsJson: external_exports.any().optional().describe("Replacement GroupSchemaPayload: { version:1, groups:[{name, color?, slots:[{agentKey, model?, role?, count, cmd?}]}] }"),
+      shared: external_exports.boolean().optional().describe("Workspace-scope only: mark the schema shared across the workspace")
+    },
+    ({ schemaId, name, slug, description, color, groupsJson, shared }) => safe5(
+      () => request(
+        ctx,
+        "PATCH",
+        workspacePath(ctx, `/group-schemas/${schemaId}`),
+        { name, slug, description, color, groupsJson, shared }
+      )
+    )
+  );
+  server.tool(
+    "bridge_list_agent_models",
+    "List available models for an agent key on a target daemon. Validates model portability across machines; use before applying a group schema to verify required models exist.",
+    {
+      agentKey: external_exports.string().optional().describe("Filter by agent key (e.g. claude, kimi, qwen)"),
+      daemonId: external_exports.string().optional().describe("Filter by daemon ID")
+    },
+    ({ agentKey, daemonId }) => safe5(() => {
+      let path = "/agent-models";
+      const params = new URLSearchParams();
+      if (agentKey) params.set("agentKey", agentKey);
+      if (daemonId) params.set("daemonId", daemonId);
+      const qs = params.toString();
+      if (qs) path += "?" + qs;
+      return request(ctx, "GET", workspacePath(ctx, path));
+    })
+  );
+}
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.28.0_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/client.js
+var ExperimentalClientTasks = class {
+  constructor(_client) {
+    this._client = _client;
+  }
+  /**
+   * Calls a tool and returns an AsyncGenerator that yields response messages.
+   * The generator is guaranteed to end with either a 'result' or 'error' message.
+   *
+   * This method provides streaming access to tool execution, allowing you to
+   * observe intermediate task status updates for long-running tool calls.
+   * Automatically validates structured output if the tool has an outputSchema.
+   *
+   * @example
+   * ```typescript
+   * const stream = client.experimental.tasks.callToolStream({ name: 'myTool', arguments: {} });
+   * for await (const message of stream) {
+   *   switch (message.type) {
+   *     case 'taskCreated':
+   *       console.log('Tool execution started:', message.task.taskId);
+   *       break;
+   *     case 'taskStatus':
+   *       console.log('Tool status:', message.task.status);
+   *       break;
+   *     case 'result':
+   *       console.log('Tool result:', message.result);
+   *       break;
+   *     case 'error':
+   *       console.error('Tool error:', message.error);
+   *       break;
+   *   }
+   * }
+   * ```
+   *
+   * @param params - Tool call parameters (name and arguments)
+   * @param resultSchema - Zod schema for validating the result (defaults to CallToolResultSchema)
+   * @param options - Optional request options (timeout, signal, task creation params, etc.)
+   * @returns AsyncGenerator that yields ResponseMessage objects
+   *
+   * @experimental
+   */
+  async *callToolStream(params, resultSchema = CallToolResultSchema, options) {
+    const clientInternal = this._client;
+    const optionsWithTask = {
+      ...options,
+      // We check if the tool is known to be a task during auto-configuration, but assume
+      // the caller knows what they're doing if they pass this explicitly
+      task: options?.task ?? (clientInternal.isToolTask(params.name) ? {} : void 0)
+    };
+    const stream = clientInternal.requestStream({ method: "tools/call", params }, resultSchema, optionsWithTask);
+    const validator = clientInternal.getToolOutputValidator(params.name);
+    for await (const message of stream) {
+      if (message.type === "result" && validator) {
+        const result = message.result;
+        if (!result.structuredContent && !result.isError) {
+          yield {
+            type: "error",
+            error: new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`)
+          };
+          return;
+        }
+        if (result.structuredContent) {
+          try {
+            const validationResult = validator(result.structuredContent);
+            if (!validationResult.valid) {
+              yield {
+                type: "error",
+                error: new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`)
+              };
+              return;
+            }
+          } catch (error2) {
+            if (error2 instanceof McpError) {
+              yield { type: "error", error: error2 };
+              return;
+            }
+            yield {
+              type: "error",
+              error: new McpError(ErrorCode.InvalidParams, `Failed to validate structured content: ${error2 instanceof Error ? error2.message : String(error2)}`)
+            };
+            return;
+          }
+        }
+      }
+      yield message;
+    }
+  }
+  /**
+   * Gets the current status of a task.
+   *
+   * @param taskId - The task identifier
+   * @param options - Optional request options
+   * @returns The task status
+   *
+   * @experimental
+   */
+  async getTask(taskId, options) {
+    return this._client.getTask({ taskId }, options);
+  }
+  /**
+   * Retrieves the result of a completed task.
+   *
+   * @param taskId - The task identifier
+   * @param resultSchema - Zod schema for validating the result
+   * @param options - Optional request options
+   * @returns The task result
+   *
+   * @experimental
+   */
+  async getTaskResult(taskId, resultSchema, options) {
+    return this._client.getTaskResult({ taskId }, resultSchema, options);
+  }
+  /**
+   * Lists tasks with optional pagination.
+   *
+   * @param cursor - Optional pagination cursor
+   * @param options - Optional request options
+   * @returns List of tasks with optional next cursor
+   *
+   * @experimental
+   */
+  async listTasks(cursor, options) {
+    return this._client.listTasks(cursor ? { cursor } : void 0, options);
+  }
+  /**
+   * Cancels a running task.
+   *
+   * @param taskId - The task identifier
+   * @param options - Optional request options
+   *
+   * @experimental
+   */
+  async cancelTask(taskId, options) {
+    return this._client.cancelTask({ taskId }, options);
+  }
+  /**
+   * Sends a request and returns an AsyncGenerator that yields response messages.
+   * The generator is guaranteed to end with either a 'result' or 'error' message.
+   *
+   * This method provides streaming access to request processing, allowing you to
+   * observe intermediate task status updates for task-augmented requests.
+   *
+   * @param request - The request to send
+   * @param resultSchema - Zod schema for validating the result
+   * @param options - Optional request options (timeout, signal, task creation params, etc.)
+   * @returns AsyncGenerator that yields ResponseMessage objects
+   *
+   * @experimental
+   */
+  requestStream(request2, resultSchema, options) {
+    return this._client.requestStream(request2, resultSchema, options);
+  }
+};
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.28.0_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/client/index.js
+function applyElicitationDefaults(schema, data) {
+  if (!schema || data === null || typeof data !== "object")
+    return;
+  if (schema.type === "object" && schema.properties && typeof schema.properties === "object") {
+    const obj = data;
+    const props = schema.properties;
+    for (const key of Object.keys(props)) {
+      const propSchema = props[key];
+      if (obj[key] === void 0 && Object.prototype.hasOwnProperty.call(propSchema, "default")) {
+        obj[key] = propSchema.default;
+      }
+      if (obj[key] !== void 0) {
+        applyElicitationDefaults(propSchema, obj[key]);
+      }
+    }
+  }
+  if (Array.isArray(schema.anyOf)) {
+    for (const sub of schema.anyOf) {
+      if (typeof sub !== "boolean") {
+        applyElicitationDefaults(sub, data);
+      }
+    }
+  }
+  if (Array.isArray(schema.oneOf)) {
+    for (const sub of schema.oneOf) {
+      if (typeof sub !== "boolean") {
+        applyElicitationDefaults(sub, data);
+      }
+    }
+  }
+}
+function getSupportedElicitationModes(capabilities) {
+  if (!capabilities) {
+    return { supportsFormMode: false, supportsUrlMode: false };
+  }
+  const hasFormCapability = capabilities.form !== void 0;
+  const hasUrlCapability = capabilities.url !== void 0;
+  const supportsFormMode = hasFormCapability || !hasFormCapability && !hasUrlCapability;
+  const supportsUrlMode = hasUrlCapability;
+  return { supportsFormMode, supportsUrlMode };
+}
+var Client = class extends Protocol {
+  /**
+   * Initializes this client with the given name and version information.
+   */
+  constructor(_clientInfo, options) {
+    super(options);
+    this._clientInfo = _clientInfo;
+    this._cachedToolOutputValidators = /* @__PURE__ */ new Map();
+    this._cachedKnownTaskTools = /* @__PURE__ */ new Set();
+    this._cachedRequiredTaskTools = /* @__PURE__ */ new Set();
+    this._listChangedDebounceTimers = /* @__PURE__ */ new Map();
+    this._capabilities = options?.capabilities ?? {};
+    this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
+    if (options?.listChanged) {
+      this._pendingListChangedConfig = options.listChanged;
+    }
+  }
+  /**
+   * Set up handlers for list changed notifications based on config and server capabilities.
+   * This should only be called after initialization when server capabilities are known.
+   * Handlers are silently skipped if the server doesn't advertise the corresponding listChanged capability.
+   * @internal
+   */
+  _setupListChangedHandlers(config2) {
+    if (config2.tools && this._serverCapabilities?.tools?.listChanged) {
+      this._setupListChangedHandler("tools", ToolListChangedNotificationSchema, config2.tools, async () => {
+        const result = await this.listTools();
+        return result.tools;
+      });
+    }
+    if (config2.prompts && this._serverCapabilities?.prompts?.listChanged) {
+      this._setupListChangedHandler("prompts", PromptListChangedNotificationSchema, config2.prompts, async () => {
+        const result = await this.listPrompts();
+        return result.prompts;
+      });
+    }
+    if (config2.resources && this._serverCapabilities?.resources?.listChanged) {
+      this._setupListChangedHandler("resources", ResourceListChangedNotificationSchema, config2.resources, async () => {
+        const result = await this.listResources();
+        return result.resources;
+      });
+    }
+  }
+  /**
+   * Access experimental features.
+   *
+   * WARNING: These APIs are experimental and may change without notice.
+   *
+   * @experimental
+   */
+  get experimental() {
+    if (!this._experimental) {
+      this._experimental = {
+        tasks: new ExperimentalClientTasks(this)
+      };
+    }
+    return this._experimental;
+  }
+  /**
+   * Registers new capabilities. This can only be called before connecting to a transport.
+   *
+   * The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
+   */
+  registerCapabilities(capabilities) {
+    if (this.transport) {
+      throw new Error("Cannot register capabilities after connecting to transport");
+    }
+    this._capabilities = mergeCapabilities(this._capabilities, capabilities);
+  }
+  /**
+   * Override request handler registration to enforce client-side validation for elicitation.
+   */
+  setRequestHandler(requestSchema, handler) {
+    const shape = getObjectShape(requestSchema);
+    const methodSchema = shape?.method;
+    if (!methodSchema) {
+      throw new Error("Schema is missing a method literal");
+    }
+    let methodValue;
+    if (isZ4Schema(methodSchema)) {
+      const v4Schema = methodSchema;
+      const v4Def = v4Schema._zod?.def;
+      methodValue = v4Def?.value ?? v4Schema.value;
+    } else {
+      const v3Schema = methodSchema;
+      const legacyDef = v3Schema._def;
+      methodValue = legacyDef?.value ?? v3Schema.value;
+    }
+    if (typeof methodValue !== "string") {
+      throw new Error("Schema method literal must be a string");
+    }
+    const method = methodValue;
+    if (method === "elicitation/create") {
+      const wrappedHandler = async (request2, extra) => {
+        const validatedRequest = safeParse2(ElicitRequestSchema, request2);
+        if (!validatedRequest.success) {
+          const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation request: ${errorMessage}`);
+        }
+        const { params } = validatedRequest.data;
+        params.mode = params.mode ?? "form";
+        const { supportsFormMode, supportsUrlMode } = getSupportedElicitationModes(this._capabilities.elicitation);
+        if (params.mode === "form" && !supportsFormMode) {
+          throw new McpError(ErrorCode.InvalidParams, "Client does not support form-mode elicitation requests");
+        }
+        if (params.mode === "url" && !supportsUrlMode) {
+          throw new McpError(ErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests");
+        }
+        const result = await Promise.resolve(handler(request2, extra));
+        if (params.task) {
+          const taskValidationResult = safeParse2(CreateTaskResultSchema, result);
+          if (!taskValidationResult.success) {
+            const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+          }
+          return taskValidationResult.data;
+        }
+        const validationResult = safeParse2(ElicitResultSchema, result);
+        if (!validationResult.success) {
+          const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation result: ${errorMessage}`);
+        }
+        const validatedResult = validationResult.data;
+        const requestedSchema = params.mode === "form" ? params.requestedSchema : void 0;
+        if (params.mode === "form" && validatedResult.action === "accept" && validatedResult.content && requestedSchema) {
+          if (this._capabilities.elicitation?.form?.applyDefaults) {
+            try {
+              applyElicitationDefaults(requestedSchema, validatedResult.content);
+            } catch {
+            }
+          }
+        }
+        return validatedResult;
+      };
+      return super.setRequestHandler(requestSchema, wrappedHandler);
+    }
+    if (method === "sampling/createMessage") {
+      const wrappedHandler = async (request2, extra) => {
+        const validatedRequest = safeParse2(CreateMessageRequestSchema, request2);
+        if (!validatedRequest.success) {
+          const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid sampling request: ${errorMessage}`);
+        }
+        const { params } = validatedRequest.data;
+        const result = await Promise.resolve(handler(request2, extra));
+        if (params.task) {
+          const taskValidationResult = safeParse2(CreateTaskResultSchema, result);
+          if (!taskValidationResult.success) {
+            const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+          }
+          return taskValidationResult.data;
+        }
+        const hasTools = params.tools || params.toolChoice;
+        const resultSchema = hasTools ? CreateMessageResultWithToolsSchema : CreateMessageResultSchema;
+        const validationResult = safeParse2(resultSchema, result);
+        if (!validationResult.success) {
+          const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid sampling result: ${errorMessage}`);
+        }
+        return validationResult.data;
+      };
+      return super.setRequestHandler(requestSchema, wrappedHandler);
+    }
+    return super.setRequestHandler(requestSchema, handler);
+  }
+  assertCapability(capability, method) {
+    if (!this._serverCapabilities?.[capability]) {
+      throw new Error(`Server does not support ${capability} (required for ${method})`);
+    }
+  }
+  async connect(transport, options) {
+    await super.connect(transport);
+    if (transport.sessionId !== void 0) {
+      return;
+    }
+    try {
+      const result = await this.request({
+        method: "initialize",
+        params: {
+          protocolVersion: LATEST_PROTOCOL_VERSION,
+          capabilities: this._capabilities,
+          clientInfo: this._clientInfo
+        }
+      }, InitializeResultSchema, options);
+      if (result === void 0) {
+        throw new Error(`Server sent invalid initialize result: ${result}`);
+      }
+      if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) {
+        throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`);
+      }
+      this._serverCapabilities = result.capabilities;
+      this._serverVersion = result.serverInfo;
+      if (transport.setProtocolVersion) {
+        transport.setProtocolVersion(result.protocolVersion);
+      }
+      this._instructions = result.instructions;
+      await this.notification({
+        method: "notifications/initialized"
+      });
+      if (this._pendingListChangedConfig) {
+        this._setupListChangedHandlers(this._pendingListChangedConfig);
+        this._pendingListChangedConfig = void 0;
+      }
+    } catch (error2) {
+      void this.close();
+      throw error2;
+    }
+  }
+  /**
+   * After initialization has completed, this will be populated with the server's reported capabilities.
+   */
+  getServerCapabilities() {
+    return this._serverCapabilities;
+  }
+  /**
+   * After initialization has completed, this will be populated with information about the server's name and version.
+   */
+  getServerVersion() {
+    return this._serverVersion;
+  }
+  /**
+   * After initialization has completed, this may be populated with information about the server's instructions.
+   */
+  getInstructions() {
+    return this._instructions;
+  }
+  assertCapabilityForMethod(method) {
+    switch (method) {
+      case "logging/setLevel":
+        if (!this._serverCapabilities?.logging) {
+          throw new Error(`Server does not support logging (required for ${method})`);
+        }
+        break;
+      case "prompts/get":
+      case "prompts/list":
+        if (!this._serverCapabilities?.prompts) {
+          throw new Error(`Server does not support prompts (required for ${method})`);
+        }
+        break;
+      case "resources/list":
+      case "resources/templates/list":
+      case "resources/read":
+      case "resources/subscribe":
+      case "resources/unsubscribe":
+        if (!this._serverCapabilities?.resources) {
+          throw new Error(`Server does not support resources (required for ${method})`);
+        }
+        if (method === "resources/subscribe" && !this._serverCapabilities.resources.subscribe) {
+          throw new Error(`Server does not support resource subscriptions (required for ${method})`);
+        }
+        break;
+      case "tools/call":
+      case "tools/list":
+        if (!this._serverCapabilities?.tools) {
+          throw new Error(`Server does not support tools (required for ${method})`);
+        }
+        break;
+      case "completion/complete":
+        if (!this._serverCapabilities?.completions) {
+          throw new Error(`Server does not support completions (required for ${method})`);
+        }
+        break;
+      case "initialize":
+        break;
+      case "ping":
+        break;
+    }
+  }
+  assertNotificationCapability(method) {
+    switch (method) {
+      case "notifications/roots/list_changed":
+        if (!this._capabilities.roots?.listChanged) {
+          throw new Error(`Client does not support roots list changed notifications (required for ${method})`);
+        }
+        break;
+      case "notifications/initialized":
+        break;
+      case "notifications/cancelled":
+        break;
+      case "notifications/progress":
+        break;
+    }
+  }
+  assertRequestHandlerCapability(method) {
+    if (!this._capabilities) {
+      return;
+    }
+    switch (method) {
+      case "sampling/createMessage":
+        if (!this._capabilities.sampling) {
+          throw new Error(`Client does not support sampling capability (required for ${method})`);
+        }
+        break;
+      case "elicitation/create":
+        if (!this._capabilities.elicitation) {
+          throw new Error(`Client does not support elicitation capability (required for ${method})`);
+        }
+        break;
+      case "roots/list":
+        if (!this._capabilities.roots) {
+          throw new Error(`Client does not support roots capability (required for ${method})`);
+        }
+        break;
+      case "tasks/get":
+      case "tasks/list":
+      case "tasks/result":
+      case "tasks/cancel":
+        if (!this._capabilities.tasks) {
+          throw new Error(`Client does not support tasks capability (required for ${method})`);
+        }
+        break;
+      case "ping":
+        break;
+    }
+  }
+  assertTaskCapability(method) {
+    assertToolsCallTaskCapability(this._serverCapabilities?.tasks?.requests, method, "Server");
+  }
+  assertTaskHandlerCapability(method) {
+    if (!this._capabilities) {
+      return;
+    }
+    assertClientRequestTaskCapability(this._capabilities.tasks?.requests, method, "Client");
+  }
+  async ping(options) {
+    return this.request({ method: "ping" }, EmptyResultSchema, options);
+  }
+  async complete(params, options) {
+    return this.request({ method: "completion/complete", params }, CompleteResultSchema, options);
+  }
+  async setLoggingLevel(level, options) {
+    return this.request({ method: "logging/setLevel", params: { level } }, EmptyResultSchema, options);
+  }
+  async getPrompt(params, options) {
+    return this.request({ method: "prompts/get", params }, GetPromptResultSchema, options);
+  }
+  async listPrompts(params, options) {
+    return this.request({ method: "prompts/list", params }, ListPromptsResultSchema, options);
+  }
+  async listResources(params, options) {
+    return this.request({ method: "resources/list", params }, ListResourcesResultSchema, options);
+  }
+  async listResourceTemplates(params, options) {
+    return this.request({ method: "resources/templates/list", params }, ListResourceTemplatesResultSchema, options);
+  }
+  async readResource(params, options) {
+    return this.request({ method: "resources/read", params }, ReadResourceResultSchema, options);
+  }
+  async subscribeResource(params, options) {
+    return this.request({ method: "resources/subscribe", params }, EmptyResultSchema, options);
+  }
+  async unsubscribeResource(params, options) {
+    return this.request({ method: "resources/unsubscribe", params }, EmptyResultSchema, options);
+  }
+  /**
+   * Calls a tool and waits for the result. Automatically validates structured output if the tool has an outputSchema.
+   *
+   * For task-based execution with streaming behavior, use client.experimental.tasks.callToolStream() instead.
+   */
+  async callTool(params, resultSchema = CallToolResultSchema, options) {
+    if (this.isToolTaskRequired(params.name)) {
+      throw new McpError(ErrorCode.InvalidRequest, `Tool "${params.name}" requires task-based execution. Use client.experimental.tasks.callToolStream() instead.`);
+    }
+    const result = await this.request({ method: "tools/call", params }, resultSchema, options);
+    const validator = this.getToolOutputValidator(params.name);
+    if (validator) {
+      if (!result.structuredContent && !result.isError) {
+        throw new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`);
+      }
+      if (result.structuredContent) {
+        try {
+          const validationResult = validator(result.structuredContent);
+          if (!validationResult.valid) {
+            throw new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`);
+          }
+        } catch (error2) {
+          if (error2 instanceof McpError) {
+            throw error2;
+          }
+          throw new McpError(ErrorCode.InvalidParams, `Failed to validate structured content: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        }
+      }
+    }
+    return result;
+  }
+  isToolTask(toolName) {
+    if (!this._serverCapabilities?.tasks?.requests?.tools?.call) {
+      return false;
+    }
+    return this._cachedKnownTaskTools.has(toolName);
+  }
+  /**
+   * Check if a tool requires task-based execution.
+   * Unlike isToolTask which includes 'optional' tools, this only checks for 'required'.
+   */
+  isToolTaskRequired(toolName) {
+    return this._cachedRequiredTaskTools.has(toolName);
+  }
+  /**
+   * Cache validators for tool output schemas.
+   * Called after listTools() to pre-compile validators for better performance.
+   */
+  cacheToolMetadata(tools) {
+    this._cachedToolOutputValidators.clear();
+    this._cachedKnownTaskTools.clear();
+    this._cachedRequiredTaskTools.clear();
+    for (const tool of tools) {
+      if (tool.outputSchema) {
+        const toolValidator = this._jsonSchemaValidator.getValidator(tool.outputSchema);
+        this._cachedToolOutputValidators.set(tool.name, toolValidator);
+      }
+      const taskSupport = tool.execution?.taskSupport;
+      if (taskSupport === "required" || taskSupport === "optional") {
+        this._cachedKnownTaskTools.add(tool.name);
+      }
+      if (taskSupport === "required") {
+        this._cachedRequiredTaskTools.add(tool.name);
+      }
+    }
+  }
+  /**
+   * Get cached validator for a tool
+   */
+  getToolOutputValidator(toolName) {
+    return this._cachedToolOutputValidators.get(toolName);
+  }
+  async listTools(params, options) {
+    const result = await this.request({ method: "tools/list", params }, ListToolsResultSchema, options);
+    this.cacheToolMetadata(result.tools);
+    return result;
+  }
+  /**
+   * Set up a single list changed handler.
+   * @internal
+   */
+  _setupListChangedHandler(listType, notificationSchema, options, fetcher) {
+    const parseResult = ListChangedOptionsBaseSchema.safeParse(options);
+    if (!parseResult.success) {
+      throw new Error(`Invalid ${listType} listChanged options: ${parseResult.error.message}`);
+    }
+    if (typeof options.onChanged !== "function") {
+      throw new Error(`Invalid ${listType} listChanged options: onChanged must be a function`);
+    }
+    const { autoRefresh, debounceMs } = parseResult.data;
+    const { onChanged } = options;
+    const refresh = async () => {
+      if (!autoRefresh) {
+        onChanged(null, null);
+        return;
+      }
+      try {
+        const items = await fetcher();
+        onChanged(null, items);
+      } catch (e) {
+        const error2 = e instanceof Error ? e : new Error(String(e));
+        onChanged(error2, null);
+      }
+    };
+    const handler = () => {
+      if (debounceMs) {
+        const existingTimer = this._listChangedDebounceTimers.get(listType);
+        if (existingTimer) {
+          clearTimeout(existingTimer);
+        }
+        const timer = setTimeout(refresh, debounceMs);
+        this._listChangedDebounceTimers.set(listType, timer);
+      } else {
+        refresh();
+      }
+    };
+    this.setNotificationHandler(notificationSchema, handler);
+  }
+  async sendRootsListChanged() {
+    return this.notification({ method: "notifications/roots/list_changed" });
+  }
+};
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.28.0_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/transport.js
+function normalizeHeaders(headers) {
+  if (!headers)
+    return {};
+  if (headers instanceof Headers) {
+    return Object.fromEntries(headers.entries());
+  }
+  if (Array.isArray(headers)) {
+    return Object.fromEntries(headers);
+  }
+  return { ...headers };
+}
+function createFetchWithInit(baseFetch = fetch, baseInit) {
+  if (!baseInit) {
+    return baseFetch;
+  }
+  return async (url2, init) => {
+    const mergedInit = {
+      ...baseInit,
+      ...init,
+      // Headers need special handling - merge instead of replace
+      headers: init?.headers ? { ...normalizeHeaders(baseInit.headers), ...normalizeHeaders(init.headers) } : baseInit.headers
+    };
+    return baseFetch(url2, mergedInit);
+  };
+}
+
+// ../../node_modules/.pnpm/pkce-challenge@5.0.1/node_modules/pkce-challenge/dist/index.node.js
+var crypto3;
+crypto3 = globalThis.crypto?.webcrypto ?? // Node.js [18-16] REPL
+globalThis.crypto ?? // Node.js >18
+import("node:crypto").then((m) => m.webcrypto);
+async function getRandomValues(size) {
+  return (await crypto3).getRandomValues(new Uint8Array(size));
+}
+async function random(size) {
+  const mask = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
+  const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % mask.length;
+  let result = "";
+  while (result.length < size) {
+    const randomBytes = await getRandomValues(size - result.length);
+    for (const randomByte of randomBytes) {
+      if (randomByte < evenDistCutoff) {
+        result += mask[randomByte % mask.length];
+      }
+    }
+  }
+  return result;
+}
+async function generateVerifier(length) {
+  return await random(length);
+}
+async function generateChallenge(code_verifier) {
+  const buffer = await (await crypto3).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
+  return btoa(String.fromCharCode(...new Uint8Array(buffer))).replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, "");
+}
+async function pkceChallenge(length) {
+  if (!length)
+    length = 43;
+  if (length < 43 || length > 128) {
+    throw `Expected a length between 43 and 128. Received ${length}.`;
+  }
+  const verifier = await generateVerifier(length);
+  const challenge = await generateChallenge(verifier);
+  return {
+    code_verifier: verifier,
+    code_challenge: challenge
+  };
+}
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.28.0_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js
+var SafeUrlSchema = url().superRefine((val, ctx) => {
+  if (!URL.canParse(val)) {
+    ctx.addIssue({
+      code: ZodIssueCode2.custom,
+      message: "URL must be parseable",
+      fatal: true
+    });
+    return NEVER2;
+  }
+}).refine((url2) => {
+  const u = new URL(url2);
+  return u.protocol !== "javascript:" && u.protocol !== "data:" && u.protocol !== "vbscript:";
+}, { message: "URL cannot use javascript:, data:, or vbscript: scheme" });
+var OAuthProtectedResourceMetadataSchema = looseObject({
+  resource: string2().url(),
+  authorization_servers: array(SafeUrlSchema).optional(),
+  jwks_uri: string2().url().optional(),
+  scopes_supported: array(string2()).optional(),
+  bearer_methods_supported: array(string2()).optional(),
+  resource_signing_alg_values_supported: array(string2()).optional(),
+  resource_name: string2().optional(),
+  resource_documentation: string2().optional(),
+  resource_policy_uri: string2().url().optional(),
+  resource_tos_uri: string2().url().optional(),
+  tls_client_certificate_bound_access_tokens: boolean2().optional(),
+  authorization_details_types_supported: array(string2()).optional(),
+  dpop_signing_alg_values_supported: array(string2()).optional(),
+  dpop_bound_access_tokens_required: boolean2().optional()
+});
+var OAuthMetadataSchema = looseObject({
+  issuer: string2(),
+  authorization_endpoint: SafeUrlSchema,
+  token_endpoint: SafeUrlSchema,
+  registration_endpoint: SafeUrlSchema.optional(),
+  scopes_supported: array(string2()).optional(),
+  response_types_supported: array(string2()),
+  response_modes_supported: array(string2()).optional(),
+  grant_types_supported: array(string2()).optional(),
+  token_endpoint_auth_methods_supported: array(string2()).optional(),
+  token_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  service_documentation: SafeUrlSchema.optional(),
+  revocation_endpoint: SafeUrlSchema.optional(),
+  revocation_endpoint_auth_methods_supported: array(string2()).optional(),
+  revocation_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  introspection_endpoint: string2().optional(),
+  introspection_endpoint_auth_methods_supported: array(string2()).optional(),
+  introspection_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  code_challenge_methods_supported: array(string2()).optional(),
+  client_id_metadata_document_supported: boolean2().optional()
+});
+var OpenIdProviderMetadataSchema = looseObject({
+  issuer: string2(),
+  authorization_endpoint: SafeUrlSchema,
+  token_endpoint: SafeUrlSchema,
+  userinfo_endpoint: SafeUrlSchema.optional(),
+  jwks_uri: SafeUrlSchema,
+  registration_endpoint: SafeUrlSchema.optional(),
+  scopes_supported: array(string2()).optional(),
+  response_types_supported: array(string2()),
+  response_modes_supported: array(string2()).optional(),
+  grant_types_supported: array(string2()).optional(),
+  acr_values_supported: array(string2()).optional(),
+  subject_types_supported: array(string2()),
+  id_token_signing_alg_values_supported: array(string2()),
+  id_token_encryption_alg_values_supported: array(string2()).optional(),
+  id_token_encryption_enc_values_supported: array(string2()).optional(),
+  userinfo_signing_alg_values_supported: array(string2()).optional(),
+  userinfo_encryption_alg_values_supported: array(string2()).optional(),
+  userinfo_encryption_enc_values_supported: array(string2()).optional(),
+  request_object_signing_alg_values_supported: array(string2()).optional(),
+  request_object_encryption_alg_values_supported: array(string2()).optional(),
+  request_object_encryption_enc_values_supported: array(string2()).optional(),
+  token_endpoint_auth_methods_supported: array(string2()).optional(),
+  token_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  display_values_supported: array(string2()).optional(),
+  claim_types_supported: array(string2()).optional(),
+  claims_supported: array(string2()).optional(),
+  service_documentation: string2().optional(),
+  claims_locales_supported: array(string2()).optional(),
+  ui_locales_supported: array(string2()).optional(),
+  claims_parameter_supported: boolean2().optional(),
+  request_parameter_supported: boolean2().optional(),
+  request_uri_parameter_supported: boolean2().optional(),
+  require_request_uri_registration: boolean2().optional(),
+  op_policy_uri: SafeUrlSchema.optional(),
+  op_tos_uri: SafeUrlSchema.optional(),
+  client_id_metadata_document_supported: boolean2().optional()
+});
+var OpenIdProviderDiscoveryMetadataSchema = object2({
+  ...OpenIdProviderMetadataSchema.shape,
+  ...OAuthMetadataSchema.pick({
+    code_challenge_methods_supported: true
+  }).shape
+});
+var OAuthTokensSchema = object2({
+  access_token: string2(),
+  id_token: string2().optional(),
+  // Optional for OAuth 2.1, but necessary in OpenID Connect
+  token_type: string2(),
+  expires_in: coerce_exports2.number().optional(),
+  scope: string2().optional(),
+  refresh_token: string2().optional()
+}).strip();
+var OAuthErrorResponseSchema = object2({
+  error: string2(),
+  error_description: string2().optional(),
+  error_uri: string2().optional()
+});
+var OptionalSafeUrlSchema = SafeUrlSchema.optional().or(literal("").transform(() => void 0));
+var OAuthClientMetadataSchema = object2({
+  redirect_uris: array(SafeUrlSchema),
+  token_endpoint_auth_method: string2().optional(),
+  grant_types: array(string2()).optional(),
+  response_types: array(string2()).optional(),
+  client_name: string2().optional(),
+  client_uri: SafeUrlSchema.optional(),
+  logo_uri: OptionalSafeUrlSchema,
+  scope: string2().optional(),
+  contacts: array(string2()).optional(),
+  tos_uri: OptionalSafeUrlSchema,
+  policy_uri: string2().optional(),
+  jwks_uri: SafeUrlSchema.optional(),
+  jwks: any().optional(),
+  software_id: string2().optional(),
+  software_version: string2().optional(),
+  software_statement: string2().optional()
+}).strip();
+var OAuthClientInformationSchema = object2({
+  client_id: string2(),
+  client_secret: string2().optional(),
+  client_id_issued_at: number2().optional(),
+  client_secret_expires_at: number2().optional()
+}).strip();
+var OAuthClientInformationFullSchema = OAuthClientMetadataSchema.merge(OAuthClientInformationSchema);
+var OAuthClientRegistrationErrorSchema = object2({
+  error: string2(),
+  error_description: string2().optional()
+}).strip();
+var OAuthTokenRevocationRequestSchema = object2({
+  token: string2(),
+  token_type_hint: string2().optional()
+}).strip();
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.28.0_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth-utils.js
+function resourceUrlFromServerUrl(url2) {
+  const resourceURL = typeof url2 === "string" ? new URL(url2) : new URL(url2.href);
+  resourceURL.hash = "";
+  return resourceURL;
+}
+function checkResourceAllowed({ requestedResource, configuredResource }) {
+  const requested = typeof requestedResource === "string" ? new URL(requestedResource) : new URL(requestedResource.href);
+  const configured = typeof configuredResource === "string" ? new URL(configuredResource) : new URL(configuredResource.href);
+  if (requested.origin !== configured.origin) {
+    return false;
+  }
+  if (requested.pathname.length < configured.pathname.length) {
+    return false;
+  }
+  const requestedPath = requested.pathname.endsWith("/") ? requested.pathname : requested.pathname + "/";
+  const configuredPath = configured.pathname.endsWith("/") ? configured.pathname : configured.pathname + "/";
+  return requestedPath.startsWith(configuredPath);
+}
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.28.0_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/auth/errors.js
+var OAuthError = class extends Error {
+  constructor(message, errorUri) {
+    super(message);
+    this.errorUri = errorUri;
+    this.name = this.constructor.name;
+  }
+  /**
+   * Converts the error to a standard OAuth error response object
+   */
+  toResponseObject() {
+    const response = {
+      error: this.errorCode,
+      error_description: this.message
+    };
+    if (this.errorUri) {
+      response.error_uri = this.errorUri;
+    }
+    return response;
+  }
+  get errorCode() {
+    return this.constructor.errorCode;
+  }
+};
+var InvalidRequestError = class extends OAuthError {
+};
+InvalidRequestError.errorCode = "invalid_request";
+var InvalidClientError = class extends OAuthError {
+};
+InvalidClientError.errorCode = "invalid_client";
+var InvalidGrantError = class extends OAuthError {
+};
+InvalidGrantError.errorCode = "invalid_grant";
+var UnauthorizedClientError = class extends OAuthError {
+};
+UnauthorizedClientError.errorCode = "unauthorized_client";
+var UnsupportedGrantTypeError = class extends OAuthError {
+};
+UnsupportedGrantTypeError.errorCode = "unsupported_grant_type";
+var InvalidScopeError = class extends OAuthError {
+};
+InvalidScopeError.errorCode = "invalid_scope";
+var AccessDeniedError = class extends OAuthError {
+};
+AccessDeniedError.errorCode = "access_denied";
+var ServerError = class extends OAuthError {
+};
+ServerError.errorCode = "server_error";
+var TemporarilyUnavailableError = class extends OAuthError {
+};
+TemporarilyUnavailableError.errorCode = "temporarily_unavailable";
+var UnsupportedResponseTypeError = class extends OAuthError {
+};
+UnsupportedResponseTypeError.errorCode = "unsupported_response_type";
+var UnsupportedTokenTypeError = class extends OAuthError {
+};
+UnsupportedTokenTypeError.errorCode = "unsupported_token_type";
+var InvalidTokenError = class extends OAuthError {
+};
+InvalidTokenError.errorCode = "invalid_token";
+var MethodNotAllowedError = class extends OAuthError {
+};
+MethodNotAllowedError.errorCode = "method_not_allowed";
+var TooManyRequestsError = class extends OAuthError {
+};
+TooManyRequestsError.errorCode = "too_many_requests";
+var InvalidClientMetadataError = class extends OAuthError {
+};
+InvalidClientMetadataError.errorCode = "invalid_client_metadata";
+var InsufficientScopeError = class extends OAuthError {
+};
+InsufficientScopeError.errorCode = "insufficient_scope";
+var InvalidTargetError = class extends OAuthError {
+};
+InvalidTargetError.errorCode = "invalid_target";
+var OAUTH_ERRORS = {
+  [InvalidRequestError.errorCode]: InvalidRequestError,
+  [InvalidClientError.errorCode]: InvalidClientError,
+  [InvalidGrantError.errorCode]: InvalidGrantError,
+  [UnauthorizedClientError.errorCode]: UnauthorizedClientError,
+  [UnsupportedGrantTypeError.errorCode]: UnsupportedGrantTypeError,
+  [InvalidScopeError.errorCode]: InvalidScopeError,
+  [AccessDeniedError.errorCode]: AccessDeniedError,
+  [ServerError.errorCode]: ServerError,
+  [TemporarilyUnavailableError.errorCode]: TemporarilyUnavailableError,
+  [UnsupportedResponseTypeError.errorCode]: UnsupportedResponseTypeError,
+  [UnsupportedTokenTypeError.errorCode]: UnsupportedTokenTypeError,
+  [InvalidTokenError.errorCode]: InvalidTokenError,
+  [MethodNotAllowedError.errorCode]: MethodNotAllowedError,
+  [TooManyRequestsError.errorCode]: TooManyRequestsError,
+  [InvalidClientMetadataError.errorCode]: InvalidClientMetadataError,
+  [InsufficientScopeError.errorCode]: InsufficientScopeError,
+  [InvalidTargetError.errorCode]: InvalidTargetError
+};
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.28.0_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/client/auth.js
+var UnauthorizedError = class extends Error {
+  constructor(message) {
+    super(message ?? "Unauthorized");
+  }
+};
+function isClientAuthMethod(method) {
+  return ["client_secret_basic", "client_secret_post", "none"].includes(method);
+}
+var AUTHORIZATION_CODE_RESPONSE_TYPE = "code";
+var AUTHORIZATION_CODE_CHALLENGE_METHOD = "S256";
+function selectClientAuthMethod(clientInformation, supportedMethods) {
+  const hasClientSecret = clientInformation.client_secret !== void 0;
+  if ("token_endpoint_auth_method" in clientInformation && clientInformation.token_endpoint_auth_method && isClientAuthMethod(clientInformation.token_endpoint_auth_method) && (supportedMethods.length === 0 || supportedMethods.includes(clientInformation.token_endpoint_auth_method))) {
+    return clientInformation.token_endpoint_auth_method;
+  }
+  if (supportedMethods.length === 0) {
+    return hasClientSecret ? "client_secret_basic" : "none";
+  }
+  if (hasClientSecret && supportedMethods.includes("client_secret_basic")) {
+    return "client_secret_basic";
+  }
+  if (hasClientSecret && supportedMethods.includes("client_secret_post")) {
+    return "client_secret_post";
+  }
+  if (supportedMethods.includes("none")) {
+    return "none";
+  }
+  return hasClientSecret ? "client_secret_post" : "none";
+}
+function applyClientAuthentication(method, clientInformation, headers, params) {
+  const { client_id, client_secret } = clientInformation;
+  switch (method) {
+    case "client_secret_basic":
+      applyBasicAuth(client_id, client_secret, headers);
+      return;
+    case "client_secret_post":
+      applyPostAuth(client_id, client_secret, params);
+      return;
+    case "none":
+      applyPublicAuth(client_id, params);
+      return;
+    default:
+      throw new Error(`Unsupported client authentication method: ${method}`);
+  }
+}
+function applyBasicAuth(clientId, clientSecret, headers) {
+  if (!clientSecret) {
+    throw new Error("client_secret_basic authentication requires a client_secret");
+  }
+  const credentials = btoa(`${clientId}:${clientSecret}`);
+  headers.set("Authorization", `Basic ${credentials}`);
+}
+function applyPostAuth(clientId, clientSecret, params) {
+  params.set("client_id", clientId);
+  if (clientSecret) {
+    params.set("client_secret", clientSecret);
+  }
+}
+function applyPublicAuth(clientId, params) {
+  params.set("client_id", clientId);
+}
+async function parseErrorResponse(input) {
+  const statusCode = input instanceof Response ? input.status : void 0;
+  const body = input instanceof Response ? await input.text() : input;
+  try {
+    const result = OAuthErrorResponseSchema.parse(JSON.parse(body));
+    const { error: error2, error_description, error_uri } = result;
+    const errorClass = OAUTH_ERRORS[error2] || ServerError;
+    return new errorClass(error_description || "", error_uri);
+  } catch (error2) {
+    const errorMessage = `${statusCode ? `HTTP ${statusCode}: ` : ""}Invalid OAuth error response: ${error2}. Raw body: ${body}`;
+    return new ServerError(errorMessage);
+  }
+}
+async function auth(provider, options) {
+  try {
+    return await authInternal(provider, options);
+  } catch (error2) {
+    if (error2 instanceof InvalidClientError || error2 instanceof UnauthorizedClientError) {
+      await provider.invalidateCredentials?.("all");
+      return await authInternal(provider, options);
+    } else if (error2 instanceof InvalidGrantError) {
+      await provider.invalidateCredentials?.("tokens");
+      return await authInternal(provider, options);
+    }
+    throw error2;
+  }
+}
+async function authInternal(provider, { serverUrl, authorizationCode, scope, resourceMetadataUrl, fetchFn }) {
+  const cachedState = await provider.discoveryState?.();
+  let resourceMetadata;
+  let authorizationServerUrl;
+  let metadata;
+  let effectiveResourceMetadataUrl = resourceMetadataUrl;
+  if (!effectiveResourceMetadataUrl && cachedState?.resourceMetadataUrl) {
+    effectiveResourceMetadataUrl = new URL(cachedState.resourceMetadataUrl);
+  }
+  if (cachedState?.authorizationServerUrl) {
+    authorizationServerUrl = cachedState.authorizationServerUrl;
+    resourceMetadata = cachedState.resourceMetadata;
+    metadata = cachedState.authorizationServerMetadata ?? await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn });
+    if (!resourceMetadata) {
+      try {
+        resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl }, fetchFn);
+      } catch {
+      }
+    }
+    if (metadata !== cachedState.authorizationServerMetadata || resourceMetadata !== cachedState.resourceMetadata) {
+      await provider.saveDiscoveryState?.({
+        authorizationServerUrl: String(authorizationServerUrl),
+        resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
+        resourceMetadata,
+        authorizationServerMetadata: metadata
+      });
+    }
+  } else {
+    const serverInfo = await discoverOAuthServerInfo(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl, fetchFn });
+    authorizationServerUrl = serverInfo.authorizationServerUrl;
+    metadata = serverInfo.authorizationServerMetadata;
+    resourceMetadata = serverInfo.resourceMetadata;
+    await provider.saveDiscoveryState?.({
+      authorizationServerUrl: String(authorizationServerUrl),
+      resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
+      resourceMetadata,
+      authorizationServerMetadata: metadata
+    });
+  }
+  const resource = await selectResourceURL(serverUrl, provider, resourceMetadata);
+  const resolvedScope = scope || resourceMetadata?.scopes_supported?.join(" ") || provider.clientMetadata.scope;
+  let clientInformation = await Promise.resolve(provider.clientInformation());
+  if (!clientInformation) {
+    if (authorizationCode !== void 0) {
+      throw new Error("Existing OAuth client information is required when exchanging an authorization code");
+    }
+    const supportsUrlBasedClientId = metadata?.client_id_metadata_document_supported === true;
+    const clientMetadataUrl = provider.clientMetadataUrl;
+    if (clientMetadataUrl && !isHttpsUrl(clientMetadataUrl)) {
+      throw new InvalidClientMetadataError(`clientMetadataUrl must be a valid HTTPS URL with a non-root pathname, got: ${clientMetadataUrl}`);
+    }
+    const shouldUseUrlBasedClientId = supportsUrlBasedClientId && clientMetadataUrl;
+    if (shouldUseUrlBasedClientId) {
+      clientInformation = {
+        client_id: clientMetadataUrl
+      };
+      await provider.saveClientInformation?.(clientInformation);
+    } else {
+      if (!provider.saveClientInformation) {
+        throw new Error("OAuth client information must be saveable for dynamic registration");
+      }
+      const fullInformation = await registerClient(authorizationServerUrl, {
+        metadata,
+        clientMetadata: provider.clientMetadata,
+        scope: resolvedScope,
+        fetchFn
+      });
+      await provider.saveClientInformation(fullInformation);
+      clientInformation = fullInformation;
+    }
+  }
+  const nonInteractiveFlow = !provider.redirectUrl;
+  if (authorizationCode !== void 0 || nonInteractiveFlow) {
+    const tokens2 = await fetchToken(provider, authorizationServerUrl, {
+      metadata,
+      resource,
+      authorizationCode,
+      fetchFn
+    });
+    await provider.saveTokens(tokens2);
+    return "AUTHORIZED";
+  }
+  const tokens = await provider.tokens();
+  if (tokens?.refresh_token) {
+    try {
+      const newTokens = await refreshAuthorization(authorizationServerUrl, {
+        metadata,
+        clientInformation,
+        refreshToken: tokens.refresh_token,
+        resource,
+        addClientAuthentication: provider.addClientAuthentication,
+        fetchFn
+      });
+      await provider.saveTokens(newTokens);
+      return "AUTHORIZED";
+    } catch (error2) {
+      if (!(error2 instanceof OAuthError) || error2 instanceof ServerError) {
+      } else {
+        throw error2;
+      }
+    }
+  }
+  const state = provider.state ? await provider.state() : void 0;
+  const { authorizationUrl, codeVerifier } = await startAuthorization(authorizationServerUrl, {
+    metadata,
+    clientInformation,
+    state,
+    redirectUrl: provider.redirectUrl,
+    scope: resolvedScope,
+    resource
+  });
+  await provider.saveCodeVerifier(codeVerifier);
+  await provider.redirectToAuthorization(authorizationUrl);
+  return "REDIRECT";
+}
+function isHttpsUrl(value) {
+  if (!value)
+    return false;
+  try {
+    const url2 = new URL(value);
+    return url2.protocol === "https:" && url2.pathname !== "/";
+  } catch {
+    return false;
+  }
+}
+async function selectResourceURL(serverUrl, provider, resourceMetadata) {
+  const defaultResource = resourceUrlFromServerUrl(serverUrl);
+  if (provider.validateResourceURL) {
+    return await provider.validateResourceURL(defaultResource, resourceMetadata?.resource);
+  }
+  if (!resourceMetadata) {
+    return void 0;
+  }
+  if (!checkResourceAllowed({ requestedResource: defaultResource, configuredResource: resourceMetadata.resource })) {
+    throw new Error(`Protected resource ${resourceMetadata.resource} does not match expected ${defaultResource} (or origin)`);
+  }
+  return new URL(resourceMetadata.resource);
+}
+function extractWWWAuthenticateParams(res) {
+  const authenticateHeader = res.headers.get("WWW-Authenticate");
+  if (!authenticateHeader) {
+    return {};
+  }
+  const [type, scheme] = authenticateHeader.split(" ");
+  if (type.toLowerCase() !== "bearer" || !scheme) {
+    return {};
+  }
+  const resourceMetadataMatch = extractFieldFromWwwAuth(res, "resource_metadata") || void 0;
+  let resourceMetadataUrl;
+  if (resourceMetadataMatch) {
+    try {
+      resourceMetadataUrl = new URL(resourceMetadataMatch);
+    } catch {
+    }
+  }
+  const scope = extractFieldFromWwwAuth(res, "scope") || void 0;
+  const error2 = extractFieldFromWwwAuth(res, "error") || void 0;
+  return {
+    resourceMetadataUrl,
+    scope,
+    error: error2
+  };
+}
+function extractFieldFromWwwAuth(response, fieldName) {
+  const wwwAuthHeader = response.headers.get("WWW-Authenticate");
+  if (!wwwAuthHeader) {
+    return null;
+  }
+  const pattern = new RegExp(`${fieldName}=(?:"([^"]+)"|([^\\s,]+))`);
+  const match = wwwAuthHeader.match(pattern);
+  if (match) {
+    return match[1] || match[2];
+  }
+  return null;
+}
+async function discoverOAuthProtectedResourceMetadata(serverUrl, opts, fetchFn = fetch) {
+  const response = await discoverMetadataWithFallback(serverUrl, "oauth-protected-resource", fetchFn, {
+    protocolVersion: opts?.protocolVersion,
+    metadataUrl: opts?.resourceMetadataUrl
+  });
+  if (!response || response.status === 404) {
+    await response?.body?.cancel();
+    throw new Error(`Resource server does not implement OAuth 2.0 Protected Resource Metadata.`);
+  }
+  if (!response.ok) {
+    await response.body?.cancel();
+    throw new Error(`HTTP ${response.status} trying to load well-known OAuth protected resource metadata.`);
+  }
+  return OAuthProtectedResourceMetadataSchema.parse(await response.json());
+}
+async function fetchWithCorsRetry(url2, headers, fetchFn = fetch) {
+  try {
+    return await fetchFn(url2, { headers });
+  } catch (error2) {
+    if (error2 instanceof TypeError) {
+      if (headers) {
+        return fetchWithCorsRetry(url2, void 0, fetchFn);
+      } else {
+        return void 0;
+      }
+    }
+    throw error2;
+  }
+}
+function buildWellKnownPath(wellKnownPrefix, pathname = "", options = {}) {
+  if (pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+  return options.prependPathname ? `${pathname}/.well-known/${wellKnownPrefix}` : `/.well-known/${wellKnownPrefix}${pathname}`;
+}
+async function tryMetadataDiscovery(url2, protocolVersion, fetchFn = fetch) {
+  const headers = {
+    "MCP-Protocol-Version": protocolVersion
+  };
+  return await fetchWithCorsRetry(url2, headers, fetchFn);
+}
+function shouldAttemptFallback(response, pathname) {
+  return !response || response.status >= 400 && response.status < 500 && pathname !== "/";
+}
+async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, opts) {
+  const issuer = new URL(serverUrl);
+  const protocolVersion = opts?.protocolVersion ?? LATEST_PROTOCOL_VERSION;
+  let url2;
+  if (opts?.metadataUrl) {
+    url2 = new URL(opts.metadataUrl);
+  } else {
+    const wellKnownPath = buildWellKnownPath(wellKnownType, issuer.pathname);
+    url2 = new URL(wellKnownPath, opts?.metadataServerUrl ?? issuer);
+    url2.search = issuer.search;
+  }
+  let response = await tryMetadataDiscovery(url2, protocolVersion, fetchFn);
+  if (!opts?.metadataUrl && shouldAttemptFallback(response, issuer.pathname)) {
+    const rootUrl = new URL(`/.well-known/${wellKnownType}`, issuer);
+    response = await tryMetadataDiscovery(rootUrl, protocolVersion, fetchFn);
+  }
+  return response;
+}
+function buildDiscoveryUrls(authorizationServerUrl) {
+  const url2 = typeof authorizationServerUrl === "string" ? new URL(authorizationServerUrl) : authorizationServerUrl;
+  const hasPath = url2.pathname !== "/";
+  const urlsToTry = [];
+  if (!hasPath) {
+    urlsToTry.push({
+      url: new URL("/.well-known/oauth-authorization-server", url2.origin),
+      type: "oauth"
+    });
+    urlsToTry.push({
+      url: new URL(`/.well-known/openid-configuration`, url2.origin),
+      type: "oidc"
+    });
+    return urlsToTry;
+  }
+  let pathname = url2.pathname;
+  if (pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+  urlsToTry.push({
+    url: new URL(`/.well-known/oauth-authorization-server${pathname}`, url2.origin),
+    type: "oauth"
+  });
+  urlsToTry.push({
+    url: new URL(`/.well-known/openid-configuration${pathname}`, url2.origin),
+    type: "oidc"
+  });
+  urlsToTry.push({
+    url: new URL(`${pathname}/.well-known/openid-configuration`, url2.origin),
+    type: "oidc"
+  });
+  return urlsToTry;
+}
+async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn = fetch, protocolVersion = LATEST_PROTOCOL_VERSION } = {}) {
+  const headers = {
+    "MCP-Protocol-Version": protocolVersion,
+    Accept: "application/json"
+  };
+  const urlsToTry = buildDiscoveryUrls(authorizationServerUrl);
+  for (const { url: endpointUrl, type } of urlsToTry) {
+    const response = await fetchWithCorsRetry(endpointUrl, headers, fetchFn);
+    if (!response) {
+      continue;
+    }
+    if (!response.ok) {
+      await response.body?.cancel();
+      if (response.status >= 400 && response.status < 500) {
+        continue;
+      }
+      throw new Error(`HTTP ${response.status} trying to load ${type === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${endpointUrl}`);
+    }
+    if (type === "oauth") {
+      return OAuthMetadataSchema.parse(await response.json());
+    } else {
+      return OpenIdProviderDiscoveryMetadataSchema.parse(await response.json());
+    }
+  }
+  return void 0;
+}
+async function discoverOAuthServerInfo(serverUrl, opts) {
+  let resourceMetadata;
+  let authorizationServerUrl;
+  try {
+    resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: opts?.resourceMetadataUrl }, opts?.fetchFn);
+    if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) {
+      authorizationServerUrl = resourceMetadata.authorization_servers[0];
+    }
+  } catch {
+  }
+  if (!authorizationServerUrl) {
+    authorizationServerUrl = String(new URL("/", serverUrl));
+  }
+  const authorizationServerMetadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn: opts?.fetchFn });
+  return {
+    authorizationServerUrl,
+    authorizationServerMetadata,
+    resourceMetadata
+  };
+}
+async function startAuthorization(authorizationServerUrl, { metadata, clientInformation, redirectUrl, scope, state, resource }) {
+  let authorizationUrl;
+  if (metadata) {
+    authorizationUrl = new URL(metadata.authorization_endpoint);
+    if (!metadata.response_types_supported.includes(AUTHORIZATION_CODE_RESPONSE_TYPE)) {
+      throw new Error(`Incompatible auth server: does not support response type ${AUTHORIZATION_CODE_RESPONSE_TYPE}`);
+    }
+    if (metadata.code_challenge_methods_supported && !metadata.code_challenge_methods_supported.includes(AUTHORIZATION_CODE_CHALLENGE_METHOD)) {
+      throw new Error(`Incompatible auth server: does not support code challenge method ${AUTHORIZATION_CODE_CHALLENGE_METHOD}`);
+    }
+  } else {
+    authorizationUrl = new URL("/authorize", authorizationServerUrl);
+  }
+  const challenge = await pkceChallenge();
+  const codeVerifier = challenge.code_verifier;
+  const codeChallenge = challenge.code_challenge;
+  authorizationUrl.searchParams.set("response_type", AUTHORIZATION_CODE_RESPONSE_TYPE);
+  authorizationUrl.searchParams.set("client_id", clientInformation.client_id);
+  authorizationUrl.searchParams.set("code_challenge", codeChallenge);
+  authorizationUrl.searchParams.set("code_challenge_method", AUTHORIZATION_CODE_CHALLENGE_METHOD);
+  authorizationUrl.searchParams.set("redirect_uri", String(redirectUrl));
+  if (state) {
+    authorizationUrl.searchParams.set("state", state);
+  }
+  if (scope) {
+    authorizationUrl.searchParams.set("scope", scope);
+  }
+  if (scope?.includes("offline_access")) {
+    authorizationUrl.searchParams.append("prompt", "consent");
+  }
+  if (resource) {
+    authorizationUrl.searchParams.set("resource", resource.href);
+  }
+  return { authorizationUrl, codeVerifier };
+}
+function prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, redirectUri) {
+  return new URLSearchParams({
+    grant_type: "authorization_code",
+    code: authorizationCode,
+    code_verifier: codeVerifier,
+    redirect_uri: String(redirectUri)
+  });
+}
+async function executeTokenRequest(authorizationServerUrl, { metadata, tokenRequestParams, clientInformation, addClientAuthentication, resource, fetchFn }) {
+  const tokenUrl = metadata?.token_endpoint ? new URL(metadata.token_endpoint) : new URL("/token", authorizationServerUrl);
+  const headers = new Headers({
+    "Content-Type": "application/x-www-form-urlencoded",
+    Accept: "application/json"
+  });
+  if (resource) {
+    tokenRequestParams.set("resource", resource.href);
+  }
+  if (addClientAuthentication) {
+    await addClientAuthentication(headers, tokenRequestParams, tokenUrl, metadata);
+  } else if (clientInformation) {
+    const supportedMethods = metadata?.token_endpoint_auth_methods_supported ?? [];
+    const authMethod = selectClientAuthMethod(clientInformation, supportedMethods);
+    applyClientAuthentication(authMethod, clientInformation, headers, tokenRequestParams);
+  }
+  const response = await (fetchFn ?? fetch)(tokenUrl, {
+    method: "POST",
+    headers,
+    body: tokenRequestParams
+  });
+  if (!response.ok) {
+    throw await parseErrorResponse(response);
+  }
+  return OAuthTokensSchema.parse(await response.json());
+}
+async function refreshAuthorization(authorizationServerUrl, { metadata, clientInformation, refreshToken, resource, addClientAuthentication, fetchFn }) {
+  const tokenRequestParams = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: refreshToken
+  });
+  const tokens = await executeTokenRequest(authorizationServerUrl, {
+    metadata,
+    tokenRequestParams,
+    clientInformation,
+    addClientAuthentication,
+    resource,
+    fetchFn
+  });
+  return { refresh_token: refreshToken, ...tokens };
+}
+async function fetchToken(provider, authorizationServerUrl, { metadata, resource, authorizationCode, fetchFn } = {}) {
+  const scope = provider.clientMetadata.scope;
+  let tokenRequestParams;
+  if (provider.prepareTokenRequest) {
+    tokenRequestParams = await provider.prepareTokenRequest(scope);
+  }
+  if (!tokenRequestParams) {
+    if (!authorizationCode) {
+      throw new Error("Either provider.prepareTokenRequest() or authorizationCode is required");
+    }
+    if (!provider.redirectUrl) {
+      throw new Error("redirectUrl is required for authorization_code flow");
+    }
+    const codeVerifier = await provider.codeVerifier();
+    tokenRequestParams = prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, provider.redirectUrl);
+  }
+  const clientInformation = await provider.clientInformation();
+  return executeTokenRequest(authorizationServerUrl, {
+    metadata,
+    tokenRequestParams,
+    clientInformation: clientInformation ?? void 0,
+    addClientAuthentication: provider.addClientAuthentication,
+    resource,
+    fetchFn
+  });
+}
+async function registerClient(authorizationServerUrl, { metadata, clientMetadata, scope, fetchFn }) {
+  let registrationUrl;
+  if (metadata) {
+    if (!metadata.registration_endpoint) {
+      throw new Error("Incompatible auth server: does not support dynamic client registration");
+    }
+    registrationUrl = new URL(metadata.registration_endpoint);
+  } else {
+    registrationUrl = new URL("/register", authorizationServerUrl);
+  }
+  const response = await (fetchFn ?? fetch)(registrationUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      ...clientMetadata,
+      ...scope !== void 0 ? { scope } : {}
+    })
+  });
+  if (!response.ok) {
+    throw await parseErrorResponse(response);
+  }
+  return OAuthClientInformationFullSchema.parse(await response.json());
+}
+
+// ../../node_modules/.pnpm/eventsource-parser@3.0.6/node_modules/eventsource-parser/dist/index.js
+var ParseError = class extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+};
+function noop(_arg) {
+}
+function createParser(callbacks) {
+  if (typeof callbacks == "function")
+    throw new TypeError(
+      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
+  let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = "";
+  function feed(newChunk) {
+    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
+    for (const line of complete)
+      parseLine(line);
+    incompleteLine = incomplete, isFirstChunk = false;
+  }
+  function parseLine(line) {
+    if (line === "") {
+      dispatchEvent();
+      return;
+    }
+    if (line.startsWith(":")) {
+      onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
+      return;
+    }
+    const fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex !== -1) {
+      const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+      processField(field, value, line);
+      return;
+    }
+    processField(line, "", line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value;
+        break;
+      case "data":
+        data = `${data}${value}
+`;
+        break;
+      case "id":
+        id = value.includes("\0") ? void 0 : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    data.length > 0 && onEvent({
+      id,
+      event: eventType || void 0,
+      // If the data buffer's last character is a U+000A LINE FEED (LF) character,
+      // then remove the last character from the data buffer.
+      data: data.endsWith(`
+`) ? data.slice(0, -1) : data
+    }), id = void 0, data = "", eventType = "";
+  }
+  function reset(options = {}) {
+    incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id = void 0, data = "", eventType = "", incompleteLine = "";
+  }
+  return { feed, reset };
+}
+function splitLines(chunk) {
+  const lines = [];
+  let incompleteLine = "", searchIndex = 0;
+  for (; searchIndex < chunk.length; ) {
+    const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+    let lineEnd = -1;
+    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
+      incompleteLine = chunk.slice(searchIndex);
+      break;
+    } else {
+      const line = chunk.slice(searchIndex, lineEnd);
+      lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
+` && searchIndex++;
+    }
+  }
+  return [lines, incompleteLine];
+}
+
+// ../../node_modules/.pnpm/eventsource-parser@3.0.6/node_modules/eventsource-parser/dist/stream.js
+var EventSourceParserStream = class extends TransformStream {
+  constructor({ onError, onRetry, onComment } = {}) {
+    let parser;
+    super({
+      start(controller) {
+        parser = createParser({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          },
+          onError(error2) {
+            onError === "terminate" ? controller.error(error2) : typeof onError == "function" && onError(error2);
+          },
+          onRetry,
+          onComment
+        });
+      },
+      transform(chunk) {
+        parser.feed(chunk);
+      }
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.28.0_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/client/streamableHttp.js
+var DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS = {
+  initialReconnectionDelay: 1e3,
+  maxReconnectionDelay: 3e4,
+  reconnectionDelayGrowFactor: 1.5,
+  maxRetries: 2
+};
+var StreamableHTTPError = class extends Error {
+  constructor(code, message) {
+    super(`Streamable HTTP error: ${message}`);
+    this.code = code;
+  }
+};
+var StreamableHTTPClientTransport = class {
+  constructor(url2, opts) {
+    this._hasCompletedAuthFlow = false;
+    this._url = url2;
+    this._resourceMetadataUrl = void 0;
+    this._scope = void 0;
+    this._requestInit = opts?.requestInit;
+    this._authProvider = opts?.authProvider;
+    this._fetch = opts?.fetch;
+    this._fetchWithInit = createFetchWithInit(opts?.fetch, opts?.requestInit);
+    this._sessionId = opts?.sessionId;
+    this._reconnectionOptions = opts?.reconnectionOptions ?? DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS;
+  }
+  async _authThenStart() {
+    if (!this._authProvider) {
+      throw new UnauthorizedError("No auth provider");
+    }
+    let result;
+    try {
+      result = await auth(this._authProvider, {
+        serverUrl: this._url,
+        resourceMetadataUrl: this._resourceMetadataUrl,
+        scope: this._scope,
+        fetchFn: this._fetchWithInit
+      });
+    } catch (error2) {
+      this.onerror?.(error2);
+      throw error2;
+    }
+    if (result !== "AUTHORIZED") {
+      throw new UnauthorizedError();
+    }
+    return await this._startOrAuthSse({ resumptionToken: void 0 });
+  }
+  async _commonHeaders() {
+    const headers = {};
+    if (this._authProvider) {
+      const tokens = await this._authProvider.tokens();
+      if (tokens) {
+        headers["Authorization"] = `Bearer ${tokens.access_token}`;
+      }
+    }
+    if (this._sessionId) {
+      headers["mcp-session-id"] = this._sessionId;
+    }
+    if (this._protocolVersion) {
+      headers["mcp-protocol-version"] = this._protocolVersion;
+    }
+    const extraHeaders = normalizeHeaders(this._requestInit?.headers);
+    return new Headers({
+      ...headers,
+      ...extraHeaders
+    });
+  }
+  async _startOrAuthSse(options) {
+    const { resumptionToken } = options;
+    try {
+      const headers = await this._commonHeaders();
+      headers.set("Accept", "text/event-stream");
+      if (resumptionToken) {
+        headers.set("last-event-id", resumptionToken);
+      }
+      const response = await (this._fetch ?? fetch)(this._url, {
+        method: "GET",
+        headers,
+        signal: this._abortController?.signal
+      });
+      if (!response.ok) {
+        await response.body?.cancel();
+        if (response.status === 401 && this._authProvider) {
+          return await this._authThenStart();
+        }
+        if (response.status === 405) {
+          return;
+        }
+        throw new StreamableHTTPError(response.status, `Failed to open SSE stream: ${response.statusText}`);
+      }
+      this._handleSseStream(response.body, options, true);
+    } catch (error2) {
+      this.onerror?.(error2);
+      throw error2;
+    }
+  }
+  /**
+   * Calculates the next reconnection delay using  backoff algorithm
+   *
+   * @param attempt Current reconnection attempt count for the specific stream
+   * @returns Time to wait in milliseconds before next reconnection attempt
+   */
+  _getNextReconnectionDelay(attempt) {
+    if (this._serverRetryMs !== void 0) {
+      return this._serverRetryMs;
+    }
+    const initialDelay = this._reconnectionOptions.initialReconnectionDelay;
+    const growFactor = this._reconnectionOptions.reconnectionDelayGrowFactor;
+    const maxDelay = this._reconnectionOptions.maxReconnectionDelay;
+    return Math.min(initialDelay * Math.pow(growFactor, attempt), maxDelay);
+  }
+  /**
+   * Schedule a reconnection attempt using server-provided retry interval or backoff
+   *
+   * @param lastEventId The ID of the last received event for resumability
+   * @param attemptCount Current reconnection attempt count for this specific stream
+   */
+  _scheduleReconnection(options, attemptCount = 0) {
+    const maxRetries = this._reconnectionOptions.maxRetries;
+    if (attemptCount >= maxRetries) {
+      this.onerror?.(new Error(`Maximum reconnection attempts (${maxRetries}) exceeded.`));
+      return;
+    }
+    const delay = this._getNextReconnectionDelay(attemptCount);
+    this._reconnectionTimeout = setTimeout(() => {
+      this._startOrAuthSse(options).catch((error2) => {
+        this.onerror?.(new Error(`Failed to reconnect SSE stream: ${error2 instanceof Error ? error2.message : String(error2)}`));
+        this._scheduleReconnection(options, attemptCount + 1);
+      });
+    }, delay);
+  }
+  _handleSseStream(stream, options, isReconnectable) {
+    if (!stream) {
+      return;
+    }
+    const { onresumptiontoken, replayMessageId } = options;
+    let lastEventId;
+    let hasPrimingEvent = false;
+    let receivedResponse = false;
+    const processStream = async () => {
+      try {
+        const reader = stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream({
+          onRetry: (retryMs) => {
+            this._serverRetryMs = retryMs;
+          }
+        })).getReader();
+        while (true) {
+          const { value: event, done } = await reader.read();
+          if (done) {
+            break;
+          }
+          if (event.id) {
+            lastEventId = event.id;
+            hasPrimingEvent = true;
+            onresumptiontoken?.(event.id);
+          }
+          if (!event.data) {
+            continue;
+          }
+          if (!event.event || event.event === "message") {
+            try {
+              const message = JSONRPCMessageSchema.parse(JSON.parse(event.data));
+              if (isJSONRPCResultResponse(message)) {
+                receivedResponse = true;
+                if (replayMessageId !== void 0) {
+                  message.id = replayMessageId;
+                }
+              }
+              this.onmessage?.(message);
+            } catch (error2) {
+              this.onerror?.(error2);
+            }
+          }
+        }
+        const canResume = isReconnectable || hasPrimingEvent;
+        const needsReconnect = canResume && !receivedResponse;
+        if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
+          this._scheduleReconnection({
+            resumptionToken: lastEventId,
+            onresumptiontoken,
+            replayMessageId
+          }, 0);
+        }
+      } catch (error2) {
+        this.onerror?.(new Error(`SSE stream disconnected: ${error2}`));
+        const canResume = isReconnectable || hasPrimingEvent;
+        const needsReconnect = canResume && !receivedResponse;
+        if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
+          try {
+            this._scheduleReconnection({
+              resumptionToken: lastEventId,
+              onresumptiontoken,
+              replayMessageId
+            }, 0);
+          } catch (error3) {
+            this.onerror?.(new Error(`Failed to reconnect: ${error3 instanceof Error ? error3.message : String(error3)}`));
+          }
+        }
+      }
+    };
+    processStream();
+  }
+  async start() {
+    if (this._abortController) {
+      throw new Error("StreamableHTTPClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+    }
+    this._abortController = new AbortController();
+  }
+  /**
+   * Call this method after the user has finished authorizing via their user agent and is redirected back to the MCP client application. This will exchange the authorization code for an access token, enabling the next connection attempt to successfully auth.
+   */
+  async finishAuth(authorizationCode) {
+    if (!this._authProvider) {
+      throw new UnauthorizedError("No auth provider");
+    }
+    const result = await auth(this._authProvider, {
+      serverUrl: this._url,
+      authorizationCode,
+      resourceMetadataUrl: this._resourceMetadataUrl,
+      scope: this._scope,
+      fetchFn: this._fetchWithInit
+    });
+    if (result !== "AUTHORIZED") {
+      throw new UnauthorizedError("Failed to authorize");
+    }
+  }
+  async close() {
+    if (this._reconnectionTimeout) {
+      clearTimeout(this._reconnectionTimeout);
+      this._reconnectionTimeout = void 0;
+    }
+    this._abortController?.abort();
+    this.onclose?.();
+  }
+  async send(message, options) {
+    try {
+      const { resumptionToken, onresumptiontoken } = options || {};
+      if (resumptionToken) {
+        this._startOrAuthSse({ resumptionToken, replayMessageId: isJSONRPCRequest(message) ? message.id : void 0 }).catch((err6) => this.onerror?.(err6));
+        return;
+      }
+      const headers = await this._commonHeaders();
+      headers.set("content-type", "application/json");
+      headers.set("accept", "application/json, text/event-stream");
+      const init = {
+        ...this._requestInit,
+        method: "POST",
+        headers,
+        body: JSON.stringify(message),
+        signal: this._abortController?.signal
+      };
+      const response = await (this._fetch ?? fetch)(this._url, init);
+      const sessionId = response.headers.get("mcp-session-id");
+      if (sessionId) {
+        this._sessionId = sessionId;
+      }
+      if (!response.ok) {
+        const text = await response.text().catch(() => null);
+        if (response.status === 401 && this._authProvider) {
+          if (this._hasCompletedAuthFlow) {
+            throw new StreamableHTTPError(401, "Server returned 401 after successful authentication");
+          }
+          const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
+          this._resourceMetadataUrl = resourceMetadataUrl;
+          this._scope = scope;
+          const result = await auth(this._authProvider, {
+            serverUrl: this._url,
+            resourceMetadataUrl: this._resourceMetadataUrl,
+            scope: this._scope,
+            fetchFn: this._fetchWithInit
+          });
+          if (result !== "AUTHORIZED") {
+            throw new UnauthorizedError();
+          }
+          this._hasCompletedAuthFlow = true;
+          return this.send(message);
+        }
+        if (response.status === 403 && this._authProvider) {
+          const { resourceMetadataUrl, scope, error: error2 } = extractWWWAuthenticateParams(response);
+          if (error2 === "insufficient_scope") {
+            const wwwAuthHeader = response.headers.get("WWW-Authenticate");
+            if (this._lastUpscopingHeader === wwwAuthHeader) {
+              throw new StreamableHTTPError(403, "Server returned 403 after trying upscoping");
+            }
+            if (scope) {
+              this._scope = scope;
+            }
+            if (resourceMetadataUrl) {
+              this._resourceMetadataUrl = resourceMetadataUrl;
+            }
+            this._lastUpscopingHeader = wwwAuthHeader ?? void 0;
+            const result = await auth(this._authProvider, {
+              serverUrl: this._url,
+              resourceMetadataUrl: this._resourceMetadataUrl,
+              scope: this._scope,
+              fetchFn: this._fetch
+            });
+            if (result !== "AUTHORIZED") {
+              throw new UnauthorizedError();
+            }
+            return this.send(message);
+          }
+        }
+        throw new StreamableHTTPError(response.status, `Error POSTing to endpoint: ${text}`);
+      }
+      this._hasCompletedAuthFlow = false;
+      this._lastUpscopingHeader = void 0;
+      if (response.status === 202) {
+        await response.body?.cancel();
+        if (isInitializedNotification(message)) {
+          this._startOrAuthSse({ resumptionToken: void 0 }).catch((err6) => this.onerror?.(err6));
+        }
+        return;
+      }
+      const messages = Array.isArray(message) ? message : [message];
+      const hasRequests = messages.filter((msg) => "method" in msg && "id" in msg && msg.id !== void 0).length > 0;
+      const contentType = response.headers.get("content-type");
+      if (hasRequests) {
+        if (contentType?.includes("text/event-stream")) {
+          this._handleSseStream(response.body, { onresumptiontoken }, false);
+        } else if (contentType?.includes("application/json")) {
+          const data = await response.json();
+          const responseMessages = Array.isArray(data) ? data.map((msg) => JSONRPCMessageSchema.parse(msg)) : [JSONRPCMessageSchema.parse(data)];
+          for (const msg of responseMessages) {
+            this.onmessage?.(msg);
+          }
+        } else {
+          await response.body?.cancel();
+          throw new StreamableHTTPError(-1, `Unexpected content type: ${contentType}`);
+        }
+      } else {
+        await response.body?.cancel();
+      }
+    } catch (error2) {
+      this.onerror?.(error2);
+      throw error2;
+    }
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  /**
+   * Terminates the current session by sending a DELETE request to the server.
+   *
+   * Clients that no longer need a particular session
+   * (e.g., because the user is leaving the client application) SHOULD send an
+   * HTTP DELETE to the MCP endpoint with the Mcp-Session-Id header to explicitly
+   * terminate the session.
+   *
+   * The server MAY respond with HTTP 405 Method Not Allowed, indicating that
+   * the server does not allow clients to terminate sessions.
+   */
+  async terminateSession() {
+    if (!this._sessionId) {
+      return;
+    }
+    try {
+      const headers = await this._commonHeaders();
+      const init = {
+        ...this._requestInit,
+        method: "DELETE",
+        headers,
+        signal: this._abortController?.signal
+      };
+      const response = await (this._fetch ?? fetch)(this._url, init);
+      await response.body?.cancel();
+      if (!response.ok && response.status !== 405) {
+        throw new StreamableHTTPError(response.status, `Failed to terminate session: ${response.statusText}`);
+      }
+      this._sessionId = void 0;
+    } catch (error2) {
+      this.onerror?.(error2);
+      throw error2;
+    }
+  }
+  setProtocolVersion(version2) {
+    this._protocolVersion = version2;
+  }
+  get protocolVersion() {
+    return this._protocolVersion;
+  }
+  /**
+   * Resume an SSE stream from a previous event ID.
+   * Opens a GET SSE connection with Last-Event-ID header to replay missed events.
+   *
+   * @param lastEventId The event ID to resume from
+   * @param options Optional callback to receive new resumption tokens
+   */
+  async resumeStream(lastEventId, options) {
+    await this._startOrAuthSse({
+      resumptionToken: lastEventId,
+      onresumptiontoken: options?.onresumptiontoken
+    });
+  }
+};
+
+// ../mcp-server/src/tools/codegraph.ts
+var CODEGRAPH_PORT = parseInt(process.env["CODEGRAPH_PORT"] ?? "3201", 10);
+var clientPromise = null;
+function getCodegraphClient() {
+  if (!clientPromise) {
+    clientPromise = (async () => {
+      const client = new Client(
+        { name: "bridge-mcp-codegraph-proxy", version: "0.1.0" },
+        { capabilities: {} }
+      );
+      const transport = new StreamableHTTPClientTransport(
+        new URL(`http://127.0.0.1:${CODEGRAPH_PORT}/mcp`)
+      );
+      await client.connect(transport);
+      return client;
+    })().catch((err6) => {
+      clientPromise = null;
+      throw err6;
+    });
+  }
+  return clientPromise;
+}
+async function resolveCwd(ctx, cwd) {
+  if (cwd && cwd.trim()) return cwd;
+  try {
+    const p = await getProject(ctx);
+    if (p.cwd) return p.cwd;
+  } catch {
+  }
+  return process.cwd();
+}
+async function proxy(ctx, toolName, rawArgs) {
+  const cwd = await resolveCwd(ctx, rawArgs["cwd"]);
+  try {
+    const client = await getCodegraphClient();
+    const res = await client.callTool({
+      name: toolName,
+      arguments: { ...rawArgs, cwd, agentId: ctx.agentId, projectId: ctx.projectId }
+    });
+    return {
+      content: res.content,
+      isError: res.isError === true
+    };
+  } catch (err6) {
+    const msg = err6 instanceof Error ? err6.message : String(err6);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: `Codegraph proxy error: ${msg}` }) }],
+      isError: true
+    };
+  }
+}
+function registerCodegraphTools(server, ctx) {
+  const P = (name, args) => proxy(ctx, name, args);
+  server.tool(
+    "bridge_codegraph_status",
+    "Codegraph index status + resolution coverage for a project (health/coverage probe). Prefer over reading whole files for structural questions. Returns {indexed, total, coverage:{resolved,unresolved}}.",
+    { cwd: external_exports.string().optional().describe("Project root. Defaults to the bridge project cwd.") },
+    ({ cwd }) => P("bridge_codegraph_status", { cwd })
+  );
+  server.tool(
+    "bridge_codegraph_index",
+    "Index (or refresh) a project for codegraph structural queries. Call before find_symbol etc. if status shows not-indexed. Prefer over broad Grep for structural discovery.",
+    {
+      cwd: external_exports.string().optional().describe("Project root. Defaults to the bridge project cwd."),
+      force: external_exports.boolean().optional().describe("Re-index from scratch"),
+      wait: external_exports.boolean().optional().describe("Wait for indexing to finish (default true)")
+    },
+    ({ cwd, force, wait }) => P("bridge_codegraph_index", { cwd, force, wait })
+  );
+  server.tool(
+    "bridge_codegraph_find_symbol",
+    'Find a symbol by name (and optional kind) in the indexed project. PREFER over Read/Grep for "where is X defined". Limits/offset supported for pagination.',
+    {
+      name: external_exports.string().describe("Symbol name to find (substring match)"),
+      kind: external_exports.string().optional().describe("Optional symbol kind filter (function, class, method, ...)"),
+      limit: external_exports.number().optional().describe("Max results (default 50)"),
+      offset: external_exports.number().optional().describe("Pagination offset (default 0)"),
+      cwd: external_exports.string().optional().describe("Project root. Defaults to the bridge project cwd.")
+    },
+    ({ name, kind, limit, offset, cwd }) => P("bridge_codegraph_find_symbol", { name, kind, limit, offset, cwd })
+  );
+  server.tool(
+    "bridge_codegraph_file_outline",
+    "Return the structural outline (symbols + signatures) of a single file. PREFER over reading the whole file when you only need its shape.",
+    {
+      file: external_exports.string().describe("Path to the file to outline"),
+      cwd: external_exports.string().optional().describe("Project root. Defaults to the bridge project cwd.")
+    },
+    ({ file, cwd }) => P("bridge_codegraph_file_outline", { file, cwd })
+  );
+  server.tool(
+    "bridge_codegraph_find_references",
+    'Find all call/reference sites of a qualified symbol ("who calls X"). PREFER over Grep for "who calls/uses X". Returns callers with file+line.',
+    {
+      qualifiedName: external_exports.string().describe("Qualified symbol name (e.g. PtyManager)"),
+      limit: external_exports.number().optional().describe("Max results (default 200)"),
+      offset: external_exports.number().optional().describe("Pagination offset (default 0)"),
+      cwd: external_exports.string().optional().describe("Project root. Defaults to the bridge project cwd.")
+    },
+    ({ qualifiedName, limit, offset, cwd }) => P("bridge_codegraph_find_references", { qualifiedName, limit, offset, cwd })
+  );
+  server.tool(
+    "bridge_codegraph_call_graph",
+    'Get the call graph (in/out/both) around a qualified symbol with bounded depth. PREFER over manual Grep traversal for "what does X call / who depends on X".',
+    {
+      qualifiedName: external_exports.string().describe("Qualified symbol name"),
+      direction: external_exports.enum(["in", "out", "both"]).optional().describe("Edge direction (default out)"),
+      depth: external_exports.number().min(1).max(3).optional().describe("Traversal depth 1-3 (default 2)"),
+      cwd: external_exports.string().optional().describe("Project root. Defaults to the bridge project cwd.")
+    },
+    ({ qualifiedName, direction, depth, cwd }) => P("bridge_codegraph_call_graph", { qualifiedName, direction, depth, cwd })
+  );
+  server.tool(
+    "bridge_codegraph_get_symbol_source",
+    "Return the source snippet of a qualified symbol. PREFER over reading the whole file when you only need one symbol's body.",
+    {
+      qualifiedName: external_exports.string().describe("Qualified symbol name"),
+      cwd: external_exports.string().optional().describe("Project root. Defaults to the bridge project cwd.")
+    },
+    ({ qualifiedName, cwd }) => P("bridge_codegraph_get_symbol_source", { qualifiedName, cwd })
+  );
+  server.tool(
+    "bridge_codegraph_diff_impact",
+    "Blast-radius of a git diff: exported symbols changed in modified files + every transitive caller (depth \u2264 3) of those symbols. PREFER over manual Grep when reviewing what a change touches. Returns {changedFiles, changedSymbols, impactedSymbols:[{qualifiedName,file,line,depth}], truncated}.",
+    {
+      cwd: external_exports.string().optional().describe("Project root. Defaults to the bridge project cwd."),
+      base: external_exports.string().optional().describe("Git diff base ref (default HEAD \u2014 working tree vs HEAD)")
+    },
+    ({ cwd, base }) => P("bridge_codegraph_diff_impact", { cwd, base })
+  );
+}
+
+// ../mcp-server/src/codegraph-toggle.ts
+var TOGGLE_TTL_MS = 1e4;
+var TOGGLE_TIMEOUT_MS = 5e3;
+var cache = /* @__PURE__ */ new Map();
+function envOverride() {
+  const v = process.env["BRIDGE_CODEGRAPH"];
+  if (v === void 0 || v.trim() === "") return null;
+  return !(v === "0" || v.toLowerCase() === "false");
+}
+async function codegraphToolsEnabled(ctx) {
+  const hard = envOverride();
+  if (hard !== null) return hard;
+  const cacheKey2 = ctx.agentId ?? "";
+  const now = Date.now();
+  const hit = cache.get(cacheKey2);
+  if (hit && now < hit.expiresAt) return hit.enabled;
+  let enabled = true;
+  try {
+    const base = ctx.serverUrl.replace(/\/$/, "");
+    const params = new URLSearchParams();
+    if (ctx.agentId) params.set("agentId", ctx.agentId);
+    const res = await request(
+      ctx,
+      "GET",
+      `${base}/api/meta/codegraph?${params.toString()}`,
+      void 0,
+      { timeoutMs: TOGGLE_TIMEOUT_MS }
+    );
+    if (res.arm === "on" || res.arm === "off") enabled = res.arm === "on";
+    else if (typeof res.enabled === "boolean") enabled = res.enabled;
+  } catch (err6) {
+    console.warn("[codegraph-toggle] arm fetch failed, failing OPEN (tools ON):", err6 instanceof Error ? err6.message : err6);
+  }
+  cache.set(cacheKey2, { enabled, expiresAt: now + TOGGLE_TTL_MS });
+  return enabled;
+}
+
+// ../mcp-server/src/index.ts
+var sessions = /* @__PURE__ */ new Map();
+async function buildMcpServer(ctx) {
+  const srv = new McpServer({ name: "bridge", version: "0.1.0" });
+  registerPlanTools(srv, ctx);
+  registerTodoTools(srv, ctx);
+  registerOrchestrationTools(srv, ctx);
+  registerMessagingTools(srv, ctx);
+  registerWorkspaceTools(srv, ctx);
+  registerPersonaTools(srv, ctx);
+  registerRolePromptTools(srv, ctx);
+  registerGroupSchemaTools(srv, ctx);
+  if (await codegraphToolsEnabled(ctx)) {
+    registerCodegraphTools(srv, ctx);
+  }
   return srv;
 }
 async function parseBody(req) {
@@ -23226,15 +25872,15 @@ function startHttpServer() {
   }
   const port = parseInt(process.env["PORT"] ?? "3200", 10);
   const httpServer = (0, import_node_http.createServer)(async (req, res) => {
-    const url = req.url ?? "/";
+    const url2 = req.url ?? "/";
     const method = req.method ?? "GET";
     try {
-      if (method === "GET" && (url === "/health" || url === "/health/")) {
+      if (method === "GET" && (url2 === "/health" || url2 === "/health/")) {
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ ok: true, sessions: sessions.size }));
         return;
       }
-      const match = url.match(/^\/mcp\/([^/?#]+)\/([^/?#]+)/);
+      const match = url2.match(/^\/mcp\/([^/?#]+)\/([^/?#]+)/);
       if (!match || !["GET", "POST", "DELETE"].includes(method)) {
         res.writeHead(404, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: "Not found" }));
@@ -23242,8 +25888,8 @@ function startHttpServer() {
       }
       const workspaceId = match[1];
       const projectId = match[2];
-      const auth = req.headers["authorization"] ?? "";
-      const token = auth.startsWith("Bearer ") ? auth.slice(7).trim() : "";
+      const auth2 = req.headers["authorization"] ?? "";
+      const token = auth2.startsWith("Bearer ") ? auth2.slice(7).trim() : "";
       if (!token) {
         res.writeHead(401, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: "Authorization: Bearer <token> required" }));
@@ -23300,11 +25946,11 @@ function startHttpServer() {
           sessions.delete(id);
         }
       });
-      const mcpServer = buildMcpServer(ctx);
+      const mcpServer = await buildMcpServer(ctx);
       await mcpServer.connect(transport);
       await transport.handleRequest(req, res, body);
-    } catch (err5) {
-      console.error("[bridge-mcp] request error:", err5);
+    } catch (err6) {
+      console.error("[bridge-mcp] request error:", err6);
       if (!res.headersSent) {
         res.writeHead(500, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: "Internal server error" }));
@@ -23331,7 +25977,7 @@ async function startStdioServer() {
     agentId: process.env["BRIDGE_PANEL_ID"] || void 0,
     personaId: process.env["BRIDGE_PERSONA_ID"] || void 0
   };
-  const srv = buildMcpServer(ctx);
+  const srv = await buildMcpServer(ctx);
   const transport = new StdioServerTransport();
   await srv.connect(transport);
   console.error("[bridge-mcp] connected via stdio");
@@ -23339,8 +25985,8 @@ async function startStdioServer() {
 if (process.env["HTTP_MODE"] !== "false") {
   startHttpServer();
 } else {
-  startStdioServer().catch((err5) => {
-    console.error("[bridge-mcp] fatal:", err5);
+  startStdioServer().catch((err6) => {
+    console.error("[bridge-mcp] fatal:", err6);
     process.exit(1);
   });
 }