@ashx-j/lunr-dev 0.2.16-dev.9.1 → 0.2.19-dev.10.1

package/dist/node-runtime/chunk-BKAZ6BKX.js

@@ -0,0 +1,2185 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  abortable,
+  computeServerHash,
+  extractToolUiStreamMode,
+  getMetadataCachePath,
+  getMissingConfiguredDirectToolServers,
+  interpolateEnvRecord,
+  isServerCacheValid,
+  loadMcpConfig,
+  loadMetadataCache,
+  openUrl,
+  parallelLimit,
+  reconstructToolMetadata,
+  resolveBearerToken,
+  resolveConfigPath,
+  saveMetadataCache,
+  serializeResources,
+  serializeTools,
+  throwIfAborted,
+  truncateAtWord
+} from "./chunk-EHMBW7FA.js";
+import {
+  formatToolName,
+  isToolExcluded,
+  resourceNameToToolName,
+  serverStreamResultPatchNotificationSchema
+} from "./chunk-ARC4KOTI.js";
+import {
+  AjvJsonSchemaValidator,
+  Client,
+  StdioClientTransport
+} from "./chunk-LWJXTA6Z.js";
+import {
+  McpOAuthProvider,
+  StreamableHTTPClientTransport,
+  UnauthorizedError,
+  auth,
+  createFetchWithInit,
+  createParser,
+  extractOAuthConfig,
+  extractWWWAuthenticateParams,
+  normalizeHeaders,
+  supportsOAuth
+} from "./chunk-U6C7VTR5.js";
+import {
+  getAgentPath
+} from "./chunk-4HXHDDCF.js";
+import {
+  CallToolResultSchema,
+  ContentBlockSchema,
+  CreateMessageRequestSchema,
+  ElicitRequestSchema,
+  ElicitationCompleteNotificationSchema,
+  EmbeddedResourceSchema,
+  ErrorCode,
+  ImplementationSchema,
+  JSONRPCMessageSchema,
+  McpError,
+  RequestIdSchema,
+  ResourceLinkSchema,
+  ToolSchema,
+  UrlElicitationRequiredError
+} from "./chunk-2IDTZAG5.js";
+import {
+  external_exports
+} from "./chunk-BI3DHYCN.js";
+import {
+  __require
+} from "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/init.js
+import { existsSync as existsSync2 } from "node:fs";
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/errors.js
+var McpUiError = class extends Error {
+  code;
+  context;
+  recoveryHint;
+  cause;
+  constructor(message, options) {
+    super(message), this.name = "McpUiError", this.code = options.code, this.context = options.context ?? {}, this.recoveryHint = options.recoveryHint, this.cause = options.cause, Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      context: this.context,
+      recoveryHint: this.recoveryHint,
+      stack: this.stack
+    };
+  }
+}, ResourceFetchError = class extends McpUiError {
+  constructor(uri, reason, options) {
+    super(`Failed to fetch UI resource "${uri}": ${reason}`, {
+      code: "RESOURCE_FETCH_ERROR",
+      context: { uri, server: options?.server },
+      recoveryHint: "Check that the MCP server is connected and the resource URI is valid.",
+      cause: options?.cause
+    }), this.name = "ResourceFetchError";
+  }
+}, ResourceParseError = class extends McpUiError {
+  constructor(uri, reason, options) {
+    super(`Invalid UI resource "${uri}": ${reason}`, {
+      code: "RESOURCE_PARSE_ERROR",
+      context: { uri, server: options?.server, mimeType: options?.mimeType },
+      recoveryHint: "Ensure the resource returns valid HTML with the correct MIME type."
+    }), this.name = "ResourceParseError";
+  }
+};
+var ConsentError = class extends McpUiError {
+  denied;
+  constructor(server, options) {
+    let message = options.denied ? `Tool calls for "${server}" were denied for this session` : `Tool call approval required for "${server}"`;
+    super(message, {
+      code: options.denied ? "CONSENT_DENIED" : "CONSENT_REQUIRED",
+      context: { server },
+      recoveryHint: options.denied ? "The user denied tool access. Start a new session to try again." : "Prompt the user for consent before calling tools."
+    }), this.name = "ConsentError", this.denied = options.denied ?? !1;
+  }
+};
+var ServerError = class extends McpUiError {
+  constructor(reason, options) {
+    super(`UI server error: ${reason}`, {
+      code: "SERVER_ERROR",
+      context: { port: options?.port },
+      recoveryHint: "Check if the port is available. Another process may be using it.",
+      cause: options?.cause
+    }), this.name = "ServerError";
+  }
+};
+function wrapError(error, context) {
+  if (error instanceof McpUiError)
+    return new McpUiError(error.message, {
+      code: error.code,
+      context: { ...error.context, ...context },
+      recoveryHint: error.recoveryHint,
+      cause: error.cause
+    });
+  let cause = error instanceof Error ? error : void 0, message = error instanceof Error ? error.message : String(error);
+  return new McpUiError(message, {
+    code: "UNKNOWN_ERROR",
+    context,
+    cause
+  });
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/logger.js
+var LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+}, LEVEL_PREFIX = {
+  debug: "[MCP-UI:DEBUG]",
+  info: "[MCP-UI]",
+  warn: "[MCP-UI:WARN]",
+  error: "[MCP-UI:ERROR]"
+}, Logger = class {
+  minLevel = "info";
+  handlers = [];
+  defaultContext = {};
+  setLevel(level) {
+    this.minLevel = level;
+  }
+  setDefaultContext(context) {
+    this.defaultContext = context;
+  }
+  addHandler(handler) {
+    this.handlers.push(handler);
+  }
+  clearHandlers() {
+    this.handlers = [];
+  }
+  shouldLog(level) {
+    return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[this.minLevel];
+  }
+  emit(level, message, context, error) {
+    if (!this.shouldLog(level))
+      return;
+    let entry = {
+      level,
+      message,
+      context: { ...this.defaultContext, ...context },
+      error,
+      timestamp: /* @__PURE__ */ new Date()
+    }, prefix = LEVEL_PREFIX[level], contextStr = formatContext(entry.context), fullMessage = contextStr ? `${prefix} ${message} ${contextStr}` : `${prefix} ${message}`;
+    level === "error" ? console.error(fullMessage, error ?? "") : level === "warn" ? console.warn(fullMessage) : level === "debug" ? console.debug(fullMessage) : console.log(fullMessage);
+    for (let handler of this.handlers)
+      try {
+        handler(entry);
+      } catch {
+      }
+  }
+  debug(message, context) {
+    this.emit("debug", message, context);
+  }
+  info(message, context) {
+    this.emit("info", message, context);
+  }
+  warn(message, context) {
+    this.emit("warn", message, context);
+  }
+  error(message, error, context) {
+    this.emit("error", message, context, error);
+  }
+  /**
+   * Create a child logger with additional default context.
+   */
+  child(context) {
+    return new ChildLogger(this, context);
+  }
+}, ChildLogger = class _ChildLogger {
+  parent;
+  context;
+  constructor(parent, context) {
+    this.parent = parent, this.context = context;
+  }
+  debug(message, context) {
+    this.parent.debug(message, { ...this.context, ...context });
+  }
+  info(message, context) {
+    this.parent.info(message, { ...this.context, ...context });
+  }
+  warn(message, context) {
+    this.parent.warn(message, { ...this.context, ...context });
+  }
+  error(message, error, context) {
+    this.parent.error(message, error, { ...this.context, ...context });
+  }
+  child(context) {
+    return new _ChildLogger(this.parent, { ...this.context, ...context });
+  }
+};
+function formatContext(context) {
+  if (!context || Object.keys(context).length === 0)
+    return "";
+  let parts = [];
+  for (let [key, value] of Object.entries(context))
+    value != null && parts.push(`${key}=${typeof value == "string" ? value : JSON.stringify(value)}`);
+  return parts.length > 0 ? `(${parts.join(", ")})` : "";
+}
+var logger = new Logger();
+(process.env.MCP_UI_DEBUG === "1" || process.env.MCP_UI_DEBUG === "true") && logger.setLevel("debug");
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/consent-manager.js
+var ConsentManager = class {
+  mode;
+  approvedServers = /* @__PURE__ */ new Set();
+  deniedServers = /* @__PURE__ */ new Set();
+  log = logger.child({ component: "ConsentManager" });
+  constructor(mode = "once-per-server") {
+    this.mode = mode, this.log.debug("Initialized", { mode });
+  }
+  requiresPrompt(serverName) {
+    return this.mode === "never" ? !1 : this.deniedServers.has(serverName) || this.mode === "always" ? !0 : !this.approvedServers.has(serverName);
+  }
+  shouldCacheConsent() {
+    return this.mode !== "always";
+  }
+  registerDecision(serverName, approved) {
+    if (this.deniedServers.delete(serverName), this.approvedServers.delete(serverName), approved) {
+      this.approvedServers.add(serverName), this.log.debug("Consent granted", { server: serverName });
+      return;
+    }
+    this.deniedServers.add(serverName), this.log.debug("Consent denied", { server: serverName });
+  }
+  ensureApproved(serverName) {
+    if (this.mode !== "never") {
+      if (this.deniedServers.has(serverName))
+        throw new ConsentError(serverName, { denied: !0 });
+      if (!this.approvedServers.has(serverName))
+        throw new ConsentError(serverName, { requiresApproval: !0 });
+      this.mode === "always" && this.approvedServers.delete(serverName);
+    }
+  }
+  clear(serverName) {
+    if (serverName) {
+      this.approvedServers.delete(serverName), this.deniedServers.delete(serverName), this.log.debug("Cleared consent for server", { server: serverName });
+      return;
+    }
+    this.approvedServers.clear(), this.deniedServers.clear(), this.log.debug("Cleared all consent records");
+  }
+};
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/lifecycle.js
+var McpLifecycleManager = class {
+  manager;
+  keepAliveServers = /* @__PURE__ */ new Map();
+  allServers = /* @__PURE__ */ new Map();
+  serverSettings = /* @__PURE__ */ new Map();
+  globalIdleTimeout = 600 * 1e3;
+  healthCheckInterval;
+  onReconnect;
+  onIdleShutdown;
+  constructor(manager) {
+    this.manager = manager;
+  }
+  /**
+   * Set callback to be invoked after a successful auto-reconnect.
+   * Use this to update tool metadata when a server reconnects.
+   */
+  setReconnectCallback(callback) {
+    this.onReconnect = callback;
+  }
+  markKeepAlive(name, definition) {
+    this.keepAliveServers.set(name, definition);
+  }
+  registerServer(name, definition, settings) {
+    this.allServers.set(name, definition), settings?.idleTimeout !== void 0 && this.serverSettings.set(name, settings);
+  }
+  setGlobalIdleTimeout(minutes) {
+    this.globalIdleTimeout = minutes * 60 * 1e3;
+  }
+  setIdleShutdownCallback(callback) {
+    this.onIdleShutdown = callback;
+  }
+  startHealthChecks(intervalMs = 3e4) {
+    this.healthCheckInterval = setInterval(() => {
+      this.checkConnections();
+    }, intervalMs), this.healthCheckInterval.unref();
+  }
+  async checkConnections() {
+    for (let [name, definition] of this.keepAliveServers) {
+      let connection = this.manager.getConnection(name);
+      if (!connection || connection.status !== "connected")
+        try {
+          await this.manager.connect(name, definition), logger.debug(`Reconnected to ${name}`), this.onReconnect?.(name);
+        } catch (error) {
+          console.error(`MCP: Failed to reconnect to ${name}:`, error);
+        }
+    }
+    for (let [name] of this.allServers) {
+      if (this.keepAliveServers.has(name))
+        continue;
+      let timeout = this.getIdleTimeout(name);
+      timeout > 0 && this.manager.isIdle(name, timeout) && (await this.manager.close(name), this.onIdleShutdown?.(name));
+    }
+  }
+  getIdleTimeout(name) {
+    let perServer = this.serverSettings.get(name)?.idleTimeout;
+    return perServer !== void 0 ? perServer * 60 * 1e3 : this.globalIdleTimeout;
+  }
+  async gracefulShutdown() {
+    this.healthCheckInterval && clearInterval(this.healthCheckInterval), await this.manager.closeAll();
+  }
+};
+
+// node_modules/eventsource/dist/index.js
+var ErrorEvent = class extends Event {
+  /**
+   * Constructs a new `ErrorEvent` instance. This is typically not called directly,
+   * but rather emitted by the `EventSource` object when an error occurs.
+   *
+   * @param type - The type of the event (should be "error")
+   * @param errorEventInitDict - Optional properties to include in the error event
+   */
+  constructor(type, errorEventInitDict) {
+    var _a, _b;
+    super(type), this.code = (_a = errorEventInitDict?.code) != null ? _a : void 0, this.message = (_b = errorEventInitDict?.message) != null ? _b : void 0;
+  }
+  /**
+   * Node.js "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+   * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+   * we explicitly include the properties in the `inspect` method.
+   *
+   * This is automatically called by Node.js when you `console.log` an instance of this class.
+   *
+   * @param _depth - The current depth
+   * @param options - The options passed to `util.inspect`
+   * @param inspect - The inspect function to use (prevents having to import it from `util`)
+   * @returns A string representation of the error
+   */
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")](_depth, options, inspect) {
+    return inspect(inspectableError(this), options);
+  }
+  /**
+   * Deno "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+   * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+   * we explicitly include the properties in the `inspect` method.
+   *
+   * This is automatically called by Deno when you `console.log` an instance of this class.
+   *
+   * @param inspect - The inspect function to use (prevents having to import it from `util`)
+   * @param options - The options passed to `Deno.inspect`
+   * @returns A string representation of the error
+   */
+  [/* @__PURE__ */ Symbol.for("Deno.customInspect")](inspect, options) {
+    return inspect(inspectableError(this), options);
+  }
+};
+function syntaxError(message) {
+  let DomException = globalThis.DOMException;
+  return typeof DomException == "function" ? new DomException(message, "SyntaxError") : new SyntaxError(message);
+}
+function flattenError(err) {
+  return err instanceof Error ? "errors" in err && Array.isArray(err.errors) ? err.errors.map(flattenError).join(", ") : "cause" in err && err.cause instanceof Error ? `${err}: ${flattenError(err.cause)}` : err.message : `${err}`;
+}
+function inspectableError(err) {
+  return {
+    type: err.type,
+    message: err.message,
+    code: err.code,
+    defaultPrevented: err.defaultPrevented,
+    cancelable: err.cancelable,
+    timeStamp: err.timeStamp
+  };
+}
+var __typeError = (msg) => {
+  throw TypeError(msg);
+}, __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg), __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj)), __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value), __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value), __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method), _readyState, _url, _redirectUrl, _withCredentials, _fetch, _reconnectInterval, _reconnectTimer, _lastEventId, _controller, _parser, _onError, _onMessage, _onOpen, _EventSource_instances, connect_fn, _onFetchResponse, _onFetchError, getRequestOptions_fn, _onEvent, _onRetryChange, failConnection_fn, scheduleReconnect_fn, _reconnect, EventSource = class extends EventTarget {
+  constructor(url, eventSourceInitDict) {
+    var _a, _b;
+    super(), __privateAdd(this, _EventSource_instances), this.CONNECTING = 0, this.OPEN = 1, this.CLOSED = 2, __privateAdd(this, _readyState), __privateAdd(this, _url), __privateAdd(this, _redirectUrl), __privateAdd(this, _withCredentials), __privateAdd(this, _fetch), __privateAdd(this, _reconnectInterval), __privateAdd(this, _reconnectTimer), __privateAdd(this, _lastEventId, null), __privateAdd(this, _controller), __privateAdd(this, _parser), __privateAdd(this, _onError, null), __privateAdd(this, _onMessage, null), __privateAdd(this, _onOpen, null), __privateAdd(this, _onFetchResponse, async (response) => {
+      var _a2;
+      __privateGet(this, _parser).reset();
+      let { body, redirected, status, headers } = response;
+      if (status === 204) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Server sent HTTP 204, not reconnecting", 204), this.close();
+        return;
+      }
+      if (redirected ? __privateSet(this, _redirectUrl, new URL(response.url)) : __privateSet(this, _redirectUrl, void 0), status !== 200) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, `Non-200 status code (${status})`, status);
+        return;
+      }
+      if (!(headers.get("content-type") || "").startsWith("text/event-stream")) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, 'Invalid content type, expected "text/event-stream"', status);
+        return;
+      }
+      if (__privateGet(this, _readyState) === this.CLOSED)
+        return;
+      __privateSet(this, _readyState, this.OPEN);
+      let openEvent = new Event("open");
+      if ((_a2 = __privateGet(this, _onOpen)) == null || _a2.call(this, openEvent), this.dispatchEvent(openEvent), typeof body != "object" || !body || !("getReader" in body)) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Invalid response body, expected a web ReadableStream", status), this.close();
+        return;
+      }
+      let decoder = new TextDecoder(), reader = body.getReader(), open2 = !0;
+      do {
+        let { done, value } = await reader.read();
+        value && __privateGet(this, _parser).feed(decoder.decode(value, { stream: !done })), done && (open2 = !1, __privateGet(this, _parser).reset(), __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this));
+      } while (open2);
+    }), __privateAdd(this, _onFetchError, (err) => {
+      __privateSet(this, _controller, void 0), !(err.name === "AbortError" || err.type === "aborted") && __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this, flattenError(err));
+    }), __privateAdd(this, _onEvent, (event) => {
+      typeof event.id == "string" && __privateSet(this, _lastEventId, event.id);
+      let messageEvent = new MessageEvent(event.event || "message", {
+        data: event.data,
+        origin: __privateGet(this, _redirectUrl) ? __privateGet(this, _redirectUrl).origin : __privateGet(this, _url).origin,
+        lastEventId: event.id || ""
+      });
+      __privateGet(this, _onMessage) && (!event.event || event.event === "message") && __privateGet(this, _onMessage).call(this, messageEvent), this.dispatchEvent(messageEvent);
+    }), __privateAdd(this, _onRetryChange, (value) => {
+      __privateSet(this, _reconnectInterval, value);
+    }), __privateAdd(this, _reconnect, () => {
+      __privateSet(this, _reconnectTimer, void 0), __privateGet(this, _readyState) === this.CONNECTING && __privateMethod(this, _EventSource_instances, connect_fn).call(this);
+    });
+    try {
+      if (url instanceof URL)
+        __privateSet(this, _url, url);
+      else if (typeof url == "string")
+        __privateSet(this, _url, new URL(url, getBaseURL()));
+      else
+        throw new Error("Invalid URL");
+    } catch {
+      throw syntaxError("An invalid or illegal string was specified");
+    }
+    __privateSet(this, _parser, createParser({
+      onEvent: __privateGet(this, _onEvent),
+      onRetry: __privateGet(this, _onRetryChange)
+    })), __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _reconnectInterval, 3e3), __privateSet(this, _fetch, (_a = eventSourceInitDict?.fetch) != null ? _a : globalThis.fetch), __privateSet(this, _withCredentials, (_b = eventSourceInitDict?.withCredentials) != null ? _b : !1), __privateMethod(this, _EventSource_instances, connect_fn).call(this);
+  }
+  /**
+   * Returns the state of this EventSource object's connection. It can have the values described below.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/readyState)
+   *
+   * Note: typed as `number` instead of `0 | 1 | 2` for compatibility with the `EventSource` interface,
+   * defined in the TypeScript `dom` library.
+   *
+   * @public
+   */
+  get readyState() {
+    return __privateGet(this, _readyState);
+  }
+  /**
+   * Returns the URL providing the event stream.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/url)
+   *
+   * @public
+   */
+  get url() {
+    return __privateGet(this, _url).href;
+  }
+  /**
+   * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/withCredentials)
+   */
+  get withCredentials() {
+    return __privateGet(this, _withCredentials);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */
+  get onerror() {
+    return __privateGet(this, _onError);
+  }
+  set onerror(value) {
+    __privateSet(this, _onError, value);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */
+  get onmessage() {
+    return __privateGet(this, _onMessage);
+  }
+  set onmessage(value) {
+    __privateSet(this, _onMessage, value);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */
+  get onopen() {
+    return __privateGet(this, _onOpen);
+  }
+  set onopen(value) {
+    __privateSet(this, _onOpen, value);
+  }
+  addEventListener(type, listener, options) {
+    let listen = listener;
+    super.addEventListener(type, listen, options);
+  }
+  removeEventListener(type, listener, options) {
+    let listen = listener;
+    super.removeEventListener(type, listen, options);
+  }
+  /**
+   * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/close)
+   *
+   * @public
+   */
+  close() {
+    __privateGet(this, _reconnectTimer) && clearTimeout(__privateGet(this, _reconnectTimer)), __privateGet(this, _readyState) !== this.CLOSED && (__privateGet(this, _controller) && __privateGet(this, _controller).abort(), __privateSet(this, _readyState, this.CLOSED), __privateSet(this, _controller, void 0));
+  }
+};
+_readyState = /* @__PURE__ */ new WeakMap(), _url = /* @__PURE__ */ new WeakMap(), _redirectUrl = /* @__PURE__ */ new WeakMap(), _withCredentials = /* @__PURE__ */ new WeakMap(), _fetch = /* @__PURE__ */ new WeakMap(), _reconnectInterval = /* @__PURE__ */ new WeakMap(), _reconnectTimer = /* @__PURE__ */ new WeakMap(), _lastEventId = /* @__PURE__ */ new WeakMap(), _controller = /* @__PURE__ */ new WeakMap(), _parser = /* @__PURE__ */ new WeakMap(), _onError = /* @__PURE__ */ new WeakMap(), _onMessage = /* @__PURE__ */ new WeakMap(), _onOpen = /* @__PURE__ */ new WeakMap(), _EventSource_instances = /* @__PURE__ */ new WeakSet(), /**
+* Connect to the given URL and start receiving events
+*
+* @internal
+*/
+connect_fn = function() {
+  __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _controller, new AbortController()), __privateGet(this, _fetch)(__privateGet(this, _url), __privateMethod(this, _EventSource_instances, getRequestOptions_fn).call(this)).then(__privateGet(this, _onFetchResponse)).catch(__privateGet(this, _onFetchError));
+}, _onFetchResponse = /* @__PURE__ */ new WeakMap(), _onFetchError = /* @__PURE__ */ new WeakMap(), /**
+* Get request options for the `fetch()` request
+*
+* @returns The request options
+* @internal
+*/
+getRequestOptions_fn = function() {
+  var _a;
+  let init = {
+    // [spec] Let `corsAttributeState` be `Anonymous`…
+    // [spec] …will have their mode set to "cors"…
+    mode: "cors",
+    redirect: "follow",
+    headers: { Accept: "text/event-stream", ...__privateGet(this, _lastEventId) ? { "Last-Event-ID": __privateGet(this, _lastEventId) } : void 0 },
+    cache: "no-store",
+    signal: (_a = __privateGet(this, _controller)) == null ? void 0 : _a.signal
+  };
+  return "window" in globalThis && (init.credentials = this.withCredentials ? "include" : "same-origin"), init;
+}, _onEvent = /* @__PURE__ */ new WeakMap(), _onRetryChange = /* @__PURE__ */ new WeakMap(), /**
+* Handles the process referred to in the EventSource specification as "failing a connection".
+*
+* @param error - The error causing the connection to fail
+* @param code - The HTTP status code, if available
+* @internal
+*/
+failConnection_fn = function(message, code) {
+  var _a;
+  __privateGet(this, _readyState) !== this.CLOSED && __privateSet(this, _readyState, this.CLOSED);
+  let errorEvent = new ErrorEvent("error", { code, message });
+  (_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent);
+}, /**
+* Schedules a reconnection attempt against the EventSource endpoint.
+*
+* @param message - The error causing the connection to fail
+* @param code - The HTTP status code, if available
+* @internal
+*/
+scheduleReconnect_fn = function(message, code) {
+  var _a;
+  if (__privateGet(this, _readyState) === this.CLOSED)
+    return;
+  __privateSet(this, _readyState, this.CONNECTING);
+  let errorEvent = new ErrorEvent("error", { code, message });
+  (_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent), __privateSet(this, _reconnectTimer, setTimeout(__privateGet(this, _reconnect), __privateGet(this, _reconnectInterval)));
+}, _reconnect = /* @__PURE__ */ new WeakMap(), /**
+* ReadyState representing an EventSource currently trying to connect
+*
+* @public
+*/
+EventSource.CONNECTING = 0, /**
+* ReadyState representing an EventSource connection that is open (eg connected)
+*
+* @public
+*/
+EventSource.OPEN = 1, /**
+* ReadyState representing an EventSource connection that is closed (eg disconnected)
+*
+* @public
+*/
+EventSource.CLOSED = 2;
+function getBaseURL() {
+  let doc = "document" in globalThis ? globalThis.document : void 0;
+  return doc && typeof doc == "object" && "baseURI" in doc && typeof doc.baseURI == "string" ? doc.baseURI : void 0;
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/sse.js
+var SseError = class extends Error {
+  constructor(code, message, event) {
+    super(`SSE error: ${message}`), this.code = code, this.event = event;
+  }
+}, SSEClientTransport = class {
+  constructor(url, opts) {
+    this._url = url, this._resourceMetadataUrl = void 0, this._scope = void 0, this._eventSourceInit = opts?.eventSourceInit, this._requestInit = opts?.requestInit, this._authProvider = opts?.authProvider, this._fetch = opts?.fetch, this._fetchWithInit = createFetchWithInit(opts?.fetch, opts?.requestInit);
+  }
+  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 (error) {
+      throw this.onerror?.(error), error;
+    }
+    if (result !== "AUTHORIZED")
+      throw new UnauthorizedError();
+    return await this._startOrAuth();
+  }
+  async _commonHeaders() {
+    let headers = {};
+    if (this._authProvider) {
+      let tokens = await this._authProvider.tokens();
+      tokens && (headers.Authorization = `Bearer ${tokens.access_token}`);
+    }
+    this._protocolVersion && (headers["mcp-protocol-version"] = this._protocolVersion);
+    let extraHeaders = normalizeHeaders(this._requestInit?.headers);
+    return new Headers({
+      ...headers,
+      ...extraHeaders
+    });
+  }
+  _startOrAuth() {
+    let fetchImpl = this?._eventSourceInit?.fetch ?? this._fetch ?? fetch;
+    return new Promise((resolve2, reject) => {
+      this._eventSource = new EventSource(this._url.href, {
+        ...this._eventSourceInit,
+        fetch: async (url, init) => {
+          let headers = await this._commonHeaders();
+          headers.set("Accept", "text/event-stream");
+          let response = await fetchImpl(url, {
+            ...init,
+            headers
+          });
+          if (response.status === 401 && response.headers.has("www-authenticate")) {
+            let { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
+            this._resourceMetadataUrl = resourceMetadataUrl, this._scope = scope;
+          }
+          return response;
+        }
+      }), this._abortController = new AbortController(), this._eventSource.onerror = (event) => {
+        if (event.code === 401 && this._authProvider) {
+          this._authThenStart().then(resolve2, reject);
+          return;
+        }
+        let error = new SseError(event.code, event.message, event);
+        reject(error), this.onerror?.(error);
+      }, this._eventSource.onopen = () => {
+      }, this._eventSource.addEventListener("endpoint", (event) => {
+        let messageEvent = event;
+        try {
+          if (this._endpoint = new URL(messageEvent.data, this._url), this._endpoint.origin !== this._url.origin)
+            throw new Error(`Endpoint origin does not match connection origin: ${this._endpoint.origin}`);
+        } catch (error) {
+          reject(error), this.onerror?.(error), this.close();
+          return;
+        }
+        resolve2();
+      }), this._eventSource.onmessage = (event) => {
+        let messageEvent = event, message;
+        try {
+          message = JSONRPCMessageSchema.parse(JSON.parse(messageEvent.data));
+        } catch (error) {
+          this.onerror?.(error);
+          return;
+        }
+        this.onmessage?.(message);
+      };
+    });
+  }
+  async start() {
+    if (this._eventSource)
+      throw new Error("SSEClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+    return await this._startOrAuth();
+  }
+  /**
+   * 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");
+    if (await auth(this._authProvider, {
+      serverUrl: this._url,
+      authorizationCode,
+      resourceMetadataUrl: this._resourceMetadataUrl,
+      scope: this._scope,
+      fetchFn: this._fetchWithInit
+    }) !== "AUTHORIZED")
+      throw new UnauthorizedError("Failed to authorize");
+  }
+  async close() {
+    this._abortController?.abort(), this._eventSource?.close(), this.onclose?.();
+  }
+  async send(message) {
+    if (!this._endpoint)
+      throw new Error("Not connected");
+    try {
+      let headers = await this._commonHeaders();
+      headers.set("content-type", "application/json");
+      let init = {
+        ...this._requestInit,
+        method: "POST",
+        headers,
+        body: JSON.stringify(message),
+        signal: this._abortController?.signal
+      }, response = await (this._fetch ?? fetch)(this._endpoint, init);
+      if (!response.ok) {
+        let text = await response.text().catch(() => null);
+        if (response.status === 401 && this._authProvider) {
+          let { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
+          if (this._resourceMetadataUrl = resourceMetadataUrl, this._scope = scope, await auth(this._authProvider, {
+            serverUrl: this._url,
+            resourceMetadataUrl: this._resourceMetadataUrl,
+            scope: this._scope,
+            fetchFn: this._fetchWithInit
+          }) !== "AUTHORIZED")
+            throw new UnauthorizedError();
+          return this.send(message);
+        }
+        throw new Error(`Error POSTing to endpoint (HTTP ${response.status}): ${text}`);
+      }
+      await response.body?.cancel();
+    } catch (error) {
+      throw this.onerror?.(error), error;
+    }
+  }
+  setProtocolVersion(version) {
+    this._protocolVersion = version;
+  }
+};
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/npx-resolver.js
+import { existsSync, readFileSync, realpathSync, readdirSync, statSync, writeFileSync, renameSync, mkdirSync, openSync, readSync, closeSync } from "node:fs";
+import { join, dirname, extname, resolve, sep } from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+var CACHE_VERSION = 1, CACHE_TTL_MS = 1440 * 60 * 1e3;
+async function resolveNpxBinary(command, args) {
+  let parsed = command === "npx" ? parseNpxArgs(args) : command === "npm" ? parseNpmExecArgs(args) : null;
+  if (!parsed)
+    return null;
+  let cacheKey = JSON.stringify([command, ...args]), cached = loadCache()?.entries?.[cacheKey];
+  if (cached && Date.now() - cached.resolvedAt < CACHE_TTL_MS && existsSync(cached.resolvedBin))
+    return { binPath: cached.resolvedBin, extraArgs: parsed.extraArgs, isJs: cached.isJs };
+  let resolved = resolveFromNpmCache(parsed.packageSpec, parsed.binName);
+  if (resolved)
+    return saveCacheEntry(cacheKey, resolved), { binPath: resolved.resolvedBin, extraArgs: parsed.extraArgs, isJs: resolved.isJs };
+  await forceNpxCache(parsed.packageSpec);
+  let resolvedAfterInstall = resolveFromNpmCache(parsed.packageSpec, parsed.binName);
+  return resolvedAfterInstall ? (saveCacheEntry(cacheKey, resolvedAfterInstall), { binPath: resolvedAfterInstall.resolvedBin, extraArgs: parsed.extraArgs, isJs: resolvedAfterInstall.isJs }) : null;
+}
+function parseNpxArgs(args) {
+  let separatorIndex = args.indexOf("--"), before = separatorIndex >= 0 ? args.slice(0, separatorIndex) : args, after = separatorIndex >= 0 ? args.slice(separatorIndex + 1) : [], positionals = [], packageSpec, sawPackageFlag = !1, foundFirstPositional = !1;
+  for (let i2 = 0; i2 < before.length; i2++) {
+    let arg = before[i2];
+    if (foundFirstPositional) {
+      positionals.push(arg);
+      continue;
+    }
+    if (!(arg === "-y" || arg === "--yes")) {
+      if (arg === "-p" || arg === "--package") {
+        let value = before[i2 + 1];
+        if (!value || value.startsWith("-"))
+          return null;
+        packageSpec || (packageSpec = value), sawPackageFlag = !0, i2++;
+        continue;
+      }
+      if (arg.startsWith("--package=")) {
+        let value = arg.slice(10);
+        if (!value)
+          return null;
+        packageSpec || (packageSpec = value), sawPackageFlag = !0;
+        continue;
+      }
+      if (arg.startsWith("-"))
+        return null;
+      positionals.push(arg), foundFirstPositional = !0;
+    }
+  }
+  let separatedAfter = separatorIndex >= 0 && after.length > 0 ? ["--", ...after] : after;
+  if (sawPackageFlag) {
+    let binName = positionals[0];
+    if (!packageSpec || !binName)
+      return null;
+    let extraArgs2 = positionals.slice(1).concat(separatedAfter);
+    return { packageSpec, binName, extraArgs: extraArgs2 };
+  }
+  let packagePositional = positionals[0];
+  if (!packagePositional)
+    return null;
+  let extraArgs = positionals.slice(1).concat(separatedAfter);
+  return { packageSpec: packagePositional, extraArgs };
+}
+function parseNpmExecArgs(args) {
+  if (args[0] !== "exec")
+    return null;
+  let execArgs = args.slice(1), separatorIndex = execArgs.indexOf("--");
+  if (separatorIndex < 0)
+    return null;
+  let before = execArgs.slice(0, separatorIndex), after = execArgs.slice(separatorIndex + 1), packageSpec;
+  for (let i2 = 0; i2 < before.length; i2++) {
+    let arg = before[i2];
+    if (!(arg === "-y" || arg === "--yes")) {
+      if (arg === "--package") {
+        let value = before[i2 + 1];
+        if (!value || value.startsWith("-"))
+          return null;
+        packageSpec || (packageSpec = value), i2++;
+        continue;
+      }
+      if (arg.startsWith("--package=")) {
+        let value = arg.slice(10);
+        if (!value)
+          return null;
+        packageSpec || (packageSpec = value);
+        continue;
+      }
+      if (arg.startsWith("-"))
+        return null;
+    }
+  }
+  let binName = after[0];
+  if (!packageSpec || !binName)
+    return null;
+  let extraArgs = after.slice(1);
+  return { packageSpec, binName, extraArgs };
+}
+function resolveFromNpmCache(packageSpec, binName) {
+  let cacheDir = getNpmCacheDir();
+  if (!cacheDir)
+    return null;
+  let packageName = extractPackageName(packageSpec);
+  if (!packageName)
+    return null;
+  let packageDir = findCachedPackageDir(cacheDir, packageName);
+  if (!packageDir)
+    return null;
+  let packageJsonPath = join(packageDir, "package.json");
+  if (!existsSync(packageJsonPath))
+    return null;
+  let pkg = null;
+  try {
+    pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  let binField = pkg?.bin;
+  if (!binField)
+    return null;
+  let candidates = buildBinCandidates(packageName, binName), chosenBinName, binRel;
+  if (typeof binField == "string")
+    chosenBinName = defaultBinName(packageName), binRel = binField;
+  else {
+    for (let candidate of candidates)
+      if (binField[candidate]) {
+        chosenBinName = candidate, binRel = binField[candidate];
+        break;
+      }
+    if (!binRel) {
+      let firstEntry = Object.entries(binField)[0];
+      firstEntry && (chosenBinName = firstEntry[0], binRel = firstEntry[1]);
+    }
+  }
+  if (!binRel)
+    return null;
+  let nodeModulesDir = findNodeModulesDir(packageDir), binLink = chosenBinName ? join(nodeModulesDir, ".bin", chosenBinName) : null, resolvedBin = binLink && existsSync(binLink) ? safeRealpath(binLink) : "";
+  if (!resolvedBin && (resolvedBin = resolve(packageDir, binRel), !existsSync(resolvedBin)))
+    return null;
+  let isJs = detectJsBinary(resolvedBin);
+  return {
+    resolvedBin,
+    resolvedAt: Date.now(),
+    packageVersion: pkg?.version,
+    isJs
+  };
+}
+var FORCE_CACHE_TIMEOUT_MS = 3e4;
+async function forceNpxCache(packageSpec) {
+  try {
+    await new Promise((resolve2, reject) => {
+      let proc = spawn("npm", ["exec", "--yes", "--package", packageSpec, "--", "node", "-e", "1"], { stdio: "ignore" }), timer = setTimeout(() => {
+        proc.kill(), reject(new Error("timeout"));
+      }, FORCE_CACHE_TIMEOUT_MS);
+      timer.unref(), proc.on("close", () => {
+        clearTimeout(timer), resolve2();
+      }), proc.on("error", (err) => {
+        clearTimeout(timer), reject(err);
+      });
+    });
+  } catch {
+  }
+}
+function buildBinCandidates(packageName, explicitBin) {
+  let candidates = [];
+  if (explicitBin && candidates.push(explicitBin), packageName.startsWith("@")) {
+    let namePart = packageName.split("/")[1] ?? "", scopePart = packageName.split("/")[0]?.replace("@", "") ?? "";
+    namePart && candidates.push(namePart), scopePart && namePart && candidates.push(`${scopePart}-${namePart}`);
+  } else
+    candidates.push(packageName);
+  return [...new Set(candidates.filter(Boolean))];
+}
+function extractPackageName(spec) {
+  let trimmed = spec.trim();
+  if (!trimmed)
+    return null;
+  if (trimmed.startsWith("@")) {
+    let slashIndex = trimmed.indexOf("/");
+    if (slashIndex < 0)
+      return null;
+    let atIndex2 = trimmed.lastIndexOf("@");
+    return atIndex2 > slashIndex ? trimmed.slice(0, atIndex2) : trimmed;
+  }
+  let atIndex = trimmed.indexOf("@");
+  return atIndex >= 0 ? trimmed.slice(0, atIndex) : trimmed;
+}
+function defaultBinName(packageName) {
+  return packageName.startsWith("@") ? packageName.split("/")[1] ?? packageName.replace("@", "").replace("/", "-") : packageName;
+}
+function findCachedPackageDir(cacheDir, packageName) {
+  let npxDir = join(cacheDir, "_npx");
+  if (!existsSync(npxDir))
+    return null;
+  let packagePathParts = packageName.startsWith("@") ? packageName.split("/") : [packageName], candidates = readdirSync(npxDir, { withFileTypes: !0 }).filter((entry) => entry.isDirectory()).map((entry) => {
+    let full = join(npxDir, entry.name), mtime = safeStatMtime(full);
+    return { name: entry.name, mtime };
+  }).sort((a2, b2) => b2.mtime - a2.mtime);
+  for (let entry of candidates) {
+    let pkgDir = join(npxDir, entry.name, "node_modules", ...packagePathParts);
+    if (existsSync(join(pkgDir, "package.json")))
+      return pkgDir;
+  }
+  return null;
+}
+function findNodeModulesDir(packageDir) {
+  let parts = packageDir.split(sep), idx = parts.lastIndexOf("node_modules");
+  return idx >= 0 ? parts.slice(0, idx + 1).join(sep) : join(packageDir, "..");
+}
+function detectJsBinary(binPath) {
+  let ext = extname(binPath).toLowerCase();
+  if (ext === ".js" || ext === ".mjs" || ext === ".cjs")
+    return !0;
+  try {
+    let fd = openSync(binPath, "r");
+    try {
+      let buf = Buffer.alloc(256);
+      readSync(fd, buf, 0, 256, 0);
+      let firstLine = buf.toString("utf-8").split(`
+`)[0] ?? "";
+      return firstLine.startsWith("#!") && firstLine.includes("node");
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return !1;
+  }
+}
+var npmCacheDirCached;
+function getNpmCacheDir() {
+  if (npmCacheDirCached !== void 0)
+    return npmCacheDirCached;
+  if (process.env.NPM_CONFIG_CACHE)
+    return npmCacheDirCached = process.env.NPM_CONFIG_CACHE, npmCacheDirCached;
+  try {
+    let result = spawnSync("npm", ["config", "get", "cache"], { encoding: "utf-8" });
+    if (result.status === 0)
+      return npmCacheDirCached = String(result.stdout).trim() || null, npmCacheDirCached;
+  } catch {
+    return npmCacheDirCached = null, null;
+  }
+  return npmCacheDirCached = null, null;
+}
+function getNpxCachePath() {
+  return getAgentPath("mcp-npx-cache.json");
+}
+function loadCache() {
+  let cachePath = getNpxCachePath();
+  if (!existsSync(cachePath))
+    return null;
+  try {
+    let raw = JSON.parse(readFileSync(cachePath, "utf-8"));
+    return !raw || typeof raw != "object" || raw.version !== CACHE_VERSION || !raw.entries || typeof raw.entries != "object" ? null : raw;
+  } catch {
+    return null;
+  }
+}
+function saveCacheEntry(key, entry) {
+  let cachePath = getNpxCachePath(), dir = dirname(cachePath);
+  mkdirSync(dir, { recursive: !0 });
+  let merged = { version: CACHE_VERSION, entries: {} };
+  try {
+    if (existsSync(cachePath)) {
+      let existing = JSON.parse(readFileSync(cachePath, "utf-8"));
+      existing && existing.version === CACHE_VERSION && existing.entries && (merged.entries = { ...existing.entries });
+    }
+  } catch {
+  }
+  merged.entries[key] = entry;
+  let tmpPath = `${cachePath}.${process.pid}.tmp`;
+  writeFileSync(tmpPath, JSON.stringify(merged, null, 2), "utf-8"), renameSync(tmpPath, cachePath);
+}
+function safeRealpath(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return "";
+  }
+}
+function safeStatMtime(path) {
+  try {
+    return statSync(path).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/sampling-handler.js
+import { complete } from "@ashx-j/lunr-ai/compat";
+function registerSamplingHandler(client, options) {
+  client.setRequestHandler(CreateMessageRequestSchema, (request) => handleSamplingRequest(options, request));
+}
+async function handleSamplingRequest(options, request) {
+  let params = request.params;
+  if ("task" in params && params.task)
+    throw new Error("MCP sampling tasks are not supported");
+  if (params.includeContext && params.includeContext !== "none")
+    throw new Error("MCP sampling context inclusion is not supported");
+  if (params.tools?.length)
+    throw new Error("MCP sampling tool use is not supported");
+  if (params.toolChoice)
+    throw new Error("MCP sampling tool choice is not supported");
+  if (params.stopSequences?.length)
+    throw new Error("MCP sampling stop sequences are not supported");
+  let messages = params.messages.map(convertSamplingMessage), { model, apiKey, headers } = await resolveSamplingModel(options, params.modelPreferences);
+  await confirmSampling(options, "Approve MCP sampling request", formatRequestApproval(options.serverName, `${model.provider}/${model.id}`, params.systemPrompt, messages));
+  let result = await complete(model, {
+    systemPrompt: params.systemPrompt,
+    messages
+  }, {
+    apiKey,
+    headers,
+    maxTokens: params.maxTokens,
+    temperature: params.temperature,
+    metadata: params.metadata,
+    signal: options.getSignal()
+  }), converted = convertAssistantResult(result);
+  return await confirmSampling(options, "Return MCP sampling response", formatResponseApproval(options.serverName, converted)), converted;
+}
+function formatRequestApproval(serverName, modelName, systemPrompt, messages) {
+  let lines = [`${serverName} wants to sample ${messages.length} message${messages.length === 1 ? "" : "s"} with ${modelName}.`];
+  systemPrompt && lines.push(`System: ${truncateAtWord(systemPrompt, 400)}`);
+  for (let [index, message] of messages.entries())
+    lines.push(`${index + 1}. ${message.role}: ${truncateAtWord(messageText(message), 400)}`);
+  return lines.join(`
+
+`);
+}
+function formatResponseApproval(serverName, response) {
+  let text = response.content.type === "text" ? response.content.text : `[${response.content.type} content]`;
+  return `${serverName} will receive this response from ${response.model}:
+
+${truncateAtWord(text, 1e3)}`;
+}
+function messageText(message) {
+  return typeof message.content == "string" ? message.content : message.content.map((block) => block.type === "text" ? block.text : block.type === "image" ? `[image: ${block.mimeType}]` : block.type === "thinking" ? "[thinking]" : block.type === "toolCall" ? `[tool call: ${block.name}]` : "[content]").join(`
+`);
+}
+async function resolveSamplingModel(options, modelPreferences) {
+  let candidates = [], availableModels = options.modelRegistry.getAvailable();
+  for (let hint of modelPreferences?.hints ?? []) {
+    let normalizedHint = hint.name?.trim().toLowerCase();
+    if (normalizedHint)
+      for (let model of availableModels)
+        [`${model.provider}/${model.id}`, model.id, model.name].some((name) => name.toLowerCase().includes(normalizedHint)) && addSamplingCandidate(candidates, model);
+  }
+  let currentModel = options.getCurrentModel();
+  currentModel && addSamplingCandidate(candidates, currentModel);
+  for (let model of availableModels)
+    addSamplingCandidate(candidates, model);
+  let errors = [];
+  for (let model of candidates) {
+    let auth2 = await options.modelRegistry.getApiKeyAndHeaders(model);
+    if (auth2.ok === !1) {
+      errors.push(`${model.provider}/${model.id}: ${auth2.error}`);
+      continue;
+    }
+    return { model, apiKey: auth2.apiKey, headers: auth2.headers };
+  }
+  throw errors.length > 0 ? new Error(`No configured auth for MCP sampling model. ${errors.join("; ")}`) : new Error("No Pi model is available for MCP sampling");
+}
+function addSamplingCandidate(candidates, model) {
+  candidates.some((candidate) => candidate.provider === model.provider && candidate.id === model.id) || candidates.push(model);
+}
+async function confirmSampling(options, title, message) {
+  if (options.autoApprove)
+    return;
+  if (!options.ui)
+    throw new Error("MCP sampling requires interactive approval. Set settings.samplingAutoApprove to true to allow it without UI.");
+  if (!await options.ui.confirm(title, message))
+    throw new Error("MCP sampling request was declined");
+}
+function convertSamplingMessage(message) {
+  let blocks = Array.isArray(message.content) ? message.content : [message.content];
+  return message.role === "user" ? {
+    role: "user",
+    content: blocks.map(convertUserContent),
+    timestamp: Date.now()
+  } : {
+    role: "assistant",
+    content: blocks.map(convertAssistantContent),
+    api: "mcp-sampling",
+    provider: "mcp",
+    model: "sampling-request",
+    usage: zeroUsage(),
+    stopReason: "stop",
+    timestamp: Date.now()
+  };
+}
+function convertUserContent(block) {
+  if (block.type === "text")
+    return { type: "text", text: block.text };
+  throw new Error(`MCP sampling ${block.type} content is not supported`);
+}
+function convertAssistantContent(block) {
+  if (block.type === "text")
+    return { type: "text", text: block.text };
+  throw new Error(`MCP sampling assistant ${block.type} content is not supported`);
+}
+function convertAssistantResult(message) {
+  if (message.stopReason === "error")
+    throw new Error(message.errorMessage ?? "MCP sampling model call failed");
+  if (message.stopReason === "aborted")
+    throw new Error(message.errorMessage ?? "MCP sampling model call was aborted");
+  let text = message.content.map((block) => {
+    if (block.type === "text")
+      return block.text;
+    if (block.type !== "thinking")
+      throw new Error(`MCP sampling result ${block.type} content is not supported`);
+  }).filter((value) => value !== void 0).join(`
+
+`).trim();
+  if (!text)
+    throw new Error("MCP sampling result did not contain text content");
+  return {
+    role: "assistant",
+    content: { type: "text", text },
+    model: `${message.provider}/${message.model}`,
+    stopReason: mapStopReason(message.stopReason)
+  };
+}
+function mapStopReason(reason) {
+  return reason === "stop" ? "endTurn" : reason === "length" ? "maxTokens" : reason === "toolUse" ? "toolUse" : reason;
+}
+function zeroUsage() {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      total: 0
+    }
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/elicitation-handler.js
+import open from "open";
+function registerElicitationHandler(client, options) {
+  client.setRequestHandler(ElicitRequestSchema, (request) => handleElicitationRequest(options, request));
+}
+async function handleElicitationRequest(options, request) {
+  return request.params.mode === "url" ? handleUrlElicitation(options, request.params) : handleFormElicitation(options, request.params);
+}
+async function handleFormElicitation(options, params) {
+  let decision = await options.ui.select(`MCP Input Request
+Server: ${options.serverName}
+
+${params.message}`, ["Continue", "Decline"]);
+  if (decision === void 0)
+    return { action: "cancel" };
+  if (decision === "Decline")
+    return { action: "decline" };
+  let values = {}, properties = Object.entries(params.requestedSchema.properties);
+  for (let [name, schema] of properties) {
+    let value = await collectValidField(options.ui, params, name, schema);
+    if (!("value" in value))
+      return { action: "cancel" };
+    values[name] = value.value;
+  }
+  for (; ; ) {
+    let content = coerceAndValidateFormValues(params, values), action = await options.ui.select(formatReview(options.serverName, properties, content), properties.length > 0 ? ["Submit", "Edit", "Decline"] : ["Submit", "Decline"]);
+    if (action === void 0)
+      return { action: "cancel" };
+    if (action === "Decline")
+      return { action: "decline" };
+    if (action === "Submit")
+      return { action: "accept", content };
+    let labels = properties.map(([name2, schema2]) => `${schema2.title ?? humanizeName(name2)} (${name2})`), selected = await options.ui.select("Choose a field to edit", labels);
+    if (selected === void 0)
+      return { action: "cancel" };
+    let property = properties[labels.indexOf(selected)];
+    if (!property)
+      continue;
+    let [name, schema] = property, value = await collectValidField(options.ui, params, name, schema, values[name]);
+    if (!("value" in value))
+      return { action: "cancel" };
+    values[name] = value.value;
+  }
+}
+async function collectValidField(ui, params, name, schema, current) {
+  let required = params.requestedSchema.required?.includes(name) === !0;
+  for (; ; ) {
+    let result = await collectField(ui, params, name, schema, current);
+    if (!("value" in result))
+      return result;
+    try {
+      return coerceAndValidateFormValues({
+        ...params,
+        requestedSchema: {
+          type: "object",
+          properties: { [name]: schema },
+          ...required ? { required: [name] } : {}
+        }
+      }, { [name]: result.value }), result;
+    } catch (error) {
+      ui.notify(error instanceof Error ? error.message : String(error), "error"), current = result.value;
+    }
+  }
+}
+async function collectField(ui, params, name, schema, current) {
+  let required = params.requestedSchema.required?.includes(name) === !0, title = [schema.title ?? humanizeName(name), required ? "(required)" : "", schema.description].filter(Boolean).join(" ");
+  if (schema.type === "string" && ("enum" in schema || "oneOf" in schema)) {
+    let choices = "oneOf" in schema ? schema.oneOf.map((option) => ({ value: option.const, display: formatChoice(option.const, option.title) })) : schema.enum.map((value, index) => ({
+      value,
+      display: formatChoice(value, "enumNames" in schema ? schema.enumNames?.[index] : void 0)
+    })), displays = uniqueLabels(choices.map((choice) => choice.display)), actions2 = [...displays], useDefault = schema.default === void 0 ? void 0 : uniqueAction("Use default", actions2);
+    useDefault && actions2.push(useDefault);
+    let omit = required ? void 0 : uniqueAction("Omit", actions2);
+    omit && actions2.push(omit);
+    let action2 = await ui.select(title, actions2);
+    return action2 === void 0 ? { cancelled: !0 } : action2 === useDefault ? { cancelled: !1, value: schema.default } : action2 === omit ? { cancelled: !1, value: void 0 } : { cancelled: !1, value: choices[displays.indexOf(action2)]?.value };
+  }
+  if (schema.type === "boolean") {
+    let actions2 = ["Yes", "No"];
+    schema.default !== void 0 && actions2.push("Use default"), required || actions2.push("Omit");
+    let action2 = await ui.select(title, actions2);
+    return action2 === void 0 ? { cancelled: !0 } : action2 === "Use default" ? { cancelled: !1, value: schema.default } : action2 === "Omit" ? { cancelled: !1, value: void 0 } : { cancelled: !1, value: action2 === "Yes" };
+  }
+  if (schema.type === "array") {
+    let actions2 = ["Choose values"];
+    schema.default !== void 0 && actions2.push("Use default"), required || actions2.push("Omit");
+    let action2 = await ui.select(title, actions2);
+    if (action2 === void 0)
+      return { cancelled: !0 };
+    if (action2 === "Use default")
+      return { cancelled: !1, value: schema.default };
+    if (action2 === "Omit")
+      return { cancelled: !1, value: void 0 };
+    let choices = extractMultiSelectOptions(schema), selected = new Set(Array.isArray(current) ? current : []);
+    for (; ; ) {
+      let displays = uniqueLabels(choices.map((choice2) => selected.has(choice2.value) ? `\u2713 ${choice2.display}` : choice2.display)), done = uniqueAction("Done", displays), picked = await ui.select(title, [...displays, done]);
+      if (picked === void 0)
+        return { cancelled: !0 };
+      if (picked === done)
+        return { cancelled: !1, value: [...selected] };
+      let choice = choices[displays.indexOf(picked)];
+      choice && (selected.has(choice.value) ? selected.delete(choice.value) : selected.add(choice.value));
+    }
+  }
+  let actions = ["Enter value"];
+  schema.default !== void 0 && actions.push("Use default"), required || actions.push("Omit");
+  let action = await ui.select(title, actions);
+  if (action === void 0)
+    return { cancelled: !0 };
+  if (action === "Use default")
+    return { cancelled: !1, value: schema.default };
+  if (action === "Omit")
+    return { cancelled: !1, value: void 0 };
+  let entered = await ui.input(title, current === void 0 ? void 0 : String(current));
+  return entered === void 0 ? { cancelled: !0 } : { cancelled: !1, value: entered };
+}
+function coerceAndValidateFormValues(params, values) {
+  let output = {}, required = new Set(params.requestedSchema.required ?? []);
+  for (let [name, schema] of Object.entries(params.requestedSchema.properties)) {
+    let value = values[name];
+    if (value === void 0) {
+      if (required.has(name))
+        throw new Error(`Missing required elicitation field: ${name}`);
+      continue;
+    }
+    if (schema.type === "string") {
+      let stringValue = String(value), limits = schema;
+      if (limits.minLength !== void 0 && stringValue.length < limits.minLength)
+        throw new Error(`Elicitation field ${name} is shorter than minimum length ${limits.minLength}`);
+      if (limits.maxLength !== void 0 && stringValue.length > limits.maxLength)
+        throw new Error(`Elicitation field ${name} is longer than maximum length ${limits.maxLength}`);
+      if ("enum" in schema && !schema.enum.includes(stringValue))
+        throw new Error(`Elicitation field ${name} is not an allowed value`);
+      if ("oneOf" in schema && !schema.oneOf.some((option) => option.const === stringValue))
+        throw new Error(`Elicitation field ${name} is not an allowed value`);
+      output[name] = stringValue;
+      continue;
+    }
+    if (schema.type === "number" || schema.type === "integer") {
+      if (typeof value == "string" && value.trim() === "")
+        throw new Error(`Elicitation field ${name} must be a number`);
+      let numberValue = typeof value == "number" ? value : Number(value);
+      if (!Number.isFinite(numberValue))
+        throw new Error(`Elicitation field ${name} must be a number`);
+      if (schema.type === "integer" && !Number.isInteger(numberValue))
+        throw new Error(`Elicitation field ${name} must be an integer`);
+      if (schema.minimum !== void 0 && numberValue < schema.minimum)
+        throw new Error(`Elicitation field ${name} is below minimum ${schema.minimum}`);
+      if (schema.maximum !== void 0 && numberValue > schema.maximum)
+        throw new Error(`Elicitation field ${name} is above maximum ${schema.maximum}`);
+      output[name] = numberValue;
+      continue;
+    }
+    if (schema.type === "boolean") {
+      output[name] = typeof value == "boolean" ? value : value === "true";
+      continue;
+    }
+    if (schema.type === "array") {
+      if (!Array.isArray(value))
+        throw new Error(`Elicitation field ${name} must be a list`);
+      let allowed = new Set(extractMultiSelectOptions(schema).map((option) => option.value)), arrayValue = value.map(String);
+      if (schema.minItems !== void 0 && arrayValue.length < schema.minItems)
+        throw new Error(`Elicitation field ${name} has fewer than ${schema.minItems} selections`);
+      if (schema.maxItems !== void 0 && arrayValue.length > schema.maxItems)
+        throw new Error(`Elicitation field ${name} has more than ${schema.maxItems} selections`);
+      if (arrayValue.some((item) => !allowed.has(item)))
+        throw new Error(`Elicitation field ${name} contains an invalid selection`);
+      output[name] = arrayValue;
+    }
+  }
+  let validation = new AjvJsonSchemaValidator().getValidator(params.requestedSchema)(output);
+  if (!validation.valid)
+    throw new Error(`Invalid elicitation response: ${validation.errorMessage}`);
+  return output;
+}
+function formatChoice(value, title) {
+  return title && title !== value ? `${title} (${value})` : value;
+}
+function uniqueLabels(labels) {
+  let used = /* @__PURE__ */ new Set();
+  return labels.map((label) => {
+    let unique = label;
+    for (; used.has(unique); )
+      unique += "\u2026";
+    return used.add(unique), unique;
+  });
+}
+function uniqueAction(label, choices) {
+  let unique = label;
+  for (; choices.includes(unique); )
+    unique += "\u2026";
+  return unique;
+}
+function extractMultiSelectOptions(schema) {
+  let items = schema.items;
+  return items.anyOf ? items.anyOf.map((option) => ({ value: option.const, display: formatChoice(option.const, option.title) })) : (items.enum ?? []).map((value) => ({ value, display: value }));
+}
+function formatReview(serverName, properties, content) {
+  let rows = properties.map(([name, schema]) => `${schema.title ?? humanizeName(name)}: ${content[name] === void 0 ? "(omitted)" : String(content[name])}`);
+  return [`Review input for ${serverName}`, "", ...rows].join(`
+`);
+}
+async function handleUrlElicitation(options, params) {
+  if (!options.allowUrl)
+    throw new McpError(ErrorCode.InvalidParams, "URL elicitation is not supported");
+  let parsed;
+  try {
+    parsed = new URL(params.url);
+  } catch {
+    throw new McpError(ErrorCode.InvalidParams, "URL elicitation supplied an invalid URL");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+    throw new McpError(ErrorCode.InvalidParams, "URL elicitation only supports HTTP and HTTPS URLs");
+  let decision = await options.ui.select([
+    "MCP Browser Request",
+    `Server: ${options.serverName}`,
+    "",
+    params.message,
+    "",
+    `Host: ${parsed.host}`,
+    `Full URL: ${params.url}`,
+    "",
+    "Open this URL in your browser?"
+  ].join(`
+`), ["Open", "Decline"]);
+  if (decision === void 0)
+    return { action: "cancel" };
+  if (decision === "Decline")
+    return { action: "decline" };
+  try {
+    await open(params.url);
+  } catch (error) {
+    return options.ui.notify(`Could not open MCP elicitation URL: ${error instanceof Error ? error.message : String(error)}`, "error"), { action: "cancel" };
+  }
+  return options.onUrlAccepted?.(params.elicitationId), options.ui.notify("Opened browser for MCP elicitation.", "info"), { action: "accept" };
+}
+function humanizeName(name) {
+  return name.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/^./, (char) => char.toUpperCase());
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/server-manager.js
+var McpServerManager = class {
+  defaultCwd;
+  connections = /* @__PURE__ */ new Map();
+  connectPromises = /* @__PURE__ */ new Map();
+  pendingConnections = /* @__PURE__ */ new Map();
+  closing = !1;
+  uiStreamListeners = /* @__PURE__ */ new Map();
+  samplingConfig;
+  elicitationConfig;
+  acceptedUrlElicitations = /* @__PURE__ */ new Map();
+  defaultRequestTimeoutMs;
+  /** Default cwd for stdio servers without an explicit config `cwd`. */
+  constructor(defaultCwd) {
+    this.defaultCwd = defaultCwd;
+  }
+  setSamplingConfig(config) {
+    this.samplingConfig = config;
+  }
+  setElicitationConfig(config) {
+    this.elicitationConfig = config;
+  }
+  setDefaultRequestTimeoutMs(timeoutMs) {
+    this.defaultRequestTimeoutMs = normalizeRequestTimeoutMs(timeoutMs);
+  }
+  getRequestOptions(name, signal) {
+    let connection = this.connections.get(name);
+    return this.buildRequestOptions(connection?.definition, signal);
+  }
+  getResolvedRequestTimeoutMs(definition) {
+    return definition?.requestTimeoutMs !== void 0 ? normalizeRequestTimeoutMs(definition.requestTimeoutMs) : this.defaultRequestTimeoutMs;
+  }
+  buildRequestOptions(definition, signal) {
+    let timeout = this.getResolvedRequestTimeoutMs(definition);
+    if (!(!signal && timeout === void 0))
+      return {
+        ...signal ? { signal } : {},
+        ...timeout !== void 0 ? { timeout } : {}
+      };
+  }
+  async connect(name, definition, signal) {
+    if (throwIfAborted(signal), this.closing)
+      throw new Error("MCP server manager is closed");
+    if (this.connectPromises.has(name))
+      return abortable(this.connectPromises.get(name), signal);
+    let existing = this.connections.get(name);
+    if (existing?.status === "connected")
+      return existing.lastUsedAt = Date.now(), existing;
+    let promise = this.createConnection(name, definition, signal).then(async (connection) => {
+      if (this.closing || signal?.aborted)
+        throw await this.disposeConnection(connection), throwIfAborted(signal), new Error("MCP server manager closed during connection");
+      return this.connections.set(name, connection), connection;
+    });
+    this.connectPromises.set(name, promise);
+    try {
+      return await promise;
+    } finally {
+      this.connectPromises.get(name) === promise && this.connectPromises.delete(name);
+    }
+  }
+  async createConnection(name, definition, signal) {
+    throwIfAborted(signal);
+    let client = this.createClient(name), transport;
+    if (definition.command) {
+      let command = definition.command, args = definition.args ?? [];
+      if (command === "npx" || command === "npm") {
+        let resolved = await resolveNpxBinary(command, args);
+        resolved && (command = resolved.isJs ? "node" : resolved.binPath, args = resolved.isJs ? [resolved.binPath, ...resolved.extraArgs] : resolved.extraArgs, logger.debug(`${name} resolved to ${resolved.binPath} (skipping npm parent)`));
+      }
+      transport = new StdioClientTransport({
+        command,
+        args,
+        env: resolveEnv(definition.env),
+        cwd: resolveConfigPath(definition.cwd) ?? this.defaultCwd,
+        stderr: definition.debug ? "inherit" : "ignore"
+      });
+    } else if (definition.url)
+      transport = await this.createHttpTransport(definition, name, signal);
+    else
+      throw new Error(`Server ${name} has no command or url`);
+    let requestOptions = this.buildRequestOptions(definition, signal), pending = { client, transport };
+    this.pendingConnections.set(name, pending);
+    try {
+      await client.connect(transport, requestOptions), this.attachAdapterNotificationHandlers(name, client);
+      let [tools, resources] = await Promise.all([
+        this.fetchAllTools(client, requestOptions),
+        this.fetchAllResources(client, requestOptions)
+      ]);
+      return {
+        client,
+        transport,
+        definition,
+        tools,
+        resources,
+        lastUsedAt: Date.now(),
+        inFlight: 0,
+        status: "connected"
+      };
+    } catch (error) {
+      if (error instanceof UnauthorizedError && supportsOAuth(definition))
+        return await client.close().catch(() => {
+        }), await transport.close().catch(() => {
+        }), {
+          client,
+          transport,
+          definition,
+          tools: [],
+          resources: [],
+          lastUsedAt: Date.now(),
+          inFlight: 0,
+          status: "needs-auth"
+        };
+      throw await client.close().catch(() => {
+      }), await transport.close().catch(() => {
+      }), error;
+    } finally {
+      this.pendingConnections.get(name) === pending && this.pendingConnections.delete(name);
+    }
+  }
+  buildClientCapabilities() {
+    return {
+      ...this.samplingConfig ? { sampling: {} } : {},
+      ...this.elicitationConfig ? {
+        elicitation: {
+          form: {},
+          ...this.elicitationConfig.allowUrl ? { url: {} } : {}
+        }
+      } : {}
+    };
+  }
+  createClient(serverName) {
+    let capabilities = this.buildClientCapabilities(), client = new Client({ name: `pi-mcp-${serverName}`, version: "1.0.0" }, Object.keys(capabilities).length > 0 ? { capabilities } : void 0);
+    return this.samplingConfig && registerSamplingHandler(client, { ...this.samplingConfig, serverName }), this.elicitationConfig && (registerElicitationHandler(client, {
+      ...this.elicitationConfig,
+      serverName,
+      onUrlAccepted: (elicitationId) => this.rememberUrlElicitation(serverName, elicitationId)
+    }), this.elicitationConfig.allowUrl && client.setNotificationHandler(ElicitationCompleteNotificationSchema, (notification) => {
+      this.acceptedUrlElicitations.get(serverName)?.delete(notification.params.elicitationId) && this.elicitationConfig?.ui.notify(`MCP browser interaction for ${serverName} completed. You can retry the tool now.`, "info");
+    })), client;
+  }
+  async handleUrlElicitationRequired(serverName, error) {
+    if (!this.elicitationConfig?.allowUrl)
+      return "cancel";
+    for (let params of error.elicitations) {
+      let result = await handleUrlElicitation({
+        ...this.elicitationConfig,
+        serverName,
+        onUrlAccepted: (elicitationId) => this.rememberUrlElicitation(serverName, elicitationId)
+      }, params);
+      if (result.action !== "accept")
+        return result.action;
+    }
+    return "accept";
+  }
+  rememberUrlElicitation(serverName, elicitationId) {
+    let accepted = this.acceptedUrlElicitations.get(serverName);
+    accepted || (accepted = /* @__PURE__ */ new Set(), this.acceptedUrlElicitations.set(serverName, accepted)), accepted.add(elicitationId);
+  }
+  async createHttpTransport(definition, serverName, signal) {
+    throwIfAborted(signal);
+    let url = new URL(definition.url), headers = resolveHeaders(definition.headers) ?? {};
+    if (definition.auth === "bearer") {
+      let token = resolveBearerToken(definition);
+      token && (headers.Authorization = `Bearer ${token}`);
+    }
+    let requestInit = Object.keys(headers).length > 0 ? { headers } : void 0, authProvider;
+    if (supportsOAuth(definition)) {
+      let oauthConfig = extractOAuthConfig(definition);
+      authProvider = new McpOAuthProvider(serverName, definition.url, oauthConfig, {
+        onRedirect: async (_authUrl) => {
+        }
+      });
+    }
+    let streamableTransport = new StreamableHTTPClientTransport(url, {
+      requestInit,
+      authProvider
+    });
+    try {
+      let testClient = new Client({ name: "pi-mcp-probe", version: "2.1.2" });
+      return await testClient.connect(streamableTransport, this.buildRequestOptions(definition, signal)), await testClient.close().catch(() => {
+      }), await streamableTransport.close().catch(() => {
+      }), new StreamableHTTPClientTransport(url, { requestInit, authProvider });
+    } catch (error) {
+      if (await streamableTransport.close().catch(() => {
+      }), signal?.aborted && throwIfAborted(signal), error instanceof UnauthorizedError)
+        throw error;
+      return new SSEClientTransport(url, { requestInit, authProvider });
+    }
+  }
+  async fetchAllTools(client, requestOptions) {
+    let allTools = [], cursor;
+    do {
+      let result = await client.listTools(cursor ? { cursor } : void 0, requestOptions);
+      allTools.push(...result.tools ?? []), cursor = result.nextCursor;
+    } while (cursor);
+    return allTools;
+  }
+  async fetchAllResources(client, requestOptions) {
+    try {
+      let allResources = [], cursor;
+      do {
+        let result = await client.listResources(cursor ? { cursor } : void 0, requestOptions);
+        allResources.push(...result.resources ?? []), cursor = result.nextCursor;
+      } while (cursor);
+      return allResources;
+    } catch {
+      return requestOptions?.signal?.aborted && throwIfAborted(requestOptions.signal), [];
+    }
+  }
+  attachAdapterNotificationHandlers(serverName, client) {
+    client.setNotificationHandler(serverStreamResultPatchNotificationSchema, (notification) => {
+      let listener = this.uiStreamListeners.get(notification.params.streamToken);
+      listener && listener(serverName, notification.params);
+    });
+  }
+  registerUiStreamListener(streamToken, listener) {
+    this.uiStreamListeners.set(streamToken, listener);
+  }
+  removeUiStreamListener(streamToken) {
+    this.uiStreamListeners.delete(streamToken);
+  }
+  async readResource(name, uri, signal) {
+    let connection = this.connections.get(name);
+    if (!connection || connection.status !== "connected")
+      throw new Error(`Server "${name}" is not connected`);
+    try {
+      return this.touch(name), this.incrementInFlight(name), await connection.client.readResource({ uri }, this.getRequestOptions(name, signal));
+    } finally {
+      this.decrementInFlight(name), this.touch(name);
+    }
+  }
+  async disposeConnection(connection) {
+    await connection.client.close().catch(() => {
+    }), await connection.transport.close().catch(() => {
+    });
+  }
+  async close(name) {
+    let connection = this.connections.get(name);
+    connection && (connection.status = "closed", this.connections.delete(name), this.acceptedUrlElicitations.delete(name), await this.disposeConnection(connection));
+  }
+  async closeAll() {
+    this.closing = !0;
+    let names = [...this.connections.keys()], pending = [...this.pendingConnections.values()];
+    await Promise.all([
+      ...names.map((name) => this.close(name)),
+      ...pending.map((connection) => this.disposeConnection(connection))
+    ]);
+  }
+  getConnection(name) {
+    return this.connections.get(name);
+  }
+  getAllConnections() {
+    return new Map(this.connections);
+  }
+  touch(name) {
+    let connection = this.connections.get(name);
+    connection && (connection.lastUsedAt = Date.now());
+  }
+  incrementInFlight(name) {
+    let connection = this.connections.get(name);
+    connection && (connection.inFlight = (connection.inFlight ?? 0) + 1);
+  }
+  decrementInFlight(name) {
+    let connection = this.connections.get(name);
+    connection && connection.inFlight && connection.inFlight--;
+  }
+  isIdle(name, timeoutMs) {
+    let connection = this.connections.get(name);
+    return !connection || connection.status !== "connected" || connection.inFlight > 0 ? !1 : Date.now() - connection.lastUsedAt > timeoutMs;
+  }
+};
+function resolveEnv(env) {
+  let resolved = {};
+  for (let [key, value] of Object.entries(process.env))
+    value !== void 0 && (resolved[key] = value);
+  if (!env)
+    return resolved;
+  let overrides = interpolateEnvRecord(env);
+  return overrides ? { ...resolved, ...overrides } : resolved;
+}
+function resolveHeaders(headers) {
+  return interpolateEnvRecord(headers);
+}
+function normalizeRequestTimeoutMs(timeoutMs) {
+  return typeof timeoutMs == "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : void 0;
+}
+
+// node_modules/@modelcontextprotocol/ext-apps/dist/src/app-bridge.js
+var ZQ = ((X) => typeof __require < "u" ? __require : typeof Proxy < "u" ? new Proxy(X, { get: (Y, Z) => (typeof __require < "u" ? __require : Y)[Z] }) : X)(function(X) {
+  if (typeof __require < "u") return __require.apply(this, arguments);
+  throw Error('Dynamic require of "' + X + '" is not supported');
+});
+var r = external_exports.union([external_exports.literal("light"), external_exports.literal("dark")]).describe("Color theme preference for the host environment."), B = external_exports.union([external_exports.literal("inline"), external_exports.literal("fullscreen"), external_exports.literal("pip")]).describe("Display mode for UI presentation."), HQ = external_exports.union([external_exports.literal("--color-background-primary"), external_exports.literal("--color-background-secondary"), external_exports.literal("--color-background-tertiary"), external_exports.literal("--color-background-inverse"), external_exports.literal("--color-background-ghost"), external_exports.literal("--color-background-info"), external_exports.literal("--color-background-danger"), external_exports.literal("--color-background-success"), external_exports.literal("--color-background-warning"), external_exports.literal("--color-background-disabled"), external_exports.literal("--color-text-primary"), external_exports.literal("--color-text-secondary"), external_exports.literal("--color-text-tertiary"), external_exports.literal("--color-text-inverse"), external_exports.literal("--color-text-ghost"), external_exports.literal("--color-text-info"), external_exports.literal("--color-text-danger"), external_exports.literal("--color-text-success"), external_exports.literal("--color-text-warning"), external_exports.literal("--color-text-disabled"), external_exports.literal("--color-border-primary"), external_exports.literal("--color-border-secondary"), external_exports.literal("--color-border-tertiary"), external_exports.literal("--color-border-inverse"), external_exports.literal("--color-border-ghost"), external_exports.literal("--color-border-info"), external_exports.literal("--color-border-danger"), external_exports.literal("--color-border-success"), external_exports.literal("--color-border-warning"), external_exports.literal("--color-border-disabled"), external_exports.literal("--color-ring-primary"), external_exports.literal("--color-ring-secondary"), external_exports.literal("--color-ring-inverse"), external_exports.literal("--color-ring-info"), external_exports.literal("--color-ring-danger"), external_exports.literal("--color-ring-success"), external_exports.literal("--color-ring-warning"), external_exports.literal("--font-sans"), external_exports.literal("--font-mono"), external_exports.literal("--font-weight-normal"), external_exports.literal("--font-weight-medium"), external_exports.literal("--font-weight-semibold"), external_exports.literal("--font-weight-bold"), external_exports.literal("--font-text-xs-size"), external_exports.literal("--font-text-sm-size"), external_exports.literal("--font-text-md-size"), external_exports.literal("--font-text-lg-size"), external_exports.literal("--font-heading-xs-size"), external_exports.literal("--font-heading-sm-size"), external_exports.literal("--font-heading-md-size"), external_exports.literal("--font-heading-lg-size"), external_exports.literal("--font-heading-xl-size"), external_exports.literal("--font-heading-2xl-size"), external_exports.literal("--font-heading-3xl-size"), external_exports.literal("--font-text-xs-line-height"), external_exports.literal("--font-text-sm-line-height"), external_exports.literal("--font-text-md-line-height"), external_exports.literal("--font-text-lg-line-height"), external_exports.literal("--font-heading-xs-line-height"), external_exports.literal("--font-heading-sm-line-height"), external_exports.literal("--font-heading-md-line-height"), external_exports.literal("--font-heading-lg-line-height"), external_exports.literal("--font-heading-xl-line-height"), external_exports.literal("--font-heading-2xl-line-height"), external_exports.literal("--font-heading-3xl-line-height"), external_exports.literal("--border-radius-xs"), external_exports.literal("--border-radius-sm"), external_exports.literal("--border-radius-md"), external_exports.literal("--border-radius-lg"), external_exports.literal("--border-radius-xl"), external_exports.literal("--border-radius-full"), external_exports.literal("--border-width-regular"), external_exports.literal("--shadow-hairline"), external_exports.literal("--shadow-sm"), external_exports.literal("--shadow-md"), external_exports.literal("--shadow-lg")]).describe("CSS variable keys available to MCP apps for theming."), RQ = external_exports.record(HQ.describe(`Style variables for theming MCP apps.
+
+Individual style keys are optional - hosts may provide any subset of these values.
+Values are strings containing CSS values (colors, sizes, font stacks, etc.).
+
+Note: This type uses \`Record<K, string | undefined>\` rather than \`Partial<Record<K, string>>\`
+for compatibility with Zod schema generation. Both are functionally equivalent for validation.`), external_exports.union([external_exports.string(), external_exports.undefined()]).describe(`Style variables for theming MCP apps.
+
+Individual style keys are optional - hosts may provide any subset of these values.
+Values are strings containing CSS values (colors, sizes, font stacks, etc.).
+
+Note: This type uses \`Record<K, string | undefined>\` rather than \`Partial<Record<K, string>>\`
+for compatibility with Zod schema generation. Both are functionally equivalent for validation.`)).describe(`Style variables for theming MCP apps.
+
+Individual style keys are optional - hosts may provide any subset of these values.
+Values are strings containing CSS values (colors, sizes, font stacks, etc.).
+
+Note: This type uses \`Record<K, string | undefined>\` rather than \`Partial<Record<K, string>>\`
+for compatibility with Zod schema generation. Both are functionally equivalent for validation.`), L = external_exports.object({ method: external_exports.literal("ui/open-link"), params: external_exports.object({ url: external_exports.string().describe("URL to open in the host's browser") }) }), P = external_exports.object({ isError: external_exports.boolean().optional().describe("True if the host failed to open the URL (e.g., due to security policy).") }).passthrough(), A = external_exports.object({ isError: external_exports.boolean().optional().describe("True if the download failed (e.g., user cancelled or host denied).") }).passthrough(), U = external_exports.object({ isError: external_exports.boolean().optional().describe("True if the host rejected or failed to deliver the message.") }).passthrough(), w = external_exports.object({ method: external_exports.literal("ui/notifications/sandbox-proxy-ready"), params: external_exports.object({}) }), O = external_exports.object({ connectDomains: external_exports.array(external_exports.string()).optional().describe(`Origins for network requests (fetch/XHR/WebSocket).
+
+- Maps to CSP \`connect-src\` directive
+- Empty or omitted \u2192 no network connections (secure default)`), resourceDomains: external_exports.array(external_exports.string()).optional().describe("Origins for static resources (images, scripts, stylesheets, fonts, media).\n\n- Maps to CSP `img-src`, `script-src`, `style-src`, `font-src`, `media-src` directives\n- Wildcard subdomains supported: `https://*.example.com`\n- Empty or omitted \u2192 no network resources (secure default)"), frameDomains: external_exports.array(external_exports.string()).optional().describe("Origins for nested iframes.\n\n- Maps to CSP `frame-src` directive\n- Empty or omitted \u2192 no nested iframes allowed (`frame-src 'none'`)"), baseUriDomains: external_exports.array(external_exports.string()).optional().describe("Allowed base URIs for the document.\n\n- Maps to CSP `base-uri` directive\n- Empty or omitted \u2192 only same origin allowed (`base-uri 'self'`)") }), z = external_exports.object({ camera: external_exports.object({}).optional().describe("Request camera access.\n\nMaps to Permission Policy `camera` feature."), microphone: external_exports.object({}).optional().describe("Request microphone access.\n\nMaps to Permission Policy `microphone` feature."), geolocation: external_exports.object({}).optional().describe("Request geolocation access.\n\nMaps to Permission Policy `geolocation` feature."), clipboardWrite: external_exports.object({}).optional().describe("Request clipboard write access.\n\nMaps to Permission Policy `clipboard-write` feature.") }), H = external_exports.object({ method: external_exports.literal("ui/notifications/size-changed"), params: external_exports.object({ width: external_exports.number().optional().describe("New width in pixels."), height: external_exports.number().optional().describe("New height in pixels.") }) }), R = external_exports.object({ method: external_exports.literal("ui/notifications/tool-input"), params: external_exports.object({ arguments: external_exports.record(external_exports.string(), external_exports.unknown().describe("Complete tool call arguments as key-value pairs.")).optional().describe("Complete tool call arguments as key-value pairs.") }) }), T = external_exports.object({ method: external_exports.literal("ui/notifications/tool-input-partial"), params: external_exports.object({ arguments: external_exports.record(external_exports.string(), external_exports.unknown().describe("Partial tool call arguments (incomplete, may change).")).optional().describe("Partial tool call arguments (incomplete, may change).") }) }), M = external_exports.object({ method: external_exports.literal("ui/notifications/tool-cancelled"), params: external_exports.object({ reason: external_exports.string().optional().describe('Optional reason for the cancellation (e.g., "user action", "timeout").') }) }), o = external_exports.object({ fonts: external_exports.string().optional() }), s = external_exports.object({ variables: RQ.optional().describe("CSS variables for theming the app."), css: o.optional().describe("CSS blocks that apps can inject.") }), C = external_exports.object({ method: external_exports.literal("ui/resource-teardown"), params: external_exports.object({}) }), S = external_exports.record(external_exports.string(), external_exports.unknown()), F = external_exports.object({ text: external_exports.object({}).optional().describe("Host supports text content blocks."), image: external_exports.object({}).optional().describe("Host supports image content blocks."), audio: external_exports.object({}).optional().describe("Host supports audio content blocks."), resource: external_exports.object({}).optional().describe("Host supports resource content blocks."), resourceLink: external_exports.object({}).optional().describe("Host supports resource link content blocks."), structuredContent: external_exports.object({}).optional().describe("Host supports structured content.") }), q = external_exports.object({ method: external_exports.literal("ui/notifications/request-teardown"), params: external_exports.object({}).optional() }), t = external_exports.object({ experimental: external_exports.object({}).optional().describe("Experimental features (structure TBD)."), openLinks: external_exports.object({}).optional().describe("Host supports opening external URLs."), downloadFile: external_exports.object({}).optional().describe("Host supports file downloads via ui/download-file."), serverTools: external_exports.object({ listChanged: external_exports.boolean().optional().describe("Host supports tools/list_changed notifications.") }).optional().describe("Host can proxy tool calls to the MCP server."), serverResources: external_exports.object({ listChanged: external_exports.boolean().optional().describe("Host supports resources/list_changed notifications.") }).optional().describe("Host can proxy resource reads to the MCP server."), logging: external_exports.object({}).optional().describe("Host accepts log messages."), sandbox: external_exports.object({ permissions: z.optional().describe("Permissions granted by the host (camera, microphone, geolocation)."), csp: O.optional().describe("CSP domains approved by the host.") }).optional().describe("Sandbox configuration applied by the host."), updateModelContext: F.optional().describe("Host accepts context updates (ui/update-model-context) to be included in the model's context for future turns."), message: F.optional().describe("Host supports receiving content messages (ui/message) from the view."), sampling: external_exports.object({ tools: external_exports.object({}).optional().describe("Host supports tool use via `tools` and `toolChoice` parameters.") }).optional().describe("Host supports LLM sampling (sampling/createMessage) from the view.\nMirrors the MCP `ClientCapabilities.sampling` shape so hosts can pass it through.") }), a = external_exports.object({ experimental: external_exports.object({}).optional().describe("Experimental features (structure TBD)."), tools: external_exports.object({ listChanged: external_exports.boolean().optional().describe("App supports tools/list_changed notifications.") }).optional().describe("App exposes MCP-style tools that the host can call."), availableDisplayModes: external_exports.array(B).optional().describe("Display modes the app supports.") }), y = external_exports.object({ method: external_exports.literal("ui/notifications/initialized"), params: external_exports.object({}).optional() }), TQ = external_exports.object({ csp: O.optional().describe("Content Security Policy configuration for UI resources."), permissions: z.optional().describe("Sandbox permissions requested by the UI resource."), domain: external_exports.string().optional().describe(`Dedicated origin for view sandbox.
+
+Useful when views need stable, dedicated origins for OAuth callbacks, CORS policies, or API key allowlists.
+
+**Host-dependent:** The format and validation rules for this field are determined by each host. Servers MUST consult host-specific documentation for the expected domain format. Common patterns include:
+- Hash-based subdomains (e.g., \`{hash}.claudemcpcontent.com\`)
+- URL-derived subdomains (e.g., \`www-example-com.oaiusercontent.com\`)
+
+If omitted, host uses default sandbox origin (typically per-conversation).`), prefersBorder: external_exports.boolean().optional().describe(`Visual boundary preference - true if view prefers a visible border.
+
+Boolean requesting whether a visible border and background is provided by the host. Specifying an explicit value for this is recommended because hosts' defaults may vary.
+
+- \`true\`: request visible border + background
+- \`false\`: request no visible border + background
+- omitted: host decides border`) }), I = external_exports.object({ method: external_exports.literal("ui/request-display-mode"), params: external_exports.object({ mode: B.describe("The display mode being requested.") }) }), g = external_exports.object({ mode: B.describe("The display mode that was actually set. May differ from requested if not supported.") }).passthrough(), e = external_exports.union([external_exports.literal("model"), external_exports.literal("app")]).describe("Tool visibility scope - who can access the tool."), MQ = external_exports.object({ resourceUri: external_exports.string().optional(), visibility: external_exports.array(e).optional().describe(`Who can access this tool. Default: ["model", "app"]
+- "model": Tool visible to and callable by the agent
+- "app": Tool callable by the app from this server only`), csp: external_exports.never().optional(), permissions: external_exports.never().optional() }), OX = external_exports.object({ mimeTypes: external_exports.array(external_exports.string()).optional().describe('Array of supported MIME types for UI resources.\nMust include `"text/html;profile=mcp-app"` for MCP Apps support.') }), f = external_exports.object({ method: external_exports.literal("ui/download-file"), params: external_exports.object({ contents: external_exports.array(external_exports.union([EmbeddedResourceSchema, ResourceLinkSchema])).describe("Resource contents to download \u2014 embedded (inline data) or linked (host fetches). Uses standard MCP resource types.") }) }), k = external_exports.object({ method: external_exports.literal("ui/message"), params: external_exports.object({ role: external_exports.literal("user").describe('Message role, currently only "user" is supported.'), content: external_exports.array(ContentBlockSchema).describe("Message content blocks (text, image, etc.).") }) }), CQ = external_exports.object({ method: external_exports.literal("ui/notifications/sandbox-resource-ready"), params: external_exports.object({ html: external_exports.string().describe("HTML content to load into the inner iframe."), sandbox: external_exports.string().optional().describe("Optional override for the inner iframe's sandbox attribute."), csp: O.optional().describe("CSP configuration from resource metadata."), permissions: z.optional().describe("Sandbox permissions from resource metadata.") }) }), v = external_exports.object({ method: external_exports.literal("ui/notifications/tool-result"), params: CallToolResultSchema.describe("Standard MCP tool execution result.") }), x = external_exports.object({ toolInfo: external_exports.object({ id: RequestIdSchema.optional().describe("JSON-RPC id of the tools/call request."), tool: ToolSchema.describe("Tool definition including name, inputSchema, etc.") }).optional().describe("Metadata of the tool call that instantiated this App."), theme: r.optional().describe("Current color theme preference."), styles: s.optional().describe("Style configuration for theming the app."), displayMode: B.optional().describe("How the UI is currently displayed."), availableDisplayModes: external_exports.array(B).optional().describe("Display modes the host supports."), containerDimensions: external_exports.union([external_exports.object({ height: external_exports.number().describe("Fixed container height in pixels.") }), external_exports.object({ maxHeight: external_exports.union([external_exports.number(), external_exports.undefined()]).optional().describe("Maximum container height in pixels.") })]).and(external_exports.union([external_exports.object({ width: external_exports.number().describe("Fixed container width in pixels.") }), external_exports.object({ maxWidth: external_exports.union([external_exports.number(), external_exports.undefined()]).optional().describe("Maximum container width in pixels.") })])).optional().describe(`Container dimensions. Represents the dimensions of the iframe or other
+container holding the app. Specify either width or maxWidth, and either height or maxHeight.`), locale: external_exports.string().optional().describe("User's language and region preference in BCP 47 format."), timeZone: external_exports.string().optional().describe("User's timezone in IANA format."), userAgent: external_exports.string().optional().describe("Host application identifier."), platform: external_exports.union([external_exports.literal("web"), external_exports.literal("desktop"), external_exports.literal("mobile")]).optional().describe("Platform type for responsive design decisions."), deviceCapabilities: external_exports.object({ touch: external_exports.boolean().optional().describe("Whether the device supports touch input."), hover: external_exports.boolean().optional().describe("Whether the device supports hover interactions.") }).optional().describe("Device input capabilities."), safeAreaInsets: external_exports.object({ top: external_exports.number().describe("Top safe area inset in pixels."), right: external_exports.number().describe("Right safe area inset in pixels."), bottom: external_exports.number().describe("Bottom safe area inset in pixels."), left: external_exports.number().describe("Left safe area inset in pixels.") }).optional().describe("Mobile safe area boundaries in pixels.") }).passthrough(), b = external_exports.object({ method: external_exports.literal("ui/notifications/host-context-changed"), params: x.describe("Partial context update containing only changed fields.") }), d = external_exports.object({ method: external_exports.literal("ui/update-model-context"), params: external_exports.object({ content: external_exports.array(ContentBlockSchema).optional().describe("Context content blocks (text, image, etc.)."), structuredContent: external_exports.record(external_exports.string(), external_exports.unknown().describe("Structured content for machine-readable context data.")).optional().describe("Structured content for machine-readable context data.") }) }), u = external_exports.object({ method: external_exports.literal("ui/initialize"), params: external_exports.object({ appInfo: ImplementationSchema.describe("App identification (name and version)."), appCapabilities: a.describe("Features and capabilities this app provides."), protocolVersion: external_exports.string().describe("Protocol version this app supports.") }) }), h = external_exports.object({ protocolVersion: external_exports.string().describe('Negotiated protocol version string (e.g., "2025-11-21").'), hostInfo: ImplementationSchema.describe("Host application identification and version."), hostCapabilities: t.describe("Features and capabilities provided by the host."), hostContext: x.describe("Rich context about the host environment.") }).passthrough();
+var i = "ui/resourceUri", pQ = "text/html;profile=mcp-app";
+function FZ(X) {
+  let Z = X._meta?.ui?.resourceUri;
+  if (Z === void 0 && (Z = X._meta?.[i]), typeof Z == "string" && Z.startsWith("ui://")) return Z;
+  if (Z !== void 0) throw Error(`Invalid UI resource URI: ${JSON.stringify(Z)}`);
+}
+function AZ(X) {
+  if (!X) return "";
+  let Y = [];
+  return X.camera && Y.push("camera"), X.microphone && Y.push("microphone"), X.geolocation && Y.push("geolocation"), X.clipboardWrite && Y.push("clipboard-write"), Y.join("; ");
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/tool-metadata.js
+function buildToolMetadata(tools, resources, definition, serverName, prefix) {
+  let metadata = [], failedTools = [];
+  for (let tool of tools) {
+    if (!tool?.name) {
+      failedTools.push("(unnamed)");
+      continue;
+    }
+    if (isToolExcluded(tool.name, serverName, prefix, definition.excludeTools))
+      continue;
+    let uiResourceUri;
+    try {
+      uiResourceUri = FZ({ _meta: tool._meta });
+    } catch {
+      failedTools.push(tool.name);
+    }
+    metadata.push({
+      name: formatToolName(tool.name, serverName, prefix),
+      originalName: tool.name,
+      description: tool.description ?? "",
+      inputSchema: tool.inputSchema,
+      uiResourceUri,
+      uiStreamMode: extractToolUiStreamMode(tool._meta)
+    });
+  }
+  if (definition.exposeResources !== !1)
+    for (let resource of resources) {
+      let baseName = `get_${resourceNameToToolName(resource.name)}`;
+      isToolExcluded(baseName, serverName, prefix, definition.excludeTools) || metadata.push({
+        name: formatToolName(baseName, serverName, prefix),
+        originalName: baseName,
+        description: resource.description ?? `Read resource: ${resource.uri}`,
+        resourceUri: resource.uri
+      });
+    }
+  return { metadata, failedTools };
+}
+function getToolNames(state, serverName) {
+  return state.toolMetadata.get(serverName)?.map((m) => m.name) ?? [];
+}
+function totalToolCount(state) {
+  let count = 0;
+  for (let metadata of state.toolMetadata.values())
+    count += metadata.length;
+  return count;
+}
+function findToolByName(metadata, toolName) {
+  if (!metadata)
+    return;
+  let exact = metadata.find((m) => m.name === toolName);
+  if (exact)
+    return exact;
+  let normalized = toolName.replace(/-/g, "_");
+  return metadata.find((m) => m.name.replace(/-/g, "_") === normalized);
+}
+function formatSchema(schema, indent = "  ") {
+  if (!schema || typeof schema != "object" || Array.isArray(schema))
+    return `${indent}(no schema)`;
+  let s2 = schema;
+  if (s2.type === "object" && s2.properties && typeof s2.properties == "object" && !Array.isArray(s2.properties)) {
+    let props = s2.properties, required = Array.isArray(s2.required) ? s2.required.filter((name) => typeof name == "string") : [];
+    if (Object.keys(props).length === 0)
+      return `${indent}(no parameters)`;
+    let lines2 = [];
+    for (let [name, propSchema] of Object.entries(props))
+      lines2.push(...formatProperty(name, propSchema, required.includes(name), indent));
+    return lines2.join(`
+`);
+  }
+  let lines = formatNestedSchema(s2, indent);
+  if (lines.length > 0)
+    return lines.join(`
+`);
+  let typeStr = formatType(s2);
+  return typeStr ? `${indent}(${typeStr})` : `${indent}(complex schema)`;
+}
+function formatProperty(name, schema, required, indent) {
+  if (!schema || typeof schema != "object" || Array.isArray(schema))
+    return [`${indent}${name}${required ? " *required*" : ""}`];
+  let s2 = schema, parts = [`${indent}${name}`], typeStr = formatType(s2);
+  return typeStr && parts.push(`(${typeStr})`), required && parts.push("*required*"), appendSchemaAnnotations(parts, s2), [parts.join(" "), ...formatNestedSchema(s2, `${indent}  `)];
+}
+function formatNestedSchema(schema, indent) {
+  let lines = [];
+  if (Array.isArray(schema.anyOf) && lines.push(...formatVariants("anyOf", schema.anyOf, indent)), Array.isArray(schema.oneOf) && lines.push(...formatVariants("oneOf", schema.oneOf, indent)), schema.items !== void 0 && lines.push(...formatProperty("items", schema.items, !1, indent)), schema.properties && typeof schema.properties == "object" && !Array.isArray(schema.properties)) {
+    let required = Array.isArray(schema.required) ? schema.required.filter((name) => typeof name == "string") : [];
+    for (let [name, propSchema] of Object.entries(schema.properties))
+      lines.push(...formatProperty(name, propSchema, required.includes(name), indent));
+  }
+  return lines;
+}
+function formatVariants(keyword, variants, indent) {
+  let lines = [`${indent}${keyword}:`];
+  for (let variant of variants) {
+    if (!variant || typeof variant != "object" || Array.isArray(variant)) {
+      lines.push(`${indent}  - ${JSON.stringify(variant)}`);
+      continue;
+    }
+    let s2 = variant, typeStr = formatType(s2) || "schema", parts = [`${indent}  - ${typeStr}`];
+    appendSchemaAnnotations(parts, s2), lines.push(parts.join(" ")), lines.push(...formatNestedSchema(s2, `${indent}    `));
+  }
+  return lines;
+}
+function formatType(schema) {
+  return Object.hasOwn(schema, "const") ? `const ${JSON.stringify(schema.const)}` : Array.isArray(schema.enum) ? `enum: ${schema.enum.map((v2) => JSON.stringify(v2)).join(", ")}` : Array.isArray(schema.type) ? schema.type.map((type) => String(type)).join(" | ") : schema.type ? String(schema.type) : schema.properties && typeof schema.properties == "object" && !Array.isArray(schema.properties) ? "object" : schema.items !== void 0 ? "array" : "";
+}
+function appendSchemaAnnotations(parts, schema) {
+  schema.description && typeof schema.description == "string" && parts.push(`- ${schema.description}`);
+  for (let key of ["minLength", "maxLength", "minimum", "maximum", "minItems", "maxItems", "format", "pattern"])
+    schema[key] !== void 0 && parts.push(`[${key}: ${JSON.stringify(schema[key])}]`);
+  schema.default !== void 0 && parts.push(`[default: ${JSON.stringify(schema.default)}]`);
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/ui-resource-handler.js
+var UiResourceHandler = class {
+  manager;
+  log = logger.child({ component: "UiResourceHandler" });
+  constructor(manager) {
+    this.manager = manager;
+  }
+  async readUiResource(serverName, uri) {
+    let log = this.log.child({ server: serverName, uri });
+    if (!uri.startsWith("ui://"))
+      throw new ResourceParseError(uri, "URI must start with ui://", { server: serverName });
+    log.debug("Fetching UI resource");
+    let result;
+    try {
+      result = await this.manager.readResource(serverName, uri);
+    } catch (error) {
+      if (error instanceof UrlElicitationRequiredError)
+        throw error;
+      let message = error instanceof Error ? error.message : String(error);
+      throw log.error("Failed to read resource", error instanceof Error ? error : void 0), new ResourceFetchError(uri, message, {
+        server: serverName,
+        cause: error instanceof Error ? error : void 0
+      });
+    }
+    let content = selectContent(result, uri), mimeType = content.mimeType;
+    if (mimeType && !isHtmlMimeType(mimeType))
+      throw log.warn("Unsupported MIME type", { mimeType }), new ResourceParseError(uri, `unsupported MIME type "${mimeType}" (expected text/html or ${pQ})`, { server: serverName, mimeType });
+    let html = toHtml(content);
+    if (!html.trim())
+      throw log.warn("Resource content is empty"), new ResourceParseError(uri, "content is empty", { server: serverName });
+    let contentMeta = extractUiMeta(content._meta), listMeta = extractUiMeta(this.getListResourceMeta(serverName, uri));
+    return log.debug("Resource loaded successfully", {
+      contentLength: html.length,
+      hasCsp: !!contentMeta.csp || !!listMeta.csp
+    }), {
+      uri: content.uri ?? uri,
+      html,
+      mimeType: mimeType ?? pQ,
+      meta: {
+        csp: contentMeta.csp ?? listMeta.csp,
+        permissions: contentMeta.permissions ?? listMeta.permissions,
+        domain: contentMeta.domain ?? listMeta.domain,
+        prefersBorder: contentMeta.prefersBorder ?? listMeta.prefersBorder
+      }
+    };
+  }
+  getListResourceMeta(serverName, uri) {
+    let connection = this.manager.getConnection(serverName);
+    if (!connection?.resources?.length)
+      return;
+    let resource = connection.resources.find((entry) => entry.uri === uri);
+    if (!(!resource || !resource._meta || typeof resource._meta != "object"))
+      return resource._meta;
+  }
+};
+function selectContent(result, preferredUri) {
+  let contents = result.contents ?? [];
+  if (contents.length === 0)
+    throw new Error(`No contents returned for UI resource: ${preferredUri}`);
+  let byUri = contents.find((content) => content.uri === preferredUri);
+  if (byUri)
+    return byUri;
+  let byHtmlMime = contents.find((content) => content.mimeType && isHtmlMimeType(content.mimeType));
+  return byHtmlMime || contents[0];
+}
+function isHtmlMimeType(mimeType) {
+  let normalized = mimeType.toLowerCase();
+  return normalized.startsWith("text/html") || normalized === pQ.toLowerCase();
+}
+function toHtml(content) {
+  if (typeof content.text == "string")
+    return content.text;
+  if (typeof content.blob == "string")
+    return Buffer.from(content.blob, "base64").toString("utf-8");
+  throw new Error(`UI resource ${content.uri ?? "(unknown)"} did not include text or blob content`);
+}
+function extractUiMeta(meta) {
+  if (!meta || typeof meta != "object")
+    return {};
+  let ui = meta.ui;
+  if (!ui || typeof ui != "object")
+    return {};
+  let out = {};
+  return ui.csp && typeof ui.csp == "object" && (out.csp = ui.csp), ui.permissions && typeof ui.permissions == "object" && (out.permissions = ui.permissions), typeof ui.domain == "string" && (out.domain = ui.domain), typeof ui.prefersBorder == "boolean" && (out.prefersBorder = ui.prefersBorder), out;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/init.js
+var FAILURE_BACKOFF_MS = 60 * 1e3;
+function isTuiMode(ctx) {
+  return ctx.hasUI && ctx.mode === "tui";
+}
+async function initializeMcp(pi, ctx, options = {}) {
+  let signal = options.signal ?? ctx.signal;
+  throwIfAborted(signal);
+  let configPath = pi.getFlag("mcp-config"), config = loadMcpConfig(configPath, ctx.cwd), manager = new McpServerManager(ctx.cwd);
+  manager.setDefaultRequestTimeoutMs(config.settings?.requestTimeoutMs);
+  let samplingAutoApprove = config.settings?.samplingAutoApprove === !0;
+  config.settings?.sampling !== !1 && (ctx.hasUI || samplingAutoApprove) && manager.setSamplingConfig({
+    autoApprove: samplingAutoApprove,
+    ui: ctx.hasUI ? ctx.ui : void 0,
+    modelRegistry: ctx.modelRegistry,
+    getCurrentModel: () => ctx.model,
+    getSignal: () => ctx.signal
+  }), config.settings?.elicitation !== !1 && ctx.hasUI && manager.setElicitationConfig({
+    ui: ctx.ui,
+    allowUrl: isTuiMode(ctx)
+  });
+  let lifecycle = new McpLifecycleManager(manager), toolMetadata = /* @__PURE__ */ new Map(), failureTracker = /* @__PURE__ */ new Map(), uiResourceHandler = new UiResourceHandler(manager), consentManager = new ConsentManager("once-per-server"), ui = ctx.hasUI ? ctx.ui : void 0, state = {
+    manager,
+    lifecycle,
+    toolMetadata,
+    config,
+    failureTracker,
+    uiResourceHandler,
+    consentManager,
+    uiServer: null,
+    completedUiSessions: [],
+    openBrowser: (url) => openUrl(pi, url, process.env.BROWSER),
+    ui,
+    sendMessage: (message, options2) => pi.sendMessage(message, options2)
+  };
+  options.onState?.(state);
+  let serverEntries = Object.entries(config.mcpServers);
+  if (serverEntries.length === 0)
+    return state;
+  let idleSetting = typeof config.settings?.idleTimeout == "number" ? config.settings.idleTimeout : 10;
+  lifecycle.setGlobalIdleTimeout(idleSetting);
+  let cachePath = getMetadataCachePath(), cacheFileExists = existsSync2(cachePath), cache = loadMetadataCache(), bootstrapAll = !1;
+  cacheFileExists ? cache || (cache = { version: 1, servers: {} }, saveMetadataCache(cache)) : (bootstrapAll = !0, saveMetadataCache({ version: 1, servers: {} }));
+  let prefix = config.settings?.toolPrefix ?? "server";
+  for (let [name, definition] of serverEntries) {
+    let lifecycleMode = definition.lifecycle ?? "lazy", idleOverride = definition.idleTimeout ?? (lifecycleMode === "eager" ? 0 : void 0);
+    if (lifecycle.registerServer(name, definition, idleOverride !== void 0 ? { idleTimeout: idleOverride } : void 0), lifecycleMode === "keep-alive" && lifecycle.markKeepAlive(name, definition), cache?.servers?.[name] && isServerCacheValid(cache.servers[name], definition)) {
+      let metadata = reconstructToolMetadata(name, cache.servers[name], prefix, definition);
+      toolMetadata.set(name, metadata);
+    }
+  }
+  let startupServers = bootstrapAll ? serverEntries : serverEntries.filter(([, definition]) => {
+    let mode = definition.lifecycle ?? "lazy";
+    return mode === "keep-alive" || mode === "eager";
+  });
+  ctx.hasUI && startupServers.length > 0 && ctx.ui.setStatus("mcp", `MCP: connecting to ${startupServers.length} servers...`);
+  let results = await parallelLimit(startupServers, 10, async ([name, definition]) => {
+    try {
+      throwIfAborted(signal);
+      let connection = await manager.connect(name, definition, signal);
+      return connection.status === "needs-auth" ? { name, definition, connection: null, error: `OAuth authentication required. Run /mcp-auth ${name}.` } : { name, definition, connection, error: null };
+    } catch (error) {
+      let message = error instanceof Error ? error.message : String(error);
+      return { name, definition, connection: null, error: message };
+    }
+  });
+  throwIfAborted(signal);
+  for (let { name, definition, connection, error } of results) {
+    if (error || !connection) {
+      ctx.hasUI && ctx.ui.notify(`MCP: Failed to connect to ${name}: ${error}`, "error"), console.error(`MCP: Failed to connect to ${name}: ${error}`);
+      continue;
+    }
+    let { metadata, failedTools } = buildToolMetadata(connection.tools, connection.resources, definition, name, prefix);
+    toolMetadata.set(name, metadata), updateMetadataCache(state, name), failedTools.length > 0 && ctx.hasUI && ctx.ui.notify(`MCP: ${name} - ${failedTools.length} tools skipped`, "warning");
+  }
+  let connectedCount = results.filter((r2) => r2.connection).length, failedCount = results.filter((r2) => r2.error).length;
+  if (ctx.hasUI && connectedCount > 0) {
+    let totalTools = totalToolCount(state), msg = failedCount > 0 ? `MCP: ${connectedCount}/${startupServers.length} servers connected (${totalTools} tools)` : `MCP: ${connectedCount} servers connected (${totalTools} tools)`;
+    ctx.ui.notify(msg, "info");
+  }
+  if (process.env.MCP_DIRECT_TOOLS !== "__none__") {
+    let currentCache = loadMetadataCache(), missingCacheServers = getMissingConfiguredDirectToolServers(config, currentCache);
+    if (missingCacheServers.length > 0) {
+      let bootstrapResults = await parallelLimit(missingCacheServers.filter((name) => !results.some((r2) => r2.name === name && r2.connection)), 10, async (name) => {
+        let definition = config.mcpServers[name];
+        try {
+          throwIfAborted(signal);
+          let connection = await manager.connect(name, definition, signal);
+          if (connection.status === "needs-auth")
+            return { name, ok: !1 };
+          let { metadata } = buildToolMetadata(connection.tools, connection.resources, definition, name, prefix);
+          return toolMetadata.set(name, metadata), updateMetadataCache(state, name), { name, ok: !0 };
+        } catch (error) {
+          let message = error instanceof Error ? error.message : String(error);
+          return logger.debug(`MCP: direct-tools bootstrap failed for ${name}: ${message}`), { name, ok: !1 };
+        }
+      });
+      throwIfAborted(signal);
+      let bootstrapped = bootstrapResults.filter((r2) => r2.ok).map((r2) => r2.name);
+      bootstrapped.length > 0 && ctx.hasUI && ctx.ui.notify(`MCP: direct tools for ${bootstrapped.join(", ")} will be available after restart`, "info");
+    }
+  }
+  return lifecycle.setReconnectCallback((serverName) => {
+    updateServerMetadata(state, serverName), updateMetadataCache(state, serverName), state.failureTracker.delete(serverName), updateStatusBar(state);
+  }), lifecycle.setIdleShutdownCallback((serverName) => {
+    let idleMinutes = getEffectiveIdleTimeoutMinutes(state, serverName);
+    logger.debug(`${serverName} shut down (idle ${idleMinutes}m)`), updateStatusBar(state);
+  }), lifecycle.startHealthChecks(), state;
+}
+function updateServerMetadata(state, serverName) {
+  let connection = state.manager.getConnection(serverName);
+  if (!connection || connection.status !== "connected")
+    return;
+  let definition = state.config.mcpServers[serverName];
+  if (!definition)
+    return;
+  let prefix = state.config.settings?.toolPrefix ?? "server", { metadata } = buildToolMetadata(connection.tools, connection.resources, definition, serverName, prefix);
+  state.toolMetadata.set(serverName, metadata);
+}
+function updateMetadataCache(state, serverName) {
+  let connection = state.manager.getConnection(serverName);
+  if (!connection || connection.status !== "connected")
+    return;
+  let definition = state.config.mcpServers[serverName];
+  if (!definition)
+    return;
+  let configHash = computeServerHash(definition), existingEntry = loadMetadataCache()?.servers?.[serverName], tools = serializeTools(connection.tools), resources = definition.exposeResources === !1 ? [] : serializeResources(connection.resources);
+  definition.exposeResources !== !1 && resources.length === 0 && existingEntry?.resources?.length && existingEntry.configHash === configHash && (resources = existingEntry.resources);
+  let entry = {
+    configHash,
+    tools,
+    resources,
+    cachedAt: Date.now()
+  };
+  saveMetadataCache({ version: 1, servers: { [serverName]: entry } });
+}
+function flushMetadataCache(state) {
+  for (let [name, connection] of state.manager.getAllConnections())
+    connection.status === "connected" && updateMetadataCache(state, name);
+}
+function updateStatusBar(state) {
+  let ui = state.ui;
+  if (!ui)
+    return;
+  let total = Object.keys(state.config.mcpServers).length;
+  if (total === 0) {
+    ui.setStatus("mcp", void 0);
+    return;
+  }
+  let connectedCount = state.manager.getAllConnections().size;
+  ui.setStatus("mcp", ui.theme.fg("accent", `MCP: ${connectedCount}/${total} servers`));
+}
+function getFailureAgeSeconds(state, serverName) {
+  let failedAt = state.failureTracker.get(serverName);
+  if (!failedAt)
+    return null;
+  let ageMs = Date.now() - failedAt;
+  return ageMs > FAILURE_BACKOFF_MS ? null : Math.round(ageMs / 1e3);
+}
+async function lazyConnect(state, serverName, signal) {
+  let connection = state.manager.getConnection(serverName);
+  if (connection?.status === "needs-auth")
+    return !1;
+  if (connection?.status === "connected")
+    return updateServerMetadata(state, serverName), !0;
+  if (getFailureAgeSeconds(state, serverName) !== null)
+    return !1;
+  let definition = state.config.mcpServers[serverName];
+  if (!definition)
+    return !1;
+  try {
+    return state.ui && state.ui.setStatus("mcp", `MCP: connecting to ${serverName}...`), (await state.manager.connect(serverName, definition, signal)).status === "needs-auth" ? !1 : (state.failureTracker.delete(serverName), updateServerMetadata(state, serverName), updateMetadataCache(state, serverName), updateStatusBar(state), !0);
+  } catch (error) {
+    signal?.aborted && throwIfAborted(signal), state.failureTracker.set(serverName, Date.now());
+    let message = error instanceof Error ? error.message : String(error);
+    return logger.debug(`MCP: lazy connect failed for ${serverName}: ${message}`), updateStatusBar(state), !1;
+  }
+}
+function getEffectiveIdleTimeoutMinutes(state, serverName) {
+  let definition = state.config.mcpServers[serverName];
+  return definition ? typeof definition.idleTimeout == "number" ? definition.idleTimeout : (definition.lifecycle ?? "lazy") === "eager" ? 0 : typeof state.config.settings?.idleTimeout == "number" ? state.config.settings.idleTimeout : 10 : typeof state.config.settings?.idleTimeout == "number" ? state.config.settings.idleTimeout : 10;
+}
+
+export {
+  ServerError,
+  wrapError,
+  logger,
+  AZ,
+  buildToolMetadata,
+  getToolNames,
+  findToolByName,
+  formatSchema,
+  isTuiMode,
+  initializeMcp,
+  updateServerMetadata,
+  updateMetadataCache,
+  flushMetadataCache,
+  updateStatusBar,
+  getFailureAgeSeconds,
+  lazyConnect
+};