@opentiny/next-sdk 0.2.9 → 0.3.0-alpha.0

package/dist/AgentModelProvider-BIOOEdcN.js

@@ -0,0 +1,4068 @@
+import { MessageChannelServerTransport as ge, createTransportPair as ut, MessageChannelClientTransport as ye, sseOptions as dt, streamOptions as pt, createSseProxy as ht, createSocketProxy as mt, createStreamProxy as ft, MessageChannelTransport as gt } from "@opentiny/next";
+import { McpServer as qe } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SetLevelRequestSchema as Te, SubscribeRequestSchema as yt, UnsubscribeRequestSchema as vt, ListResourcesRequestSchema as wt, RootsListChangedNotificationSchema as _t, CallToolResultSchema as bt, ElicitRequestSchema as St, CreateMessageRequestSchema as Tt, ListRootsRequestSchema as Pt, ToolListChangedNotificationSchema as Ct, PromptListChangedNotificationSchema as Rt, ResourceListChangedNotificationSchema as Mt, ResourceUpdatedNotificationSchema as Et, LoggingMessageNotificationSchema as At, JSONRPCMessageSchema as kt } from "@modelcontextprotocol/sdk/types.js";
+import { dynamicTool as Ot, jsonSchema as It, generateText as Pe, streamText as ie, stepCountIs as xt } from "ai";
+import { TypeValidationError as pe, JSONParseError as Ce, InvalidArgumentError as Lt, AISDKError as K } from "@ai-sdk/provider";
+import * as Re from "zod/v4";
+import { z as o } from "zod/v4";
+import { ZodFirstPartyTypeKind as w } from "zod/v3";
+import { StreamableHTTPClientTransport as se } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SSEClientTransport as ne } from "@modelcontextprotocol/sdk/client/sse.js";
+import { InMemoryTransport as Ut } from "@modelcontextprotocol/sdk/inMemory.js";
+import { createOpenAI as $t } from "@ai-sdk/openai";
+import { createDeepSeek as jt } from "@ai-sdk/deepseek";
+import { Client as He } from "@modelcontextprotocol/sdk/client/index.js";
+import { WebSocketClientTransport as Nt } from "@modelcontextprotocol/sdk/client/websocket.js";
+class _n {
+  constructor(e, r) {
+    const s = {
+      name: "web-mcp-server",
+      version: "1.0.0"
+    }, n = {
+      prompts: { listChanged: !0 },
+      resources: { subscribe: !0, listChanged: !0 },
+      tools: { listChanged: !0 },
+      completions: {},
+      logging: {}
+    };
+    this.server = new qe(e || s, r || { capabilities: n }), this.server.server.oninitialized = () => {
+      this.oninitialized?.();
+    }, this.server.server.onclose = () => {
+      this.onclose?.();
+    }, this.server.server.onerror = (a) => {
+      this.onerror?.(a);
+    }, this.server.server.setRequestHandler(Te, async () => ({}));
+  }
+  /**
+   * Connects the server to a transport via the specified option.
+   */
+  async connect(e) {
+    return typeof e.start == "function" ? (this.transport = e, this.transport.onclose = void 0, this.transport.onerror = void 0, this.transport.onmessage = void 0) : (this.transport = new ge(e), await this.transport.listen()), await this.server.connect(this.transport), this.transport;
+  }
+  /**
+   * Closes the connection.
+   */
+  async close() {
+    await this.server.close();
+  }
+  /**
+   * Registers a tool with a config object and callback.
+   */
+  registerTool(e, r, s) {
+    return this.server.registerTool(e, r, s);
+  }
+  /**
+   * Registers a prompt with a config object and callback.
+   */
+  registerPrompt(e, r, s) {
+    return this.server.registerPrompt(e, r, s);
+  }
+  registerResource(e, r, s, n) {
+    return typeof r == "string" ? this.server.registerResource(e, r, s, n) : this.server.registerResource(e, r, s, n);
+  }
+  /**
+   * Checks if the server is connected to a transport.
+   * @returns True if the server is connected
+   */
+  isConnected() {
+    return this.server.isConnected();
+  }
+  /**
+   * Sends a resource list changed event to the client, if connected.
+   */
+  sendResourceListChanged() {
+    this.server.sendResourceListChanged();
+  }
+  /**
+   * Sends a tool list changed event to the client, if connected.
+   */
+  sendToolListChanged() {
+    this.server.sendToolListChanged();
+  }
+  /**
+   * Sends a prompt list changed event to the client, if connected.
+   */
+  sendPromptListChanged() {
+    this.server.sendPromptListChanged();
+  }
+  /**
+   * After initialization has completed, this will be populated with the client's reported capabilities.
+   */
+  getClientCapabilities() {
+    return this.server.server.getClientCapabilities();
+  }
+  /**
+   * After initialization has completed, this will be populated with information about the client's name and version.
+   */
+  getClientVersion() {
+    return this.server.server.getClientVersion();
+  }
+  /**
+   * Sends a ping to the client to check if it is still connected.
+   */
+  async ping() {
+    return await this.server.server.ping();
+  }
+  /**
+   * Creates a LLM message to be sent to the client.
+   */
+  async createMessage(e, r) {
+    return await this.server.server.createMessage(e, r);
+  }
+  /**
+   * Elicits input from the client, such as a prompt or resource.
+   */
+  async elicitInput(e, r) {
+    return await this.server.server.elicitInput(e, r);
+  }
+  /**
+   * Lists the root resources available to the client.
+   */
+  async listRoots(e, r) {
+    return await this.server.server.listRoots(e, r);
+  }
+  /**
+   * Sends a logging message to the client.
+   */
+  async sendLoggingMessage(e) {
+    return await this.server.server.sendLoggingMessage(e);
+  }
+  /**
+   * Sends a resource updated notification to the client.
+   */
+  async sendResourceUpdated(e) {
+    return await this.server.server.sendResourceUpdated(e);
+  }
+  /**
+   * Sends a request and wait for a response.
+   *
+   * Do not use this method to emit notifications! Use notification() instead.
+   */
+  request(e, r, s) {
+    return this.server.server.request(e, r, s);
+  }
+  /**
+   * Emits a notification, which is a one-way message that does not expect a response.
+   */
+  async notification(e, r) {
+    return await this.server.server.notification(e, r);
+  }
+  /**
+   * Registers a handler to invoke when this protocol object receives a request with the given method.
+   *
+   * Note that this will replace any previous request handler for the same method.
+   */
+  setRequestHandler(e, r) {
+    this.server.server.setRequestHandler(e, r);
+  }
+  /**
+   * Removes the request handler for the given method.
+   */
+  removeRequestHandler(e) {
+    this.server.server.removeRequestHandler(e);
+  }
+  /**
+   * Registers a handler to invoke when this protocol object receives a notification with the given method.
+   *
+   * Note that this will replace any previous notification handler for the same method.
+   */
+  setNotificationHandler(e, r) {
+    this.server.server.setNotificationHandler(e, r);
+  }
+  /**
+   * Removes the notification handler for the given method.
+   */
+  removeNotificationHandler(e) {
+    this.server.server.removeNotificationHandler(e);
+  }
+  /**
+   * Registers a handler for the subscribe request.
+   */
+  onSubscribe(e) {
+    this.server.server.setRequestHandler(yt, e);
+  }
+  /**
+   * Registers a handler for the unsubscribe request.
+   */
+  onUnsubscribe(e) {
+    this.server.server.setRequestHandler(vt, e);
+  }
+  /**
+   * Registers a handler for the set log level request.
+   */
+  onSetLogLevel(e) {
+    this.server.server.setRequestHandler(Te, e);
+  }
+  /**
+   * Registers a handler for the list tools request.
+   */
+  onListResources(e) {
+    this.server.server.setRequestHandler(wt, e);
+  }
+  /**
+   * Registers a handler for the roots list changed notification.
+   */
+  onRootsListChanged(e) {
+    this.server.server.setNotificationHandler(_t, e);
+  }
+  /**
+   * Close the transport for window.addEventListener('pagehide')
+   */
+  async onPagehide(e) {
+    e.persisted || this.transport && typeof this.transport.close == "function" && await this.transport.close();
+  }
+}
+const bn = (t, e) => new ge(t, e), Sn = () => ut(), Tn = (t) => t instanceof ge, Pn = (t) => t instanceof qe;
+class qt {
+  constructor(e, r) {
+    const s = {
+      name: "web-mcp-client",
+      version: "1.0.0"
+    }, n = {
+      roots: { listChanged: !0 },
+      sampling: {},
+      elicitation: {}
+    };
+    this.client = new He(e || s, r || { capabilities: n }), this.client.onclose = () => {
+      this.onclose?.();
+    }, this.client.onerror = (a) => {
+      this.onerror?.(a);
+    };
+  }
+  /**
+   * Connects the client to a transport via the specified option.
+   */
+  async connect(e) {
+    if (typeof e.start == "function")
+      return this.transport = e, this.transport.onclose = void 0, this.transport.onerror = void 0, this.transport.onmessage = void 0, await this.client.connect(this.transport), { transport: this.transport, sessionId: this.transport.sessionId };
+    const { url: r, token: s, sessionId: n, type: a, agent: i, onError: u } = e;
+    if (i === !0) {
+      const p = { client: this.client, url: r, token: s, sessionId: n };
+      let g;
+      return await (async () => {
+        const { transport: m, sessionId: y } = a === "sse" ? await ht(p) : a === "socket" ? await mt(p) : await ft(p);
+        m.onerror = async (h) => {
+          u?.(h);
+        }, g = { transport: m, sessionId: y };
+      })(), g;
+    }
+    const l = new URL(r);
+    let c;
+    if (a === "channel" && (c = new ye(r), await this.client.connect(c)), a === "sse") {
+      const p = dt(s, n);
+      c = new ne(l, p), await this.client.connect(c);
+    }
+    if (a === "socket" && (c = new Nt(new URL(`${r}?sessionId=${n}&token=${s}`)), c.sessionId = n, await this.client.connect(c)), typeof c > "u") {
+      const p = pt(s, n);
+      c = new se(l, p), await this.client.connect(c);
+    }
+    return this.transport = c, { transport: this.transport, sessionId: this.transport.sessionId };
+  }
+  /**
+   * Closes the connection.
+   */
+  async close() {
+    await this.client.close();
+  }
+  /**
+   * After initialization has completed, this will be populated with the server's reported capabilities.
+   */
+  getServerCapabilities() {
+    return this.client.getServerCapabilities();
+  }
+  /**
+   * After initialization has completed, this will be populated with information about the server's name and version.
+   */
+  getServerVersion() {
+    return this.client.getServerVersion();
+  }
+  /**
+   * After initialization has completed, this may be populated with information about the server's instructions.
+   */
+  getInstructions() {
+    return this.client.getInstructions();
+  }
+  /**
+   * Sends a ping to the server to check if it is still connected.
+   */
+  async ping(e) {
+    return await this.client.ping(e);
+  }
+  /**
+   * Sends a completion request to the server.
+   */
+  async complete(e, r) {
+    return await this.client.complete(e, r);
+  }
+  /**
+   * Sends a request for setting the logging level to the server.
+   */
+  async setLoggingLevel(e, r) {
+    return await this.client.setLoggingLevel(e, r);
+  }
+  /**
+   * Gets the prompt with the given params from the server.
+   */
+  async getPrompt(e, r) {
+    return await this.client.getPrompt(e, r);
+  }
+  /**
+   * Lists all prompts available on the server.
+   */
+  async listPrompts(e, r) {
+    return await this.client.listPrompts(e, r);
+  }
+  /**
+   * Lists all resources available on the server.
+   */
+  async listResources(e, r) {
+    return await this.client.listResources(e, r);
+  }
+  /**
+   * Lists all resource templates available on the server.
+   */
+  async listResourceTemplates(e, r) {
+    return await this.client.listResourceTemplates(e, r);
+  }
+  /**
+   * Reads the resource with the given params from the server.
+   */
+  async readResource(e, r) {
+    return await this.client.readResource(e, r);
+  }
+  /**
+   * Subscribes to a resource on the server.
+   */
+  async subscribeResource(e, r) {
+    return await this.client.subscribeResource(e, r);
+  }
+  /**
+   * Unsubscribes from a resource on the server.
+   */
+  async unsubscribeResource(e, r) {
+    return await this.client.unsubscribeResource(e, r);
+  }
+  /**
+   * Calls a tool on the server with the given parameters.
+   */
+  async callTool(e, r) {
+    return await this.client.callTool(e, bt, r);
+  }
+  /**
+   * Lists all tools available on the server.
+   */
+  async listTools(e, r) {
+    return await this.client.listTools(e, r);
+  }
+  /**
+   * Sends a notification for the roots list changed event to the server.
+   */
+  async sendRootsListChanged() {
+    return await this.client.sendRootsListChanged();
+  }
+  /**
+   * Sends a request and wait for a response.
+   *
+   * Do not use this method to emit notifications! Use notification() instead.
+   */
+  request(e, r, s) {
+    return this.client.request(e, r, s);
+  }
+  /**
+   * Emits a notification, which is a one-way message that does not expect a response.
+   */
+  async notification(e, r) {
+    return await this.client.notification(e, r);
+  }
+  /**
+   * Registers a handler to invoke when this protocol object receives a request with the given method.
+   *
+   * Note that this will replace any previous request handler for the same method.
+   */
+  setRequestHandler(e, r) {
+    this.client.setRequestHandler(e, r);
+  }
+  /**
+   * Removes the request handler for the given method.
+   */
+  removeRequestHandler(e) {
+    this.client.removeRequestHandler(e);
+  }
+  /**
+   * Registers a handler to invoke when this protocol object receives a notification with the given method.
+   *
+   * Note that this will replace any previous notification handler for the same method.
+   */
+  setNotificationHandler(e, r) {
+    this.client.setNotificationHandler(e, r);
+  }
+  /**
+   * Removes the notification handler for the given method.
+   */
+  removeNotificationHandler(e) {
+    this.client.removeNotificationHandler(e);
+  }
+  /**
+   * Registers a handler for the elicitation request.
+   */
+  onElicit(e) {
+    this.client.setRequestHandler(St, e);
+  }
+  /**
+   * Registers a handler for the create LLM message request.
+   */
+  onCreateMessage(e) {
+    this.client.setRequestHandler(Tt, e);
+  }
+  /**
+   * Registers a handler for the list roots request.
+   */
+  onListRoots(e) {
+    this.client.setRequestHandler(Pt, e);
+  }
+  /**
+   * Registers a handler for the tool list changed notification.
+   */
+  onToolListChanged(e) {
+    this.client.setNotificationHandler(Ct, e);
+  }
+  /**
+   * Registers a handler for the prompt list changed notification.
+   */
+  onPromptListChanged(e) {
+    this.client.setNotificationHandler(Rt, e);
+  }
+  /**
+   * Registers a handler for the resource list changed notification.
+   */
+  onResourceListChanged(e) {
+    this.client.setNotificationHandler(Mt, e);
+  }
+  /**
+   * Registers a handler for the resource updated notification.
+   */
+  onResourceUpdated(e) {
+    this.client.setNotificationHandler(Et, e);
+  }
+  /**
+   * Registers a handler for the logging message notification.
+   */
+  onLoggingMessage(e) {
+    this.client.setNotificationHandler(At, e);
+  }
+  /**
+   * Close the transport for window.addEventListener('pagehide')
+   */
+  async onPagehide(e) {
+    e.persisted || (Ht(this.transport) ? await this.transport.terminateSession() : this.transport && typeof this.transport.close == "function" && await this.transport.close());
+  }
+}
+const Cn = (t, e) => new ne(t, e), Rn = (t, e) => new se(t, e), Mn = (t, e) => new ye(t, e), En = (t) => t instanceof ne, Ht = (t) => t instanceof se, An = (t) => t instanceof ye, kn = (t) => t instanceof He, On = (t, e, r) => {
+  window.postMessage({ type: t, direction: r, data: e }, "*");
+}, In = (t, e, r) => {
+  const s = async function(n) {
+    n.source === window && n.data.type === t && n.data.direction === r && await e(n.data.data);
+  };
+  return window.addEventListener("message", s), () => window.removeEventListener("message", s);
+}, Zt = (t, e, r) => {
+  if (r.endsWith("content"))
+    chrome.tabs.query({}, (s) => {
+      s.forEach((n) => {
+        chrome.tabs.sendMessage(n.id, { type: t, data: e, direction: r, tabId: n.id });
+      });
+    });
+  else
+    return chrome.runtime.sendMessage({ direction: r, type: t, data: e });
+}, Dt = (t, e, r, s) => {
+  const n = (a, i, u) => {
+    if (a.type === t && a.direction === r && (!s || s && a.tabId === s)) {
+      const { data: l } = a;
+      e(l, i, u), u(i);
+    }
+  };
+  return chrome.runtime.onMessage.addListener(n), () => chrome.runtime.onMessage.removeListener(n);
+};
+class zt {
+  constructor(e) {
+    this._isStarted = !1, this._isClosed = !1, this.targetSessionId = e, this._messageListener = Dt(
+      "mcp-server-to-client",
+      (r) => {
+        try {
+          if (r.sessionId !== this.targetSessionId) return;
+          const s = kt.parse(r.mcpMessage);
+          this.onmessage?.(s);
+        } catch (s) {
+          console.log("【Client Transport】处理server消息错误：", s);
+        }
+      },
+      "content->bg"
+    );
+  }
+  // 是否已关闭
+  _throwError(e, r) {
+    if (e()) {
+      const s = new Error(r);
+      throw console.log(r, s), this.onerror && this.onerror(s), s;
+    }
+  }
+  /** 启动 transport，开始监听消息   */
+  async start() {
+    this._throwError(() => this._isClosed, "【Client Transport】 未启动，无法重新启动"), this._isStarted = !0;
+  }
+  /** 发送消息到 MCP Server  */
+  async send(e, r) {
+    this._throwError(() => !this._isStarted, "【Client Transport】 未启动，无法发送消息"), this._throwError(() => this._isClosed, "【Client Transport】 已关闭，无法发送消息");
+    let s;
+    if (chrome.sessionRegistry) {
+      const n = chrome.sessionRegistry.get(this.targetSessionId);
+      n && n.tabIds.length > 0 && (s = n.tabIds[n.tabIds.length - 1]);
+    }
+    s == null && (s = await chrome.runtime.sendMessage({ type: "get-session-tab-id", sessionId: this.targetSessionId })), this._throwError(() => s == null, `【Client Transport】后台未找到活动的tabId用于${this.targetSessionId}`), Zt(
+      "mcp-client-to-server",
+      { sessionId: this.targetSessionId, tabId: s, mcpMessage: e },
+      "bg->content"
+    );
+  }
+  /** 关闭 transport   */
+  async close() {
+    if (!this._isClosed)
+      try {
+        this._isClosed = !0, this._isStarted = !1, this._messageListener && this._messageListener(), this.onclose && this.onclose();
+      } catch {
+        this._throwError(() => !0, "【Client Transport】 关闭时发生错误");
+      }
+  }
+}
+class Me extends Error {
+  constructor(e, r) {
+    super(e), this.name = "ParseError", this.type = r.type, this.field = r.field, this.value = r.value, this.line = r.line;
+  }
+}
+function ce(t) {
+}
+function Ft(t) {
+  if (typeof t == "function")
+    throw new TypeError(
+      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+    );
+  const { onEvent: e = ce, onError: r = ce, onRetry: s = ce, onComment: n } = t;
+  let a = "", i = !0, u, l = "", c = "";
+  function p(h) {
+    const f = i ? h.replace(/^\xEF\xBB\xBF/, "") : h, [v, b] = Vt(`${a}${f}`);
+    for (const T of v)
+      g(T);
+    a = b, i = !1;
+  }
+  function g(h) {
+    if (h === "") {
+      m();
+      return;
+    }
+    if (h.startsWith(":")) {
+      n && n(h.slice(h.startsWith(": ") ? 2 : 1));
+      return;
+    }
+    const f = h.indexOf(":");
+    if (f !== -1) {
+      const v = h.slice(0, f), b = h[f + 1] === " " ? 2 : 1, T = h.slice(f + b);
+      d(v, T, h);
+      return;
+    }
+    d(h, "", h);
+  }
+  function d(h, f, v) {
+    switch (h) {
+      case "event":
+        c = f;
+        break;
+      case "data":
+        l = `${l}${f}
+`;
+        break;
+      case "id":
+        u = f.includes("\0") ? void 0 : f;
+        break;
+      case "retry":
+        /^\d+$/.test(f) ? s(parseInt(f, 10)) : r(
+          new Me(`Invalid \`retry\` value: "${f}"`, {
+            type: "invalid-retry",
+            value: f,
+            line: v
+          })
+        );
+        break;
+      default:
+        r(
+          new Me(
+            `Unknown field "${h.length > 20 ? `${h.slice(0, 20)}…` : h}"`,
+            { type: "unknown-field", field: h, value: f, line: v }
+          )
+        );
+        break;
+    }
+  }
+  function m() {
+    l.length > 0 && e({
+      id: u,
+      event: c || void 0,
+      // If the data buffer's last character is a U+000A LINE FEED (LF) character,
+      // then remove the last character from the data buffer.
+      data: l.endsWith(`
+`) ? l.slice(0, -1) : l
+    }), u = void 0, l = "", c = "";
+  }
+  function y(h = {}) {
+    a && h.consume && g(a), i = !0, u = void 0, l = "", c = "", a = "";
+  }
+  return { feed: p, reset: y };
+}
+function Vt(t) {
+  const e = [];
+  let r = "", s = 0;
+  for (; s < t.length; ) {
+    const n = t.indexOf("\r", s), a = t.indexOf(`
+`, s);
+    let i = -1;
+    if (n !== -1 && a !== -1 ? i = Math.min(n, a) : n !== -1 ? n === t.length - 1 ? i = -1 : i = n : a !== -1 && (i = a), i === -1) {
+      r = t.slice(s);
+      break;
+    } else {
+      const u = t.slice(s, i);
+      e.push(u), s = i + 1, t[s - 1] === "\r" && t[s] === `
+` && s++;
+    }
+  }
+  return [e, r];
+}
+class he extends TransformStream {
+  constructor({ onError: e, onRetry: r, onComment: s } = {}) {
+    let n;
+    super({
+      start(a) {
+        n = Ft({
+          onEvent: (i) => {
+            a.enqueue(i);
+          },
+          onError(i) {
+            e === "terminate" ? a.error(i) : typeof e == "function" && e(i);
+          },
+          onRetry: r,
+          onComment: s
+        });
+      },
+      transform(a) {
+        n.feed(a);
+      }
+    });
+  }
+}
+var Jt = ({
+  prefix: t,
+  size: e = 16,
+  alphabet: r = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  separator: s = "-"
+} = {}) => {
+  const n = () => {
+    const a = r.length, i = new Array(e);
+    for (let u = 0; u < e; u++)
+      i[u] = r[Math.random() * a | 0];
+    return i.join("");
+  };
+  if (t == null)
+    return n;
+  if (r.includes(s))
+    throw new Lt({
+      argument: "separator",
+      message: `The separator "${s}" must not be part of the alphabet "${r}".`
+    });
+  return () => `${t}${s}${n()}`;
+};
+Jt();
+function Ze(t = globalThis) {
+  var e, r, s;
+  return t.window ? "runtime/browser" : (e = t.navigator) != null && e.userAgent ? `runtime/${t.navigator.userAgent.toLowerCase()}` : (s = (r = t.process) == null ? void 0 : r.versions) != null && s.node ? `runtime/node.js/${t.process.version.substring(0)}` : t.EdgeRuntime ? "runtime/vercel-edge" : "runtime/unknown";
+}
+function Wt(t) {
+  if (t == null)
+    return {};
+  const e = {};
+  if (t instanceof Headers)
+    t.forEach((r, s) => {
+      e[s.toLowerCase()] = r;
+    });
+  else {
+    Array.isArray(t) || (t = Object.entries(t));
+    for (const [r, s] of t)
+      s != null && (e[r.toLowerCase()] = s);
+  }
+  return e;
+}
+function De(t, ...e) {
+  const r = new Headers(Wt(t)), s = r.get("user-agent") || "";
+  return r.set(
+    "user-agent",
+    [s, ...e].filter(Boolean).join(" ")
+  ), Object.fromEntries(r.entries());
+}
+var Bt = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/, Gt = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+function Ee(t) {
+  const e = JSON.parse(t);
+  return e === null || typeof e != "object" || Bt.test(t) === !1 && Gt.test(t) === !1 ? e : Kt(e);
+}
+function Kt(t) {
+  let e = [t];
+  for (; e.length; ) {
+    const r = e;
+    e = [];
+    for (const s of r) {
+      if (Object.prototype.hasOwnProperty.call(s, "__proto__"))
+        throw new SyntaxError("Object contains forbidden prototype property");
+      if (Object.prototype.hasOwnProperty.call(s, "constructor") && s.constructor !== null && typeof s.constructor == "object" && Object.prototype.hasOwnProperty.call(s.constructor, "prototype"))
+        throw new SyntaxError("Object contains forbidden prototype property");
+      for (const n in s) {
+        const a = s[n];
+        a && typeof a == "object" && e.push(a);
+      }
+    }
+  }
+  return t;
+}
+function Xt(t) {
+  const { stackTraceLimit: e } = Error;
+  try {
+    Error.stackTraceLimit = 0;
+  } catch {
+    return Ee(t);
+  }
+  try {
+    return Ee(t);
+  } finally {
+    Error.stackTraceLimit = e;
+  }
+}
+function ve(t) {
+  if (t.type === "object" || Array.isArray(t.type) && t.type.includes("object")) {
+    t.additionalProperties = !1;
+    const { properties: r } = t;
+    if (r != null)
+      for (const s of Object.keys(r))
+        r[s] = q(r[s]);
+  }
+  t.items != null && (t.items = Array.isArray(t.items) ? t.items.map(q) : q(t.items)), t.anyOf != null && (t.anyOf = t.anyOf.map(q)), t.allOf != null && (t.allOf = t.allOf.map(q)), t.oneOf != null && (t.oneOf = t.oneOf.map(q));
+  const { definitions: e } = t;
+  if (e != null)
+    for (const r of Object.keys(e))
+      e[r] = q(e[r]);
+  return t;
+}
+function q(t) {
+  return typeof t == "boolean" ? t : ve(t);
+}
+var Qt = /* @__PURE__ */ Symbol(
+  "Let zodToJsonSchema decide on which parser to use"
+), Ae = {
+  name: void 0,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  allowedAdditionalProperties: !0,
+  rejectedAdditionalProperties: !1,
+  definitionPath: "definitions",
+  strictUnions: !1,
+  definitions: {},
+  errorMessages: !1,
+  patternStrategy: "escape",
+  applyRegexFlags: !1,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref"
+}, Yt = (t) => typeof t == "string" ? {
+  ...Ae,
+  name: t
+} : {
+  ...Ae,
+  ...t
+};
+function E() {
+  return {};
+}
+function er(t, e) {
+  var r, s, n;
+  const a = {
+    type: "array"
+  };
+  return (r = t.type) != null && r._def && ((n = (s = t.type) == null ? void 0 : s._def) == null ? void 0 : n.typeName) !== w.ZodAny && (a.items = S(t.type._def, {
+    ...e,
+    currentPath: [...e.currentPath, "items"]
+  })), t.minLength && (a.minItems = t.minLength.value), t.maxLength && (a.maxItems = t.maxLength.value), t.exactLength && (a.minItems = t.exactLength.value, a.maxItems = t.exactLength.value), a;
+}
+function tr(t) {
+  const e = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!t.checks) return e;
+  for (const r of t.checks)
+    switch (r.kind) {
+      case "min":
+        r.inclusive ? e.minimum = r.value : e.exclusiveMinimum = r.value;
+        break;
+      case "max":
+        r.inclusive ? e.maximum = r.value : e.exclusiveMaximum = r.value;
+        break;
+      case "multipleOf":
+        e.multipleOf = r.value;
+        break;
+    }
+  return e;
+}
+function rr() {
+  return { type: "boolean" };
+}
+function ze(t, e) {
+  return S(t.type._def, e);
+}
+var sr = (t, e) => S(t.innerType._def, e);
+function Fe(t, e, r) {
+  const s = r ?? e.dateStrategy;
+  if (Array.isArray(s))
+    return {
+      anyOf: s.map((n, a) => Fe(t, e, n))
+    };
+  switch (s) {
+    case "string":
+    case "format:date-time":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "format:date":
+      return {
+        type: "string",
+        format: "date"
+      };
+    case "integer":
+      return nr(t);
+  }
+}
+var nr = (t) => {
+  const e = {
+    type: "integer",
+    format: "unix-time"
+  };
+  for (const r of t.checks)
+    switch (r.kind) {
+      case "min":
+        e.minimum = r.value;
+        break;
+      case "max":
+        e.maximum = r.value;
+        break;
+    }
+  return e;
+};
+function or(t, e) {
+  return {
+    ...S(t.innerType._def, e),
+    default: t.defaultValue()
+  };
+}
+function ar(t, e) {
+  return e.effectStrategy === "input" ? S(t.schema._def, e) : E();
+}
+function ir(t) {
+  return {
+    type: "string",
+    enum: Array.from(t.values)
+  };
+}
+var cr = (t) => "type" in t && t.type === "string" ? !1 : "allOf" in t;
+function lr(t, e) {
+  const r = [
+    S(t.left._def, {
+      ...e,
+      currentPath: [...e.currentPath, "allOf", "0"]
+    }),
+    S(t.right._def, {
+      ...e,
+      currentPath: [...e.currentPath, "allOf", "1"]
+    })
+  ].filter((n) => !!n), s = [];
+  return r.forEach((n) => {
+    if (cr(n))
+      s.push(...n.allOf);
+    else {
+      let a = n;
+      if ("additionalProperties" in n && n.additionalProperties === !1) {
+        const { additionalProperties: i, ...u } = n;
+        a = u;
+      }
+      s.push(a);
+    }
+  }), s.length ? { allOf: s } : void 0;
+}
+function ur(t) {
+  const e = typeof t.value;
+  return e !== "bigint" && e !== "number" && e !== "boolean" && e !== "string" ? {
+    type: Array.isArray(t.value) ? "array" : "object"
+  } : {
+    type: e === "bigint" ? "integer" : e,
+    const: t.value
+  };
+}
+var le = void 0, L = {
+  /**
+   * `c` was changed to `[cC]` to replicate /i flag
+   */
+  cuid: /^[cC][^\s-]{8,}$/,
+  cuid2: /^[0-9a-z]+$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  /**
+   * `a-z` was added to replicate /i flag
+   */
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  /**
+   * Constructed a valid Unicode RegExp
+   *
+   * Lazily instantiate since this type of regex isn't supported
+   * in all envs (e.g. React Native).
+   *
+   * See:
+   * https://github.com/colinhacks/zod/issues/2433
+   * Fix in Zod:
+   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+   */
+  emoji: () => (le === void 0 && (le = RegExp(
+    "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
+    "u"
+  )), le),
+  /**
+   * Unused
+   */
+  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+  /**
+   * Unused
+   */
+  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+  /**
+   * Unused
+   */
+  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+  nanoid: /^[a-zA-Z0-9_-]{21}$/,
+  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+};
+function Ve(t, e) {
+  const r = {
+    type: "string"
+  };
+  if (t.checks)
+    for (const s of t.checks)
+      switch (s.kind) {
+        case "min":
+          r.minLength = typeof r.minLength == "number" ? Math.max(r.minLength, s.value) : s.value;
+          break;
+        case "max":
+          r.maxLength = typeof r.maxLength == "number" ? Math.min(r.maxLength, s.value) : s.value;
+          break;
+        case "email":
+          switch (e.emailStrategy) {
+            case "format:email":
+              U(r, "email", s.message, e);
+              break;
+            case "format:idn-email":
+              U(r, "idn-email", s.message, e);
+              break;
+            case "pattern:zod":
+              C(r, L.email, s.message, e);
+              break;
+          }
+          break;
+        case "url":
+          U(r, "uri", s.message, e);
+          break;
+        case "uuid":
+          U(r, "uuid", s.message, e);
+          break;
+        case "regex":
+          C(r, s.regex, s.message, e);
+          break;
+        case "cuid":
+          C(r, L.cuid, s.message, e);
+          break;
+        case "cuid2":
+          C(r, L.cuid2, s.message, e);
+          break;
+        case "startsWith":
+          C(
+            r,
+            RegExp(`^${ue(s.value, e)}`),
+            s.message,
+            e
+          );
+          break;
+        case "endsWith":
+          C(
+            r,
+            RegExp(`${ue(s.value, e)}$`),
+            s.message,
+            e
+          );
+          break;
+        case "datetime":
+          U(r, "date-time", s.message, e);
+          break;
+        case "date":
+          U(r, "date", s.message, e);
+          break;
+        case "time":
+          U(r, "time", s.message, e);
+          break;
+        case "duration":
+          U(r, "duration", s.message, e);
+          break;
+        case "length":
+          r.minLength = typeof r.minLength == "number" ? Math.max(r.minLength, s.value) : s.value, r.maxLength = typeof r.maxLength == "number" ? Math.min(r.maxLength, s.value) : s.value;
+          break;
+        case "includes": {
+          C(
+            r,
+            RegExp(ue(s.value, e)),
+            s.message,
+            e
+          );
+          break;
+        }
+        case "ip": {
+          s.version !== "v6" && U(r, "ipv4", s.message, e), s.version !== "v4" && U(r, "ipv6", s.message, e);
+          break;
+        }
+        case "base64url":
+          C(r, L.base64url, s.message, e);
+          break;
+        case "jwt":
+          C(r, L.jwt, s.message, e);
+          break;
+        case "cidr": {
+          s.version !== "v6" && C(r, L.ipv4Cidr, s.message, e), s.version !== "v4" && C(r, L.ipv6Cidr, s.message, e);
+          break;
+        }
+        case "emoji":
+          C(r, L.emoji(), s.message, e);
+          break;
+        case "ulid": {
+          C(r, L.ulid, s.message, e);
+          break;
+        }
+        case "base64": {
+          switch (e.base64Strategy) {
+            case "format:binary": {
+              U(r, "binary", s.message, e);
+              break;
+            }
+            case "contentEncoding:base64": {
+              r.contentEncoding = "base64";
+              break;
+            }
+            case "pattern:zod": {
+              C(r, L.base64, s.message, e);
+              break;
+            }
+          }
+          break;
+        }
+        case "nanoid":
+          C(r, L.nanoid, s.message, e);
+      }
+  return r;
+}
+function ue(t, e) {
+  return e.patternStrategy === "escape" ? pr(t) : t;
+}
+var dr = new Set(
+  "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
+);
+function pr(t) {
+  let e = "";
+  for (let r = 0; r < t.length; r++)
+    dr.has(t[r]) || (e += "\\"), e += t[r];
+  return e;
+}
+function U(t, e, r, s) {
+  var n;
+  t.format || (n = t.anyOf) != null && n.some((a) => a.format) ? (t.anyOf || (t.anyOf = []), t.format && (t.anyOf.push({
+    format: t.format
+  }), delete t.format), t.anyOf.push({
+    format: e,
+    ...r && s.errorMessages && { errorMessage: { format: r } }
+  })) : t.format = e;
+}
+function C(t, e, r, s) {
+  var n;
+  t.pattern || (n = t.allOf) != null && n.some((a) => a.pattern) ? (t.allOf || (t.allOf = []), t.pattern && (t.allOf.push({
+    pattern: t.pattern
+  }), delete t.pattern), t.allOf.push({
+    pattern: ke(e, s),
+    ...r && s.errorMessages && { errorMessage: { pattern: r } }
+  })) : t.pattern = ke(e, s);
+}
+function ke(t, e) {
+  var r;
+  if (!e.applyRegexFlags || !t.flags)
+    return t.source;
+  const s = {
+    i: t.flags.includes("i"),
+    // Case-insensitive
+    m: t.flags.includes("m"),
+    // `^` and `$` matches adjacent to newline characters
+    s: t.flags.includes("s")
+    // `.` matches newlines
+  }, n = s.i ? t.source.toLowerCase() : t.source;
+  let a = "", i = !1, u = !1, l = !1;
+  for (let c = 0; c < n.length; c++) {
+    if (i) {
+      a += n[c], i = !1;
+      continue;
+    }
+    if (s.i) {
+      if (u) {
+        if (n[c].match(/[a-z]/)) {
+          l ? (a += n[c], a += `${n[c - 2]}-${n[c]}`.toUpperCase(), l = !1) : n[c + 1] === "-" && ((r = n[c + 2]) != null && r.match(/[a-z]/)) ? (a += n[c], l = !0) : a += `${n[c]}${n[c].toUpperCase()}`;
+          continue;
+        }
+      } else if (n[c].match(/[a-z]/)) {
+        a += `[${n[c]}${n[c].toUpperCase()}]`;
+        continue;
+      }
+    }
+    if (s.m) {
+      if (n[c] === "^") {
+        a += `(^|(?<=[\r
+]))`;
+        continue;
+      } else if (n[c] === "$") {
+        a += `($|(?=[\r
+]))`;
+        continue;
+      }
+    }
+    if (s.s && n[c] === ".") {
+      a += u ? `${n[c]}\r
+` : `[${n[c]}\r
+]`;
+      continue;
+    }
+    a += n[c], n[c] === "\\" ? i = !0 : u && n[c] === "]" ? u = !1 : !u && n[c] === "[" && (u = !0);
+  }
+  try {
+    new RegExp(a);
+  } catch {
+    return console.warn(
+      `Could not convert regex pattern at ${e.currentPath.join(
+        "/"
+      )} to a flag-independent form! Falling back to the flag-ignorant source`
+    ), t.source;
+  }
+  return a;
+}
+function Je(t, e) {
+  var r, s, n, a, i, u;
+  const l = {
+    type: "object",
+    additionalProperties: (r = S(t.valueType._def, {
+      ...e,
+      currentPath: [...e.currentPath, "additionalProperties"]
+    })) != null ? r : e.allowedAdditionalProperties
+  };
+  if (((s = t.keyType) == null ? void 0 : s._def.typeName) === w.ZodString && ((n = t.keyType._def.checks) != null && n.length)) {
+    const { type: c, ...p } = Ve(t.keyType._def, e);
+    return {
+      ...l,
+      propertyNames: p
+    };
+  } else {
+    if (((a = t.keyType) == null ? void 0 : a._def.typeName) === w.ZodEnum)
+      return {
+        ...l,
+        propertyNames: {
+          enum: t.keyType._def.values
+        }
+      };
+    if (((i = t.keyType) == null ? void 0 : i._def.typeName) === w.ZodBranded && t.keyType._def.type._def.typeName === w.ZodString && ((u = t.keyType._def.type._def.checks) != null && u.length)) {
+      const { type: c, ...p } = ze(
+        t.keyType._def,
+        e
+      );
+      return {
+        ...l,
+        propertyNames: p
+      };
+    }
+  }
+  return l;
+}
+function hr(t, e) {
+  if (e.mapStrategy === "record")
+    return Je(t, e);
+  const r = S(t.keyType._def, {
+    ...e,
+    currentPath: [...e.currentPath, "items", "items", "0"]
+  }) || E(), s = S(t.valueType._def, {
+    ...e,
+    currentPath: [...e.currentPath, "items", "items", "1"]
+  }) || E();
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [r, s],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+function mr(t) {
+  const e = t.values, s = Object.keys(t.values).filter((a) => typeof e[e[a]] != "number").map((a) => e[a]), n = Array.from(
+    new Set(s.map((a) => typeof a))
+  );
+  return {
+    type: n.length === 1 ? n[0] === "string" ? "string" : "number" : ["string", "number"],
+    enum: s
+  };
+}
+function fr() {
+  return { not: E() };
+}
+function gr() {
+  return {
+    type: "null"
+  };
+}
+var me = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "integer",
+  ZodBoolean: "boolean",
+  ZodNull: "null"
+};
+function yr(t, e) {
+  const r = t.options instanceof Map ? Array.from(t.options.values()) : t.options;
+  if (r.every(
+    (s) => s._def.typeName in me && (!s._def.checks || !s._def.checks.length)
+  )) {
+    const s = r.reduce((n, a) => {
+      const i = me[a._def.typeName];
+      return i && !n.includes(i) ? [...n, i] : n;
+    }, []);
+    return {
+      type: s.length > 1 ? s : s[0]
+    };
+  } else if (r.every((s) => s._def.typeName === "ZodLiteral" && !s.description)) {
+    const s = r.reduce(
+      (n, a) => {
+        const i = typeof a._def.value;
+        switch (i) {
+          case "string":
+          case "number":
+          case "boolean":
+            return [...n, i];
+          case "bigint":
+            return [...n, "integer"];
+          case "object":
+            if (a._def.value === null) return [...n, "null"];
+          case "symbol":
+          case "undefined":
+          case "function":
+          default:
+            return n;
+        }
+      },
+      []
+    );
+    if (s.length === r.length) {
+      const n = s.filter((a, i, u) => u.indexOf(a) === i);
+      return {
+        type: n.length > 1 ? n : n[0],
+        enum: r.reduce(
+          (a, i) => a.includes(i._def.value) ? a : [...a, i._def.value],
+          []
+        )
+      };
+    }
+  } else if (r.every((s) => s._def.typeName === "ZodEnum"))
+    return {
+      type: "string",
+      enum: r.reduce(
+        (s, n) => [
+          ...s,
+          ...n._def.values.filter((a) => !s.includes(a))
+        ],
+        []
+      )
+    };
+  return vr(t, e);
+}
+var vr = (t, e) => {
+  const r = (t.options instanceof Map ? Array.from(t.options.values()) : t.options).map(
+    (s, n) => S(s._def, {
+      ...e,
+      currentPath: [...e.currentPath, "anyOf", `${n}`]
+    })
+  ).filter(
+    (s) => !!s && (!e.strictUnions || typeof s == "object" && Object.keys(s).length > 0)
+  );
+  return r.length ? { anyOf: r } : void 0;
+};
+function wr(t, e) {
+  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(
+    t.innerType._def.typeName
+  ) && (!t.innerType._def.checks || !t.innerType._def.checks.length))
+    return {
+      type: [
+        me[t.innerType._def.typeName],
+        "null"
+      ]
+    };
+  const r = S(t.innerType._def, {
+    ...e,
+    currentPath: [...e.currentPath, "anyOf", "0"]
+  });
+  return r && { anyOf: [r, { type: "null" }] };
+}
+function _r(t) {
+  const e = {
+    type: "number"
+  };
+  if (!t.checks) return e;
+  for (const r of t.checks)
+    switch (r.kind) {
+      case "int":
+        e.type = "integer";
+        break;
+      case "min":
+        r.inclusive ? e.minimum = r.value : e.exclusiveMinimum = r.value;
+        break;
+      case "max":
+        r.inclusive ? e.maximum = r.value : e.exclusiveMaximum = r.value;
+        break;
+      case "multipleOf":
+        e.multipleOf = r.value;
+        break;
+    }
+  return e;
+}
+function br(t, e) {
+  const r = {
+    type: "object",
+    properties: {}
+  }, s = [], n = t.shape();
+  for (const i in n) {
+    let u = n[i];
+    if (u === void 0 || u._def === void 0)
+      continue;
+    const l = Tr(u), c = S(u._def, {
+      ...e,
+      currentPath: [...e.currentPath, "properties", i],
+      propertyPath: [...e.currentPath, "properties", i]
+    });
+    c !== void 0 && (r.properties[i] = c, l || s.push(i));
+  }
+  s.length && (r.required = s);
+  const a = Sr(t, e);
+  return a !== void 0 && (r.additionalProperties = a), r;
+}
+function Sr(t, e) {
+  if (t.catchall._def.typeName !== "ZodNever")
+    return S(t.catchall._def, {
+      ...e,
+      currentPath: [...e.currentPath, "additionalProperties"]
+    });
+  switch (t.unknownKeys) {
+    case "passthrough":
+      return e.allowedAdditionalProperties;
+    case "strict":
+      return e.rejectedAdditionalProperties;
+    case "strip":
+      return e.removeAdditionalStrategy === "strict" ? e.allowedAdditionalProperties : e.rejectedAdditionalProperties;
+  }
+}
+function Tr(t) {
+  try {
+    return t.isOptional();
+  } catch {
+    return !0;
+  }
+}
+var Pr = (t, e) => {
+  var r;
+  if (e.currentPath.toString() === ((r = e.propertyPath) == null ? void 0 : r.toString()))
+    return S(t.innerType._def, e);
+  const s = S(t.innerType._def, {
+    ...e,
+    currentPath: [...e.currentPath, "anyOf", "1"]
+  });
+  return s ? { anyOf: [{ not: E() }, s] } : E();
+}, Cr = (t, e) => {
+  if (e.pipeStrategy === "input")
+    return S(t.in._def, e);
+  if (e.pipeStrategy === "output")
+    return S(t.out._def, e);
+  const r = S(t.in._def, {
+    ...e,
+    currentPath: [...e.currentPath, "allOf", "0"]
+  }), s = S(t.out._def, {
+    ...e,
+    currentPath: [...e.currentPath, "allOf", r ? "1" : "0"]
+  });
+  return {
+    allOf: [r, s].filter((n) => n !== void 0)
+  };
+};
+function Rr(t, e) {
+  return S(t.type._def, e);
+}
+function Mr(t, e) {
+  const s = {
+    type: "array",
+    uniqueItems: !0,
+    items: S(t.valueType._def, {
+      ...e,
+      currentPath: [...e.currentPath, "items"]
+    })
+  };
+  return t.minSize && (s.minItems = t.minSize.value), t.maxSize && (s.maxItems = t.maxSize.value), s;
+}
+function Er(t, e) {
+  return t.rest ? {
+    type: "array",
+    minItems: t.items.length,
+    items: t.items.map(
+      (r, s) => S(r._def, {
+        ...e,
+        currentPath: [...e.currentPath, "items", `${s}`]
+      })
+    ).reduce(
+      (r, s) => s === void 0 ? r : [...r, s],
+      []
+    ),
+    additionalItems: S(t.rest._def, {
+      ...e,
+      currentPath: [...e.currentPath, "additionalItems"]
+    })
+  } : {
+    type: "array",
+    minItems: t.items.length,
+    maxItems: t.items.length,
+    items: t.items.map(
+      (r, s) => S(r._def, {
+        ...e,
+        currentPath: [...e.currentPath, "items", `${s}`]
+      })
+    ).reduce(
+      (r, s) => s === void 0 ? r : [...r, s],
+      []
+    )
+  };
+}
+function Ar() {
+  return {
+    not: E()
+  };
+}
+function kr() {
+  return E();
+}
+var Or = (t, e) => S(t.innerType._def, e), Ir = (t, e, r) => {
+  switch (e) {
+    case w.ZodString:
+      return Ve(t, r);
+    case w.ZodNumber:
+      return _r(t);
+    case w.ZodObject:
+      return br(t, r);
+    case w.ZodBigInt:
+      return tr(t);
+    case w.ZodBoolean:
+      return rr();
+    case w.ZodDate:
+      return Fe(t, r);
+    case w.ZodUndefined:
+      return Ar();
+    case w.ZodNull:
+      return gr();
+    case w.ZodArray:
+      return er(t, r);
+    case w.ZodUnion:
+    case w.ZodDiscriminatedUnion:
+      return yr(t, r);
+    case w.ZodIntersection:
+      return lr(t, r);
+    case w.ZodTuple:
+      return Er(t, r);
+    case w.ZodRecord:
+      return Je(t, r);
+    case w.ZodLiteral:
+      return ur(t);
+    case w.ZodEnum:
+      return ir(t);
+    case w.ZodNativeEnum:
+      return mr(t);
+    case w.ZodNullable:
+      return wr(t, r);
+    case w.ZodOptional:
+      return Pr(t, r);
+    case w.ZodMap:
+      return hr(t, r);
+    case w.ZodSet:
+      return Mr(t, r);
+    case w.ZodLazy:
+      return () => t.getter()._def;
+    case w.ZodPromise:
+      return Rr(t, r);
+    case w.ZodNaN:
+    case w.ZodNever:
+      return fr();
+    case w.ZodEffects:
+      return ar(t, r);
+    case w.ZodAny:
+      return E();
+    case w.ZodUnknown:
+      return kr();
+    case w.ZodDefault:
+      return or(t, r);
+    case w.ZodBranded:
+      return ze(t, r);
+    case w.ZodReadonly:
+      return Or(t, r);
+    case w.ZodCatch:
+      return sr(t, r);
+    case w.ZodPipeline:
+      return Cr(t, r);
+    case w.ZodFunction:
+    case w.ZodVoid:
+    case w.ZodSymbol:
+      return;
+    default:
+      return /* @__PURE__ */ ((s) => {
+      })();
+  }
+}, xr = (t, e) => {
+  let r = 0;
+  for (; r < t.length && r < e.length && t[r] === e[r]; r++)
+    ;
+  return [(t.length - r).toString(), ...e.slice(r)].join("/");
+};
+function S(t, e, r = !1) {
+  var s;
+  const n = e.seen.get(t);
+  if (e.override) {
+    const l = (s = e.override) == null ? void 0 : s.call(
+      e,
+      t,
+      e,
+      n,
+      r
+    );
+    if (l !== Qt)
+      return l;
+  }
+  if (n && !r) {
+    const l = Lr(n, e);
+    if (l !== void 0)
+      return l;
+  }
+  const a = { def: t, path: e.currentPath, jsonSchema: void 0 };
+  e.seen.set(t, a);
+  const i = Ir(t, t.typeName, e), u = typeof i == "function" ? S(i(), e) : i;
+  if (u && Ur(t, e, u), e.postProcess) {
+    const l = e.postProcess(u, t, e);
+    return a.jsonSchema = u, l;
+  }
+  return a.jsonSchema = u, u;
+}
+var Lr = (t, e) => {
+  switch (e.$refStrategy) {
+    case "root":
+      return { $ref: t.path.join("/") };
+    case "relative":
+      return { $ref: xr(e.currentPath, t.path) };
+    case "none":
+    case "seen":
+      return t.path.length < e.currentPath.length && t.path.every((r, s) => e.currentPath[s] === r) ? (console.warn(
+        `Recursive reference detected at ${e.currentPath.join(
+          "/"
+        )}! Defaulting to any`
+      ), E()) : e.$refStrategy === "seen" ? E() : void 0;
+  }
+}, Ur = (t, e, r) => (t.description && (r.description = t.description), r), $r = (t) => {
+  const e = Yt(t), r = e.name !== void 0 ? [...e.basePath, e.definitionPath, e.name] : e.basePath;
+  return {
+    ...e,
+    currentPath: r,
+    propertyPath: void 0,
+    seen: new Map(
+      Object.entries(e.definitions).map(([s, n]) => [
+        n._def,
+        {
+          def: n._def,
+          path: [...e.basePath, e.definitionPath, s],
+          // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+          jsonSchema: void 0
+        }
+      ])
+    )
+  };
+}, jr = (t, e) => {
+  var r;
+  const s = $r(e);
+  let n = typeof e == "object" && e.definitions ? Object.entries(e.definitions).reduce(
+    (c, [p, g]) => {
+      var d;
+      return {
+        ...c,
+        [p]: (d = S(
+          g._def,
+          {
+            ...s,
+            currentPath: [...s.basePath, s.definitionPath, p]
+          },
+          !0
+        )) != null ? d : E()
+      };
+    },
+    {}
+  ) : void 0;
+  const a = typeof e == "string" ? e : e?.nameStrategy === "title" ? void 0 : e?.name, i = (r = S(
+    t._def,
+    a === void 0 ? s : {
+      ...s,
+      currentPath: [...s.basePath, s.definitionPath, a]
+    },
+    !1
+  )) != null ? r : E(), u = typeof e == "object" && e.name !== void 0 && e.nameStrategy === "title" ? e.name : void 0;
+  u !== void 0 && (i.title = u);
+  const l = a === void 0 ? n ? {
+    ...i,
+    [s.definitionPath]: n
+  } : i : {
+    $ref: [
+      ...s.$refStrategy === "relative" ? [] : s.basePath,
+      s.definitionPath,
+      a
+    ].join("/"),
+    [s.definitionPath]: {
+      ...n,
+      [a]: i
+    }
+  };
+  return l.$schema = "http://json-schema.org/draft-07/schema#", l;
+}, fe = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
+function J(t, {
+  validate: e
+} = {}) {
+  return {
+    [fe]: !0,
+    _type: void 0,
+    // should never be used directly
+    get jsonSchema() {
+      return typeof t == "function" && (t = t()), t;
+    },
+    validate: e
+  };
+}
+function Nr(t) {
+  return typeof t == "object" && t !== null && fe in t && t[fe] === !0 && "jsonSchema" in t && "validate" in t;
+}
+function We(t) {
+  return t == null ? J({ properties: {}, additionalProperties: !1 }) : Nr(t) ? t : "~standard" in t ? t["~standard"].vendor === "zod" ? zr(t) : qr(t) : t();
+}
+function qr(t) {
+  return J(
+    () => ve(
+      t["~standard"].jsonSchema.input({
+        target: "draft-07"
+      })
+    ),
+    {
+      validate: async (e) => {
+        const r = await t["~standard"].validate(e);
+        return "value" in r ? { success: !0, value: r.value } : {
+          success: !1,
+          error: new pe({
+            value: e,
+            cause: r.issues
+          })
+        };
+      }
+    }
+  );
+}
+function Hr(t, e) {
+  var r;
+  const s = (r = void 0) != null ? r : !1;
+  return J(
+    // defer json schema creation to avoid unnecessary computation when only validation is needed
+    () => jr(t, {
+      $refStrategy: s ? "root" : "none"
+    }),
+    {
+      validate: async (n) => {
+        const a = await t.safeParseAsync(n);
+        return a.success ? { success: !0, value: a.data } : { success: !1, error: a.error };
+      }
+    }
+  );
+}
+function Zr(t, e) {
+  var r;
+  const s = (r = void 0) != null ? r : !1;
+  return J(
+    // defer json schema creation to avoid unnecessary computation when only validation is needed
+    () => ve(
+      Re.toJSONSchema(t, {
+        target: "draft-7",
+        io: "input",
+        reused: s ? "ref" : "inline"
+      })
+    ),
+    {
+      validate: async (n) => {
+        const a = await Re.safeParseAsync(t, n);
+        return a.success ? { success: !0, value: a.data } : { success: !1, error: a.error };
+      }
+    }
+  );
+}
+function Dr(t) {
+  return "_zod" in t;
+}
+function zr(t, e) {
+  return Dr(t) ? Zr(t) : Hr(t);
+}
+async function Be({
+  value: t,
+  schema: e,
+  context: r
+}) {
+  const s = We(e);
+  try {
+    if (s.validate == null)
+      return { success: !0, value: t, rawValue: t };
+    const n = await s.validate(t);
+    return n.success ? { success: !0, value: n.value, rawValue: t } : {
+      success: !1,
+      error: pe.wrap({ value: t, cause: n.error, context: r }),
+      rawValue: t
+    };
+  } catch (n) {
+    return {
+      success: !1,
+      error: pe.wrap({ value: t, cause: n, context: r }),
+      rawValue: t
+    };
+  }
+}
+async function Fr({
+  text: t,
+  schema: e
+}) {
+  try {
+    const r = Xt(t);
+    return e == null ? { success: !0, value: r, rawValue: r } : await Be({ value: r, schema: e });
+  } catch (r) {
+    return {
+      success: !1,
+      error: Ce.isInstance(r) ? r : new Ce({ text: t, cause: r }),
+      rawValue: void 0
+    };
+  }
+}
+function Vr(t) {
+  return { ...t, type: "dynamic" };
+}
+let we;
+we = globalThis.crypto;
+async function Jr(t) {
+  return (await we).getRandomValues(new Uint8Array(t));
+}
+async function Wr(t) {
+  const e = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~", r = Math.pow(2, 8) - Math.pow(2, 8) % e.length;
+  let s = "";
+  for (; s.length < t; ) {
+    const n = await Jr(t - s.length);
+    for (const a of n)
+      a < r && (s += e[a % e.length]);
+  }
+  return s;
+}
+async function Br(t) {
+  return await Wr(t);
+}
+async function Gr(t) {
+  const e = await (await we).subtle.digest("SHA-256", new TextEncoder().encode(t));
+  return btoa(String.fromCharCode(...new Uint8Array(e))).replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, "");
+}
+async function Kr(t) {
+  if (t || (t = 43), t < 43 || t > 128)
+    throw `Expected a length between 43 and 128. Received ${t}.`;
+  const e = await Br(t), r = await Gr(e);
+  return {
+    code_verifier: e,
+    code_challenge: r
+  };
+}
+var Xr = "AI_MCPClientError", Ge = `vercel.ai.error.${Xr}`, Qr = Symbol.for(Ge), Oe, Ie, _ = class extends (Ie = K, Oe = Qr, Ie) {
+  constructor({
+    name: t = "MCPClientError",
+    message: e,
+    cause: r,
+    data: s,
+    code: n
+  }) {
+    super({ name: t, message: e, cause: r }), this[Oe] = !0, this.data = s, this.code = n;
+  }
+  static isInstance(t) {
+    return K.hasMarker(t, Ge);
+  }
+}, D = "2025-11-25", Yr = [
+  D,
+  "2025-06-18",
+  "2025-03-26",
+  "2024-11-05"
+], es = o.optional(o.record(o.string(), o.unknown())), ts = o.looseObject({
+  name: o.string(),
+  version: o.string()
+}), oe = o.looseObject({
+  _meta: o.optional(o.object({}).loose())
+}), $ = oe, Ke = o.object({
+  method: o.string(),
+  params: o.optional(oe)
+}), Xe = o.object({
+  applyDefaults: o.optional(o.boolean())
+}).loose(), rs = o.looseObject({
+  experimental: o.optional(o.object({}).loose()),
+  logging: o.optional(o.object({}).loose()),
+  prompts: o.optional(
+    o.looseObject({
+      listChanged: o.optional(o.boolean())
+    })
+  ),
+  resources: o.optional(
+    o.looseObject({
+      subscribe: o.optional(o.boolean()),
+      listChanged: o.optional(o.boolean())
+    })
+  ),
+  tools: o.optional(
+    o.looseObject({
+      listChanged: o.optional(o.boolean())
+    })
+  ),
+  elicitation: o.optional(Xe)
+});
+o.object({
+  elicitation: o.optional(Xe)
+}).loose();
+var ss = $.extend({
+  protocolVersion: o.string(),
+  capabilities: rs,
+  serverInfo: ts,
+  instructions: o.optional(o.string())
+}), _e = $.extend({
+  nextCursor: o.optional(o.string())
+}), ns = o.object({
+  name: o.string(),
+  /**
+   * @see https://modelcontextprotocol.io/specification/2025-11-25/server/tools#tool
+   */
+  title: o.optional(o.string()),
+  description: o.optional(o.string()),
+  inputSchema: o.object({
+    type: o.literal("object"),
+    properties: o.optional(o.object({}).loose())
+  }).loose(),
+  /**
+   * @see https://modelcontextprotocol.io/specification/2025-06-18/server/tools#output-schema
+   */
+  outputSchema: o.optional(o.object({}).loose()),
+  annotations: o.optional(
+    o.object({
+      title: o.optional(o.string())
+    }).loose()
+  ),
+  _meta: es
+}).loose(), os = _e.extend({
+  tools: o.array(ns)
+}), Qe = o.object({
+  type: o.literal("text"),
+  text: o.string()
+}).loose(), Ye = o.object({
+  type: o.literal("image"),
+  data: o.base64(),
+  mimeType: o.string()
+}).loose(), as = o.object({
+  uri: o.string(),
+  name: o.string(),
+  title: o.optional(o.string()),
+  description: o.optional(o.string()),
+  mimeType: o.optional(o.string()),
+  size: o.optional(o.number())
+}).loose(), is = _e.extend({
+  resources: o.array(as)
+}), et = o.object({
+  /**
+   * The URI of this resource.
+   */
+  uri: o.string(),
+  /**
+   * Optional display name of the resource content.
+   */
+  name: o.optional(o.string()),
+  /**
+   * Optional human readable title.
+   */
+  title: o.optional(o.string()),
+  /**
+   * The MIME type of this resource, if known.
+   */
+  mimeType: o.optional(o.string())
+}).loose(), tt = et.extend({
+  text: o.string()
+}), rt = et.extend({
+  blob: o.base64()
+}), st = o.object({
+  type: o.literal("resource"),
+  resource: o.union([tt, rt])
+}).loose(), cs = $.extend({
+  content: o.array(
+    o.union([Qe, Ye, st])
+  ),
+  /**
+   * @see https://modelcontextprotocol.io/specification/2025-06-18/server/tools#structured-content
+   */
+  structuredContent: o.optional(o.unknown()),
+  isError: o.boolean().default(!1).optional()
+}).or(
+  $.extend({
+    toolResult: o.unknown()
+  })
+), ls = o.object({
+  uriTemplate: o.string(),
+  name: o.string(),
+  title: o.optional(o.string()),
+  description: o.optional(o.string()),
+  mimeType: o.optional(o.string())
+}).loose(), us = $.extend({
+  resourceTemplates: o.array(ls)
+}), ds = $.extend({
+  contents: o.array(
+    o.union([tt, rt])
+  )
+}), ps = o.object({
+  name: o.string(),
+  description: o.optional(o.string()),
+  required: o.optional(o.boolean())
+}).loose(), hs = o.object({
+  name: o.string(),
+  title: o.optional(o.string()),
+  description: o.optional(o.string()),
+  arguments: o.optional(o.array(ps))
+}).loose(), ms = _e.extend({
+  prompts: o.array(hs)
+}), fs = o.object({
+  role: o.union([o.literal("user"), o.literal("assistant")]),
+  content: o.union([
+    Qe,
+    Ye,
+    st
+  ])
+}).loose(), gs = $.extend({
+  description: o.optional(o.string()),
+  messages: o.array(fs)
+}), ys = oe.extend({
+  message: o.string(),
+  requestedSchema: o.unknown()
+}), xe = Ke.extend({
+  method: o.literal("elicitation/create"),
+  params: ys
+}), vs = $.extend({
+  action: o.union([
+    o.literal("accept"),
+    o.literal("decline"),
+    o.literal("cancel")
+  ]),
+  content: o.optional(o.record(o.string(), o.unknown()))
+}), ae = "2.0", ws = o.object({
+  jsonrpc: o.literal(ae),
+  id: o.union([o.string(), o.number().int()])
+}).merge(Ke).strict(), _s = o.object({
+  jsonrpc: o.literal(ae),
+  id: o.union([o.string(), o.number().int()]),
+  result: $
+}).strict(), bs = o.object({
+  jsonrpc: o.literal(ae),
+  id: o.union([o.string(), o.number().int()]),
+  error: o.object({
+    code: o.number().int(),
+    message: o.string(),
+    data: o.optional(o.unknown())
+  })
+}).strict(), Ss = o.object({
+  jsonrpc: o.literal(ae)
+}).merge(
+  o.object({
+    method: o.string(),
+    params: o.optional(oe)
+  })
+).strict(), V = o.union([
+  ws,
+  Ss,
+  _s,
+  bs
+]), nt = typeof __PACKAGE_VERSION__ < "u" ? __PACKAGE_VERSION__ : "0.0.0-test", ot = o.object({
+  access_token: o.string(),
+  id_token: o.string().optional(),
+  // Optional for OAuth 2.1, but necessary in OpenID Connect
+  token_type: o.string(),
+  expires_in: o.number().optional(),
+  scope: o.string().optional(),
+  refresh_token: o.string().optional()
+}).strip(), R = o.string().url().superRefine((t, e) => {
+  if (!URL.canParse(t))
+    return e.addIssue({
+      code: o.ZodIssueCode.custom,
+      message: "URL must be parseable",
+      fatal: !0
+    }), o.NEVER;
+}).refine(
+  (t) => {
+    const e = new URL(t);
+    return e.protocol !== "javascript:" && e.protocol !== "data:" && e.protocol !== "vbscript:";
+  },
+  { message: "URL cannot use javascript:, data:, or vbscript: scheme" }
+), Ts = o.object({
+  resource: o.string().url(),
+  authorization_servers: o.array(R).optional(),
+  jwks_uri: o.string().url().optional(),
+  scopes_supported: o.array(o.string()).optional(),
+  bearer_methods_supported: o.array(o.string()).optional(),
+  resource_signing_alg_values_supported: o.array(o.string()).optional(),
+  resource_name: o.string().optional(),
+  resource_documentation: o.string().optional(),
+  resource_policy_uri: o.string().url().optional(),
+  resource_tos_uri: o.string().url().optional(),
+  tls_client_certificate_bound_access_tokens: o.boolean().optional(),
+  authorization_details_types_supported: o.array(o.string()).optional(),
+  dpop_signing_alg_values_supported: o.array(o.string()).optional(),
+  dpop_bound_access_tokens_required: o.boolean().optional()
+}).passthrough(), at = o.object({
+  issuer: o.string(),
+  authorization_endpoint: R,
+  token_endpoint: R,
+  registration_endpoint: R.optional(),
+  scopes_supported: o.array(o.string()).optional(),
+  response_types_supported: o.array(o.string()),
+  grant_types_supported: o.array(o.string()).optional(),
+  code_challenge_methods_supported: o.array(o.string()),
+  token_endpoint_auth_methods_supported: o.array(o.string()).optional(),
+  token_endpoint_auth_signing_alg_values_supported: o.array(o.string()).optional()
+}).passthrough(), Ps = o.object({
+  issuer: o.string(),
+  authorization_endpoint: R,
+  token_endpoint: R,
+  userinfo_endpoint: R.optional(),
+  jwks_uri: R,
+  registration_endpoint: R.optional(),
+  scopes_supported: o.array(o.string()).optional(),
+  response_types_supported: o.array(o.string()),
+  grant_types_supported: o.array(o.string()).optional(),
+  subject_types_supported: o.array(o.string()),
+  id_token_signing_alg_values_supported: o.array(o.string()),
+  claims_supported: o.array(o.string()).optional(),
+  token_endpoint_auth_methods_supported: o.array(o.string()).optional()
+}).passthrough(), Cs = Ps.merge(
+  at.pick({
+    code_challenge_methods_supported: !0
+  })
+), Rs = o.object({
+  client_id: o.string(),
+  client_secret: o.string().optional(),
+  client_id_issued_at: o.number().optional(),
+  client_secret_expires_at: o.number().optional()
+}).strip(), Ms = o.object({
+  redirect_uris: o.array(R),
+  token_endpoint_auth_method: o.string().optional(),
+  grant_types: o.array(o.string()).optional(),
+  response_types: o.array(o.string()).optional(),
+  client_name: o.string().optional(),
+  client_uri: R.optional(),
+  logo_uri: R.optional(),
+  scope: o.string().optional(),
+  contacts: o.array(o.string()).optional(),
+  tos_uri: R.optional(),
+  policy_uri: o.string().optional(),
+  jwks_uri: R.optional(),
+  jwks: o.any().optional(),
+  software_id: o.string().optional(),
+  software_version: o.string().optional(),
+  software_statement: o.string().optional()
+}).strip(), Es = o.object({
+  error: o.string(),
+  error_description: o.string().optional(),
+  error_uri: o.string().optional()
+}), As = Ms.merge(
+  Rs
+), ks = "AI_MCPClientOAuthError", it = `vercel.ai.error.${ks}`, Os = Symbol.for(it), Le, Ue, W = class extends (Ue = K, Le = Os, Ue) {
+  constructor({
+    name: t = "MCPClientOAuthError",
+    message: e,
+    cause: r
+  }) {
+    super({ name: t, message: e, cause: r }), this[Le] = !0;
+  }
+  static isInstance(t) {
+    return K.hasMarker(t, it);
+  }
+}, Z = class extends W {
+};
+Z.errorCode = "server_error";
+var X = class extends W {
+};
+X.errorCode = "invalid_client";
+var Q = class extends W {
+};
+Q.errorCode = "invalid_grant";
+var Y = class extends W {
+};
+Y.errorCode = "unauthorized_client";
+var Is = {
+  [Z.errorCode]: Z,
+  [X.errorCode]: X,
+  [Q.errorCode]: Q,
+  [Y.errorCode]: Y
+};
+function xs(t) {
+  const e = typeof t == "string" ? new URL(t) : new URL(t.href);
+  return e.hash = "", e;
+}
+function Ls({
+  requestedResource: t,
+  configuredResource: e
+}) {
+  const r = typeof t == "string" ? new URL(t) : new URL(t.href), s = typeof e == "string" ? new URL(e) : new URL(e.href);
+  if (r.origin !== s.origin || r.pathname.length < s.pathname.length)
+    return !1;
+  const n = r.pathname.endsWith("/") ? r.pathname : r.pathname + "/", a = s.pathname.endsWith("/") ? s.pathname : s.pathname + "/";
+  return n.startsWith(a);
+}
+var ee = class extends Error {
+  constructor(t = "Unauthorized") {
+    super(t), this.name = "UnauthorizedError";
+  }
+};
+function te(t) {
+  var e;
+  const r = (e = t.headers.get("www-authenticate")) != null ? e : t.headers.get("WWW-Authenticate");
+  if (!r)
+    return;
+  const [s, n] = r.split(" ");
+  if (s.toLowerCase() !== "bearer" || !n)
+    return;
+  const a = /resource_metadata="([^"]*)"/, i = r.match(a);
+  if (i)
+    try {
+      return new URL(i[1]);
+    } catch {
+      return;
+    }
+}
+function Us(t, e = "", r = {}) {
+  return e.endsWith("/") && (e = e.slice(0, -1)), r.prependPathname ? `${e}/.well-known/${t}` : `/.well-known/${t}${e}`;
+}
+async function be(t, e, r = fetch) {
+  try {
+    return await r(t, { headers: e });
+  } catch (s) {
+    if (s instanceof TypeError)
+      return e ? be(t, void 0, r) : void 0;
+    throw s;
+  }
+}
+async function $e(t, e, r = fetch) {
+  return await be(t, {
+    "MCP-Protocol-Version": e
+  }, r);
+}
+function $s(t, e) {
+  return !t || t.status >= 400 && t.status < 500 && e !== "/";
+}
+async function js(t, e, r, s) {
+  var n, a;
+  const i = new URL(t), u = (n = s?.protocolVersion) != null ? n : D;
+  let l;
+  if (s?.metadataUrl)
+    l = new URL(s.metadataUrl);
+  else {
+    const p = Us(e, i.pathname);
+    l = new URL(p, (a = s?.metadataServerUrl) != null ? a : i), l.search = i.search;
+  }
+  let c = await $e(l, u, r);
+  if (!s?.metadataUrl && $s(c, i.pathname)) {
+    const p = new URL(`/.well-known/${e}`, i);
+    c = await $e(p, u, r);
+  }
+  return c;
+}
+async function Ns(t, e, r = fetch) {
+  const s = await js(
+    t,
+    "oauth-protected-resource",
+    r,
+    {
+      protocolVersion: e?.protocolVersion,
+      metadataUrl: e?.resourceMetadataUrl
+    }
+  );
+  if (!s || s.status === 404)
+    throw new Error(
+      "Resource server does not implement OAuth 2.0 Protected Resource Metadata."
+    );
+  if (!s.ok)
+    throw new Error(
+      `HTTP ${s.status} trying to load well-known OAuth protected resource metadata.`
+    );
+  return Ts.parse(await s.json());
+}
+function qs(t) {
+  const e = typeof t == "string" ? new URL(t) : t, r = e.pathname !== "/", s = [];
+  if (!r)
+    return s.push({
+      url: new URL("/.well-known/oauth-authorization-server", e.origin),
+      type: "oauth"
+    }), s.push({
+      url: new URL("/.well-known/openid-configuration", e.origin),
+      type: "oidc"
+    }), s;
+  let n = e.pathname;
+  return n.endsWith("/") && (n = n.slice(0, -1)), s.push({
+    url: new URL(
+      `/.well-known/oauth-authorization-server${n}`,
+      e.origin
+    ),
+    type: "oauth"
+  }), s.push({
+    url: new URL("/.well-known/oauth-authorization-server", e.origin),
+    type: "oauth"
+  }), s.push({
+    url: new URL(`/.well-known/openid-configuration${n}`, e.origin),
+    type: "oidc"
+  }), s.push({
+    url: new URL(`${n}/.well-known/openid-configuration`, e.origin),
+    type: "oidc"
+  }), s;
+}
+async function Hs(t, {
+  fetchFn: e = fetch,
+  protocolVersion: r = D
+} = {}) {
+  var s;
+  const n = { "MCP-Protocol-Version": r }, a = qs(t);
+  for (const { url: i, type: u } of a) {
+    const l = await be(i, n, e);
+    if (l) {
+      if (!l.ok) {
+        if (l.status >= 400 && l.status < 500)
+          continue;
+        throw new Error(
+          `HTTP ${l.status} trying to load ${u === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${i}`
+        );
+      }
+      if (u === "oauth")
+        return at.parse(await l.json());
+      {
+        const c = Cs.parse(
+          await l.json()
+        );
+        if (!((s = c.code_challenge_methods_supported) != null && s.includes("S256")))
+          throw new Error(
+            `Incompatible OIDC provider at ${i}: does not support S256 code challenge method required by MCP specification`
+          );
+        return c;
+      }
+    }
+  }
+}
+async function Zs(t, {
+  metadata: e,
+  clientInformation: r,
+  redirectUrl: s,
+  scope: n,
+  state: a,
+  resource: i
+}) {
+  const u = "code", l = "S256";
+  let c;
+  if (e) {
+    if (c = new URL(e.authorization_endpoint), !e.response_types_supported.includes(u))
+      throw new Error(
+        `Incompatible auth server: does not support response type ${u}`
+      );
+    if (!e.code_challenge_methods_supported || !e.code_challenge_methods_supported.includes(l))
+      throw new Error(
+        `Incompatible auth server: does not support code challenge method ${l}`
+      );
+  } else
+    c = new URL("/authorize", t);
+  const p = await Kr(), g = p.code_verifier, d = p.code_challenge;
+  return c.searchParams.set("response_type", u), c.searchParams.set("client_id", r.client_id), c.searchParams.set("code_challenge", d), c.searchParams.set(
+    "code_challenge_method",
+    l
+  ), c.searchParams.set("redirect_uri", String(s)), a && c.searchParams.set("state", a), n && c.searchParams.set("scope", n), n?.includes("offline_access") && c.searchParams.append("prompt", "consent"), i && c.searchParams.set("resource", i.href), { authorizationUrl: c, codeVerifier: g };
+}
+function ct(t, e) {
+  const r = t.client_secret !== void 0;
+  return e.length === 0 ? r ? "client_secret_post" : "none" : r && e.includes("client_secret_basic") ? "client_secret_basic" : r && e.includes("client_secret_post") ? "client_secret_post" : e.includes("none") ? "none" : r ? "client_secret_post" : "none";
+}
+function lt(t, e, r, s) {
+  const { client_id: n, client_secret: a } = e;
+  switch (t) {
+    case "client_secret_basic":
+      Ds(n, a, r);
+      return;
+    case "client_secret_post":
+      zs(n, a, s);
+      return;
+    case "none":
+      Fs(n, s);
+      return;
+    default:
+      throw new Error(`Unsupported client authentication method: ${t}`);
+  }
+}
+function Ds(t, e, r) {
+  if (!e)
+    throw new Error(
+      "client_secret_basic authentication requires a client_secret"
+    );
+  const s = btoa(`${t}:${e}`);
+  r.set("Authorization", `Basic ${s}`);
+}
+function zs(t, e, r) {
+  r.set("client_id", t), e && r.set("client_secret", e);
+}
+function Fs(t, e) {
+  e.set("client_id", t);
+}
+async function Se(t) {
+  const e = t instanceof Response ? t.status : void 0, r = t instanceof Response ? await t.text() : t;
+  try {
+    const s = Es.parse(JSON.parse(r)), { error: n, error_description: a, error_uri: i } = s, u = Is[n] || Z;
+    return new u({
+      message: a || "",
+      cause: i
+    });
+  } catch (s) {
+    const n = `${e ? `HTTP ${e}: ` : ""}Invalid OAuth error response: ${s}. Raw body: ${r}`;
+    return new Z({ message: n });
+  }
+}
+async function Vs(t, {
+  metadata: e,
+  clientInformation: r,
+  authorizationCode: s,
+  codeVerifier: n,
+  redirectUri: a,
+  resource: i,
+  addClientAuthentication: u,
+  fetchFn: l
+}) {
+  var c;
+  const p = "authorization_code", g = e?.token_endpoint ? new URL(e.token_endpoint) : new URL("/token", t);
+  if (e?.grant_types_supported && !e.grant_types_supported.includes(p))
+    throw new Error(
+      `Incompatible auth server: does not support grant type ${p}`
+    );
+  const d = new Headers({
+    "Content-Type": "application/x-www-form-urlencoded",
+    Accept: "application/json"
+  }), m = new URLSearchParams({
+    grant_type: p,
+    code: s,
+    code_verifier: n,
+    redirect_uri: String(a)
+  });
+  if (u)
+    u(d, m, t, e);
+  else {
+    const h = (c = e?.token_endpoint_auth_methods_supported) != null ? c : [], f = ct(
+      r,
+      h
+    );
+    lt(f, r, d, m);
+  }
+  i && m.set("resource", i.href);
+  const y = await (l ?? fetch)(g, {
+    method: "POST",
+    headers: d,
+    body: m
+  });
+  if (!y.ok)
+    throw await Se(y);
+  return ot.parse(await y.json());
+}
+async function Js(t, {
+  metadata: e,
+  clientInformation: r,
+  refreshToken: s,
+  resource: n,
+  addClientAuthentication: a,
+  fetchFn: i
+}) {
+  var u;
+  const l = "refresh_token";
+  let c;
+  if (e) {
+    if (c = new URL(e.token_endpoint), e.grant_types_supported && !e.grant_types_supported.includes(l))
+      throw new Error(
+        `Incompatible auth server: does not support grant type ${l}`
+      );
+  } else
+    c = new URL("/token", t);
+  const p = new Headers({
+    "Content-Type": "application/x-www-form-urlencoded",
+    Accept: "application/json"
+  }), g = new URLSearchParams({
+    grant_type: l,
+    refresh_token: s
+  });
+  if (a)
+    a(p, g, t, e);
+  else {
+    const m = (u = e?.token_endpoint_auth_methods_supported) != null ? u : [], y = ct(
+      r,
+      m
+    );
+    lt(y, r, p, g);
+  }
+  n && g.set("resource", n.href);
+  const d = await (i ?? fetch)(c, {
+    method: "POST",
+    headers: p,
+    body: g
+  });
+  if (!d.ok)
+    throw await Se(d);
+  return ot.parse({
+    refresh_token: s,
+    ...await d.json()
+  });
+}
+async function Ws(t, {
+  metadata: e,
+  clientMetadata: r,
+  fetchFn: s
+}) {
+  let n;
+  if (e) {
+    if (!e.registration_endpoint)
+      throw new Error(
+        "Incompatible auth server: does not support dynamic client registration"
+      );
+    n = new URL(e.registration_endpoint);
+  } else
+    n = new URL("/register", t);
+  const a = await (s ?? fetch)(n, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(r)
+  });
+  if (!a.ok)
+    throw await Se(a);
+  return As.parse(await a.json());
+}
+async function re(t, e) {
+  var r, s;
+  try {
+    return await de(t, e);
+  } catch (n) {
+    if (n instanceof X || n instanceof Y)
+      return await ((r = t.invalidateCredentials) == null ? void 0 : r.call(t, "all")), await de(t, e);
+    if (n instanceof Q)
+      return await ((s = t.invalidateCredentials) == null ? void 0 : s.call(t, "tokens")), await de(t, e);
+    throw n;
+  }
+}
+async function Bs(t, e, r) {
+  const s = xs(t);
+  if (e.validateResourceURL)
+    return await e.validateResourceURL(
+      s,
+      r?.resource
+    );
+  if (r) {
+    if (!Ls({
+      requestedResource: s,
+      configuredResource: r.resource
+    }))
+      throw new Error(
+        `Protected resource ${r.resource} does not match expected ${s} (or origin)`
+      );
+    return new URL(r.resource);
+  }
+}
+async function de(t, {
+  serverUrl: e,
+  authorizationCode: r,
+  callbackState: s,
+  scope: n,
+  resourceMetadataUrl: a,
+  fetchFn: i
+}) {
+  let u, l;
+  try {
+    u = await Ns(
+      e,
+      { resourceMetadataUrl: a },
+      i
+    ), u.authorization_servers && u.authorization_servers.length > 0 && (l = u.authorization_servers[0]);
+  } catch {
+  }
+  l || (l = e);
+  const c = await Bs(
+    e,
+    t,
+    u
+  ), p = await Hs(
+    l,
+    {
+      fetchFn: i
+    }
+  );
+  let g = await Promise.resolve(t.clientInformation());
+  if (!g) {
+    if (r !== void 0)
+      throw new Error(
+        "Existing OAuth client information is required when exchanging an authorization code"
+      );
+    if (!t.saveClientInformation)
+      throw new Error(
+        "OAuth client information must be saveable for dynamic registration"
+      );
+    const f = await Ws(l, {
+      metadata: p,
+      clientMetadata: t.clientMetadata,
+      fetchFn: i
+    });
+    await t.saveClientInformation(f), g = f;
+  }
+  if (r !== void 0) {
+    if (t.storedState) {
+      const b = await t.storedState();
+      if (b !== void 0 && b !== s)
+        throw new Error(
+          "OAuth state parameter mismatch - possible CSRF attack"
+        );
+    }
+    const f = await t.codeVerifier(), v = await Vs(l, {
+      metadata: p,
+      clientInformation: g,
+      authorizationCode: r,
+      codeVerifier: f,
+      redirectUri: t.redirectUrl,
+      resource: c,
+      addClientAuthentication: t.addClientAuthentication,
+      fetchFn: i
+    });
+    return await t.saveTokens(v), "AUTHORIZED";
+  }
+  const d = await t.tokens();
+  if (d?.refresh_token)
+    try {
+      const f = await Js(l, {
+        metadata: p,
+        clientInformation: g,
+        refreshToken: d.refresh_token,
+        resource: c,
+        addClientAuthentication: t.addClientAuthentication,
+        fetchFn: i
+      });
+      return await t.saveTokens(f), "AUTHORIZED";
+    } catch (f) {
+      if (
+        // If this is a ServerError, or an unknown type, log it out and try to continue. Otherwise, escalate so we can fix things and retry.
+        !(!(f instanceof W) || f instanceof Z)
+      ) throw f;
+    }
+  const m = t.state ? await t.state() : void 0;
+  m && t.saveState && await t.saveState(m);
+  const { authorizationUrl: y, codeVerifier: h } = await Zs(
+    l,
+    {
+      metadata: p,
+      clientInformation: g,
+      state: m,
+      redirectUrl: t.redirectUrl,
+      scope: n || t.clientMetadata.scope,
+      resource: c
+    }
+  );
+  return await t.saveCodeVerifier(h), await t.redirectToAuthorization(y), "REDIRECT";
+}
+var Gs = class {
+  constructor({
+    url: t,
+    headers: e,
+    authProvider: r,
+    redirect: s = "follow"
+  }) {
+    this.connected = !1, this.url = new URL(t), this.headers = e, this.authProvider = r, this.redirectMode = s;
+  }
+  async commonHeaders(t) {
+    const e = {
+      ...this.headers,
+      ...t,
+      "mcp-protocol-version": D
+    };
+    if (this.authProvider) {
+      const r = await this.authProvider.tokens();
+      r?.access_token && (e.Authorization = `Bearer ${r.access_token}`);
+    }
+    return De(
+      e,
+      `ai-sdk/${nt}`,
+      Ze()
+    );
+  }
+  async start() {
+    return new Promise((t, e) => {
+      if (this.connected)
+        return t();
+      this.abortController = new AbortController();
+      const r = async (s = !1) => {
+        var n, a, i, u, l;
+        try {
+          const c = await this.commonHeaders({
+            Accept: "text/event-stream"
+          }), p = await fetch(this.url.href, {
+            headers: c,
+            signal: (n = this.abortController) == null ? void 0 : n.signal,
+            redirect: this.redirectMode
+          });
+          if (p.status === 401 && this.authProvider && !s) {
+            this.resourceMetadataUrl = te(p);
+            try {
+              if (await re(this.authProvider, {
+                serverUrl: this.url,
+                resourceMetadataUrl: this.resourceMetadataUrl
+              }) !== "AUTHORIZED") {
+                const h = new ee();
+                return (a = this.onerror) == null || a.call(this, h), e(h);
+              }
+            } catch (y) {
+              return (i = this.onerror) == null || i.call(this, y), e(y);
+            }
+            return r(!0);
+          }
+          if (!p.ok || !p.body) {
+            let y = `MCP SSE Transport Error: ${p.status} ${p.statusText}`;
+            p.status === 405 && (y += ". This server does not support SSE transport. Try using `http` transport instead");
+            const h = new _({
+              message: y
+            });
+            return (u = this.onerror) == null || u.call(this, h), e(h);
+          }
+          const d = p.body.pipeThrough(new TextDecoderStream()).pipeThrough(new he()).getReader(), m = async () => {
+            var y, h, f;
+            try {
+              for (; ; ) {
+                const { done: v, value: b } = await d.read();
+                if (v) {
+                  if (this.connected)
+                    throw this.connected = !1, new _({
+                      message: "MCP SSE Transport Error: Connection closed unexpectedly"
+                    });
+                  return;
+                }
+                const { event: T, data: A } = b;
+                if (T === "endpoint") {
+                  if (this.endpoint = new URL(A, this.url), this.endpoint.origin !== this.url.origin)
+                    throw new _({
+                      message: `MCP SSE Transport Error: Endpoint origin does not match connection origin: ${this.endpoint.origin}`
+                    });
+                  this.connected = !0, t();
+                } else if (T === "message")
+                  try {
+                    const M = V.parse(
+                      JSON.parse(A)
+                    );
+                    (y = this.onmessage) == null || y.call(this, M);
+                  } catch (M) {
+                    const k = new _({
+                      message: "MCP SSE Transport Error: Failed to parse message",
+                      cause: M
+                    });
+                    (h = this.onerror) == null || h.call(this, k);
+                  }
+              }
+            } catch (v) {
+              if (v instanceof Error && v.name === "AbortError")
+                return;
+              (f = this.onerror) == null || f.call(this, v), e(v);
+            }
+          };
+          this.sseConnection = {
+            close: () => d.cancel()
+          }, m();
+        } catch (c) {
+          if (c instanceof Error && c.name === "AbortError")
+            return;
+          (l = this.onerror) == null || l.call(this, c), e(c);
+        }
+      };
+      r();
+    });
+  }
+  async close() {
+    var t, e, r;
+    this.connected = !1, (t = this.sseConnection) == null || t.close(), (e = this.abortController) == null || e.abort(), (r = this.onclose) == null || r.call(this);
+  }
+  async send(t) {
+    if (!this.endpoint || !this.connected)
+      throw new _({
+        message: "MCP SSE Transport Error: Not connected"
+      });
+    const e = this.endpoint, r = async (s = !1) => {
+      var n, a, i, u, l;
+      try {
+        const p = {
+          method: "POST",
+          headers: await this.commonHeaders({
+            "Content-Type": "application/json"
+          }),
+          body: JSON.stringify(t),
+          signal: (n = this.abortController) == null ? void 0 : n.signal,
+          redirect: this.redirectMode
+        }, g = await fetch(e, p);
+        if (g.status === 401 && this.authProvider && !s) {
+          this.resourceMetadataUrl = te(g);
+          try {
+            if (await re(this.authProvider, {
+              serverUrl: this.url,
+              resourceMetadataUrl: this.resourceMetadataUrl
+            }) !== "AUTHORIZED") {
+              const m = new ee();
+              (a = this.onerror) == null || a.call(this, m);
+              return;
+            }
+          } catch (d) {
+            (i = this.onerror) == null || i.call(this, d);
+            return;
+          }
+          return r(!0);
+        }
+        if (!g.ok) {
+          const d = await g.text().catch(() => null), m = new _({
+            message: `MCP SSE Transport Error: POSTing to endpoint (HTTP ${g.status}): ${d}`
+          });
+          (u = this.onerror) == null || u.call(this, m);
+          return;
+        }
+      } catch (c) {
+        (l = this.onerror) == null || l.call(this, c);
+        return;
+      }
+    };
+    await r();
+  }
+}, Ks = class {
+  constructor({
+    url: t,
+    headers: e,
+    authProvider: r,
+    redirect: s = "follow"
+  }) {
+    this.inboundReconnectAttempts = 0, this.reconnectionOptions = {
+      initialReconnectionDelay: 1e3,
+      maxReconnectionDelay: 3e4,
+      reconnectionDelayGrowFactor: 1.5,
+      maxRetries: 2
+    }, this.url = new URL(t), this.headers = e, this.authProvider = r, this.redirectMode = s;
+  }
+  async commonHeaders(t) {
+    const e = {
+      ...this.headers,
+      ...t,
+      "mcp-protocol-version": D
+    };
+    if (this.sessionId && (e["mcp-session-id"] = this.sessionId), this.authProvider) {
+      const r = await this.authProvider.tokens();
+      r?.access_token && (e.Authorization = `Bearer ${r.access_token}`);
+    }
+    return De(
+      e,
+      `ai-sdk/${nt}`,
+      Ze()
+    );
+  }
+  async start() {
+    if (this.abortController)
+      throw new _({
+        message: "MCP HTTP Transport Error: Transport already started. Note: client.connect() calls start() automatically."
+      });
+    this.abortController = new AbortController(), this.openInboundSse();
+  }
+  async close() {
+    var t, e, r;
+    (t = this.inboundSseConnection) == null || t.close();
+    try {
+      if (this.sessionId && this.abortController && !this.abortController.signal.aborted) {
+        const s = await this.commonHeaders({});
+        await fetch(this.url, {
+          method: "DELETE",
+          headers: s,
+          signal: this.abortController.signal,
+          redirect: this.redirectMode
+        }).catch(() => {
+        });
+      }
+    } catch {
+    }
+    (e = this.abortController) == null || e.abort(), (r = this.onclose) == null || r.call(this);
+  }
+  async send(t) {
+    const e = async (r = !1) => {
+      var s, n, a, i, u, l, c;
+      try {
+        const g = {
+          method: "POST",
+          headers: await this.commonHeaders({
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream"
+          }),
+          body: JSON.stringify(t),
+          signal: (s = this.abortController) == null ? void 0 : s.signal,
+          redirect: this.redirectMode
+        }, d = await fetch(this.url, g), m = d.headers.get("mcp-session-id");
+        if (m && (this.sessionId = m), d.status === 401 && this.authProvider && !r) {
+          this.resourceMetadataUrl = te(d);
+          try {
+            if (await re(this.authProvider, {
+              serverUrl: this.url,
+              resourceMetadataUrl: this.resourceMetadataUrl
+            }) !== "AUTHORIZED")
+              throw new ee();
+          } catch (v) {
+            throw (n = this.onerror) == null || n.call(this, v), v;
+          }
+          return e(!0);
+        }
+        if (d.status === 202) {
+          this.inboundSseConnection || this.openInboundSse();
+          return;
+        }
+        if (!d.ok) {
+          const v = await d.text().catch(() => null);
+          let b = `MCP HTTP Transport Error: POSTing to endpoint (HTTP ${d.status}): ${v}`;
+          d.status === 404 && (b += ". This server does not support HTTP transport. Try using `sse` transport instead");
+          const T = new _({
+            message: b
+          });
+          throw (a = this.onerror) == null || a.call(this, T), T;
+        }
+        if (!("id" in t))
+          return;
+        const h = d.headers.get("content-type") || "";
+        if (h.includes("application/json")) {
+          const v = await d.json(), b = Array.isArray(v) ? v.map((T) => V.parse(T)) : [V.parse(v)];
+          for (const T of b) (i = this.onmessage) == null || i.call(this, T);
+          return;
+        }
+        if (h.includes("text/event-stream")) {
+          if (!d.body) {
+            const A = new _({
+              message: "MCP HTTP Transport Error: text/event-stream response without body"
+            });
+            throw (u = this.onerror) == null || u.call(this, A), A;
+          }
+          const b = d.body.pipeThrough(new TextDecoderStream()).pipeThrough(new he()).getReader();
+          (async () => {
+            var A, M, k;
+            try {
+              for (; ; ) {
+                const { done: O, value: H } = await b.read();
+                if (O) return;
+                const { event: I, data: j } = H;
+                if (I === "message")
+                  try {
+                    const z = V.parse(JSON.parse(j));
+                    (A = this.onmessage) == null || A.call(this, z);
+                  } catch (z) {
+                    const x = new _({
+                      message: "MCP HTTP Transport Error: Failed to parse message",
+                      cause: z
+                    });
+                    (M = this.onerror) == null || M.call(this, x);
+                  }
+              }
+            } catch (O) {
+              if (O instanceof Error && O.name === "AbortError")
+                return;
+              (k = this.onerror) == null || k.call(this, O);
+            }
+          })();
+          return;
+        }
+        const f = new _({
+          message: `MCP HTTP Transport Error: Unexpected content type: ${h}`
+        });
+        throw (l = this.onerror) == null || l.call(this, f), f;
+      } catch (p) {
+        throw (c = this.onerror) == null || c.call(this, p), p;
+      }
+    };
+    await e();
+  }
+  getNextReconnectionDelay(t) {
+    const {
+      initialReconnectionDelay: e,
+      reconnectionDelayGrowFactor: r,
+      maxReconnectionDelay: s
+    } = this.reconnectionOptions;
+    return Math.min(
+      e * Math.pow(r, t),
+      s
+    );
+  }
+  scheduleInboundSseReconnection() {
+    var t;
+    const { maxRetries: e } = this.reconnectionOptions;
+    if (e > 0 && this.inboundReconnectAttempts >= e) {
+      (t = this.onerror) == null || t.call(
+        this,
+        new _({
+          message: `MCP HTTP Transport Error: Maximum reconnection attempts (${e}) exceeded.`
+        })
+      );
+      return;
+    }
+    const r = this.getNextReconnectionDelay(this.inboundReconnectAttempts);
+    this.inboundReconnectAttempts += 1, setTimeout(async () => {
+      var s;
+      (s = this.abortController) != null && s.signal.aborted || await this.openInboundSse(!1, this.lastInboundEventId);
+    }, r);
+  }
+  // Open optional inbound SSE stream; best-effort and resumable
+  async openInboundSse(t = !1, e) {
+    var r, s, n, a, i, u;
+    try {
+      const l = await this.commonHeaders({
+        Accept: "text/event-stream"
+      });
+      e && (l["last-event-id"] = e);
+      const c = await fetch(this.url.href, {
+        method: "GET",
+        headers: l,
+        signal: (r = this.abortController) == null ? void 0 : r.signal,
+        redirect: this.redirectMode
+      }), p = c.headers.get("mcp-session-id");
+      if (p && (this.sessionId = p), c.status === 401 && this.authProvider && !t) {
+        this.resourceMetadataUrl = te(c);
+        try {
+          if (await re(this.authProvider, {
+            serverUrl: this.url,
+            resourceMetadataUrl: this.resourceMetadataUrl
+          }) !== "AUTHORIZED") {
+            const h = new ee();
+            (s = this.onerror) == null || s.call(this, h);
+            return;
+          }
+        } catch (y) {
+          (n = this.onerror) == null || n.call(this, y);
+          return;
+        }
+        return this.openInboundSse(!0, e);
+      }
+      if (c.status === 405)
+        return;
+      if (!c.ok || !c.body) {
+        const y = new _({
+          message: `MCP HTTP Transport Error: GET SSE failed: ${c.status} ${c.statusText}`
+        });
+        (a = this.onerror) == null || a.call(this, y);
+        return;
+      }
+      const d = c.body.pipeThrough(new TextDecoderStream()).pipeThrough(new he()).getReader(), m = async () => {
+        var y, h, f, v;
+        try {
+          for (; ; ) {
+            const { done: b, value: T } = await d.read();
+            if (b) return;
+            const { event: A, data: M, id: k } = T;
+            if (k && (this.lastInboundEventId = k), A === "message")
+              try {
+                const O = V.parse(JSON.parse(M));
+                (y = this.onmessage) == null || y.call(this, O);
+              } catch (O) {
+                const H = new _({
+                  message: "MCP HTTP Transport Error: Failed to parse message",
+                  cause: O
+                });
+                (h = this.onerror) == null || h.call(this, H);
+              }
+          }
+        } catch (b) {
+          if (b instanceof Error && b.name === "AbortError")
+            return;
+          (f = this.onerror) == null || f.call(this, b), (v = this.abortController) != null && v.signal.aborted || this.scheduleInboundSseReconnection();
+        }
+      };
+      this.inboundSseConnection = {
+        close: () => d.cancel()
+      }, this.inboundReconnectAttempts = 0, m();
+    } catch (l) {
+      if (l instanceof Error && l.name === "AbortError")
+        return;
+      (i = this.onerror) == null || i.call(this, l), (u = this.abortController) != null && u.signal.aborted || this.scheduleInboundSseReconnection();
+    }
+  }
+};
+function Xs(t) {
+  switch (t.type) {
+    case "sse":
+      return new Gs(t);
+    case "http":
+      return new Ks(t);
+    default:
+      throw new _({
+        message: "Unsupported or invalid transport configuration. If you are using a custom transport, make sure it implements the MCPTransport interface."
+      });
+  }
+}
+function Qs(t) {
+  return "start" in t && typeof t.start == "function" && "send" in t && typeof t.send == "function" && "close" in t && typeof t.close == "function";
+}
+var Ys = "1.0.0";
+function je({
+  output: t
+}) {
+  const e = t;
+  return !("content" in e) || !Array.isArray(e.content) ? { type: "json", value: e } : { type: "content", value: e.content.map(
+    (s) => s.type === "text" && "text" in s ? { type: "text", text: s.text } : s.type === "image" && "data" in s && "mimeType" in s ? {
+      type: "image-data",
+      data: s.data,
+      mediaType: s.mimeType
+    } : { type: "text", text: JSON.stringify(s) }
+  ) };
+}
+async function en(t) {
+  const e = new tn(t);
+  return await e.init(), e;
+}
+var tn = class {
+  constructor({
+    transport: t,
+    name: e = "ai-sdk-mcp-client",
+    version: r = Ys,
+    onUncaughtError: s,
+    capabilities: n
+  }) {
+    this.requestMessageId = 0, this.responseHandlers = /* @__PURE__ */ new Map(), this.serverCapabilities = {}, this.isClosed = !0, this.onUncaughtError = s, this.clientCapabilities = n ?? {}, Qs(t) ? this.transport = t : this.transport = Xs(t), this.transport.onclose = () => this.onClose(), this.transport.onerror = (a) => this.onError(a), this.transport.onmessage = (a) => {
+      if ("method" in a) {
+        "id" in a ? this.onRequestMessage(a) : this.onError(
+          new _({
+            message: "Unsupported message type"
+          })
+        );
+        return;
+      }
+      this.onResponse(a);
+    }, this.clientInfo = {
+      name: e,
+      version: r
+    };
+  }
+  async init() {
+    try {
+      await this.transport.start(), this.isClosed = !1;
+      const t = await this.request({
+        request: {
+          method: "initialize",
+          params: {
+            protocolVersion: D,
+            capabilities: this.clientCapabilities,
+            clientInfo: this.clientInfo
+          }
+        },
+        resultSchema: ss
+      });
+      if (t === void 0)
+        throw new _({
+          message: "Server sent invalid initialize result"
+        });
+      if (!Yr.includes(t.protocolVersion))
+        throw new _({
+          message: `Server's protocol version is not supported: ${t.protocolVersion}`
+        });
+      return this.serverCapabilities = t.capabilities, await this.notification({
+        method: "notifications/initialized"
+      }), this;
+    } catch (t) {
+      throw await this.close(), t;
+    }
+  }
+  async close() {
+    var t;
+    this.isClosed || (await ((t = this.transport) == null ? void 0 : t.close()), this.onClose());
+  }
+  assertCapability(t) {
+    switch (t) {
+      case "initialize":
+        break;
+      case "tools/list":
+      case "tools/call":
+        if (!this.serverCapabilities.tools)
+          throw new _({
+            message: "Server does not support tools"
+          });
+        break;
+      case "resources/list":
+      case "resources/read":
+      case "resources/templates/list":
+        if (!this.serverCapabilities.resources)
+          throw new _({
+            message: "Server does not support resources"
+          });
+        break;
+      case "prompts/list":
+      case "prompts/get":
+        if (!this.serverCapabilities.prompts)
+          throw new _({
+            message: "Server does not support prompts"
+          });
+        break;
+      default:
+        throw new _({
+          message: `Unsupported method: ${t}`
+        });
+    }
+  }
+  async request({
+    request: t,
+    resultSchema: e,
+    options: r
+  }) {
+    return new Promise((s, n) => {
+      if (this.isClosed)
+        return n(
+          new _({
+            message: "Attempted to send a request from a closed client"
+          })
+        );
+      this.assertCapability(t.method);
+      const a = r?.signal;
+      a?.throwIfAborted();
+      const i = this.requestMessageId++, u = {
+        ...t,
+        jsonrpc: "2.0",
+        id: i
+      }, l = () => {
+        this.responseHandlers.delete(i);
+      };
+      this.responseHandlers.set(i, (c) => {
+        if (a?.aborted)
+          return n(
+            new _({
+              message: "Request was aborted",
+              cause: a.reason
+            })
+          );
+        if (c instanceof Error)
+          return n(c);
+        try {
+          const p = e.parse(c.result);
+          s(p);
+        } catch (p) {
+          const g = new _({
+            message: "Failed to parse server response",
+            cause: p
+          });
+          n(g);
+        }
+      }), this.transport.send(u).catch((c) => {
+        l(), n(c);
+      });
+    });
+  }
+  async listTools({
+    params: t,
+    options: e
+  } = {}) {
+    return this.request({
+      request: { method: "tools/list", params: t },
+      resultSchema: os,
+      options: e
+    });
+  }
+  async callTool({
+    name: t,
+    args: e,
+    options: r
+  }) {
+    try {
+      return this.request({
+        request: { method: "tools/call", params: { name: t, arguments: e } },
+        resultSchema: cs,
+        options: {
+          signal: r?.abortSignal
+        }
+      });
+    } catch (s) {
+      throw s;
+    }
+  }
+  async listResourcesInternal({
+    params: t,
+    options: e
+  } = {}) {
+    try {
+      return this.request({
+        request: { method: "resources/list", params: t },
+        resultSchema: is,
+        options: e
+      });
+    } catch (r) {
+      throw r;
+    }
+  }
+  async readResourceInternal({
+    uri: t,
+    options: e
+  }) {
+    try {
+      return this.request({
+        request: { method: "resources/read", params: { uri: t } },
+        resultSchema: ds,
+        options: e
+      });
+    } catch (r) {
+      throw r;
+    }
+  }
+  async listResourceTemplatesInternal({
+    options: t
+  } = {}) {
+    try {
+      return this.request({
+        request: { method: "resources/templates/list" },
+        resultSchema: us,
+        options: t
+      });
+    } catch (e) {
+      throw e;
+    }
+  }
+  async listPromptsInternal({
+    params: t,
+    options: e
+  } = {}) {
+    try {
+      return this.request({
+        request: { method: "prompts/list", params: t },
+        resultSchema: ms,
+        options: e
+      });
+    } catch (r) {
+      throw r;
+    }
+  }
+  async getPromptInternal({
+    name: t,
+    args: e,
+    options: r
+  }) {
+    try {
+      return this.request({
+        request: { method: "prompts/get", params: { name: t, arguments: e } },
+        resultSchema: gs,
+        options: r
+      });
+    } catch (s) {
+      throw s;
+    }
+  }
+  async notification(t) {
+    const e = {
+      ...t,
+      jsonrpc: "2.0"
+    };
+    await this.transport.send(e);
+  }
+  /**
+   * Returns a set of AI SDK tools from the MCP server.
+   * This fetches tool definitions and wraps them with execute functions.
+   * @returns A record of tool names to their implementations
+   */
+  async tools({
+    schemas: t = "automatic"
+  } = {}) {
+    const e = await this.listTools();
+    return this.toolsFromDefinitions(e, {
+      schemas: t
+    });
+  }
+  /**
+   * Creates AI SDK tools from tool definitions without fetching from the server.
+   */
+  toolsFromDefinitions(t, { schemas: e = "automatic" } = {}) {
+    var r, s;
+    const n = {};
+    for (const {
+      name: a,
+      title: i,
+      description: u,
+      inputSchema: l,
+      annotations: c,
+      _meta: p
+    } of t.tools) {
+      const g = i ?? c?.title;
+      if (e !== "automatic" && !(a in e))
+        continue;
+      const d = this, m = e !== "automatic" ? (r = e[a]) == null ? void 0 : r.outputSchema : void 0, y = async (f, v) => {
+        var b;
+        (b = v?.abortSignal) == null || b.throwIfAborted();
+        const T = await d.callTool({ name: a, args: f, options: v });
+        return m != null ? d.extractStructuredContent(T, m, a) : T;
+      }, h = e === "automatic" ? Vr({
+        description: u,
+        title: g,
+        inputSchema: J({
+          ...l,
+          properties: (s = l.properties) != null ? s : {},
+          additionalProperties: !1
+        }),
+        execute: y,
+        toModelOutput: je
+      }) : {
+        description: u,
+        title: g,
+        inputSchema: e[a].inputSchema,
+        ...m != null ? { outputSchema: m } : {},
+        execute: y,
+        toModelOutput: je
+      };
+      n[a] = { ...h, _meta: p };
+    }
+    return n;
+  }
+  /**
+   * Extracts and validates structuredContent from a tool result.
+   */
+  async extractStructuredContent(t, e, r) {
+    if ("structuredContent" in t && t.structuredContent != null) {
+      const s = await Be({
+        value: t.structuredContent,
+        schema: We(e)
+      });
+      if (!s.success)
+        throw new _({
+          message: `Tool "${r}" returned structuredContent that does not match the expected outputSchema`,
+          cause: s.error
+        });
+      return s.value;
+    }
+    if ("content" in t && Array.isArray(t.content)) {
+      const s = t.content.find((n) => n.type === "text");
+      if (s && "text" in s) {
+        const n = await Fr({
+          text: s.text,
+          schema: e
+        });
+        if (!n.success)
+          throw new _({
+            message: `Tool "${r}" returned content that does not match the expected outputSchema`,
+            cause: n.error
+          });
+        return n.value;
+      }
+    }
+    throw new _({
+      message: `Tool "${r}" did not return structuredContent or parseable text content`
+    });
+  }
+  listResources({
+    params: t,
+    options: e
+  } = {}) {
+    return this.listResourcesInternal({ params: t, options: e });
+  }
+  readResource({
+    uri: t,
+    options: e
+  }) {
+    return this.readResourceInternal({ uri: t, options: e });
+  }
+  listResourceTemplates({
+    options: t
+  } = {}) {
+    return this.listResourceTemplatesInternal({ options: t });
+  }
+  experimental_listPrompts({
+    params: t,
+    options: e
+  } = {}) {
+    return this.listPromptsInternal({ params: t, options: e });
+  }
+  experimental_getPrompt({
+    name: t,
+    arguments: e,
+    options: r
+  }) {
+    return this.getPromptInternal({ name: t, args: e, options: r });
+  }
+  onElicitationRequest(t, e) {
+    if (t !== xe)
+      throw new _({
+        message: "Unsupported request schema. Only ElicitationRequestSchema is supported."
+      });
+    this.elicitationRequestHandler = e;
+  }
+  async onRequestMessage(t) {
+    try {
+      if (t.method !== "elicitation/create") {
+        await this.transport.send({
+          jsonrpc: "2.0",
+          id: t.id,
+          error: {
+            code: -32601,
+            message: `Unsupported request method: ${t.method}`
+          }
+        });
+        return;
+      }
+      if (!this.elicitationRequestHandler) {
+        await this.transport.send({
+          jsonrpc: "2.0",
+          id: t.id,
+          error: {
+            code: -32601,
+            message: "No elicitation handler registered on client"
+          }
+        });
+        return;
+      }
+      const e = xe.safeParse({
+        method: t.method,
+        params: t.params
+      });
+      if (!e.success) {
+        await this.transport.send({
+          jsonrpc: "2.0",
+          id: t.id,
+          error: {
+            code: -32602,
+            message: `Invalid elicitation request: ${e.error.message}`,
+            data: e.error.issues
+          }
+        });
+        return;
+      }
+      try {
+        const r = await this.elicitationRequestHandler(e.data), s = vs.parse(r);
+        await this.transport.send({
+          jsonrpc: "2.0",
+          id: t.id,
+          result: s
+        });
+      } catch (r) {
+        await this.transport.send({
+          jsonrpc: "2.0",
+          id: t.id,
+          error: {
+            code: -32603,
+            message: r instanceof Error ? r.message : "Failed to handle elicitation request"
+          }
+        }), this.onError(r);
+      }
+    } catch (e) {
+      this.onError(e);
+    }
+  }
+  onClose() {
+    if (this.isClosed) return;
+    this.isClosed = !0;
+    const t = new _({
+      message: "Connection closed"
+    });
+    for (const e of this.responseHandlers.values())
+      e(t);
+    this.responseHandlers.clear();
+  }
+  onError(t) {
+    this.onUncaughtError && this.onUncaughtError(t);
+  }
+  onResponse(t) {
+    const e = Number(t.id), r = this.responseHandlers.get(e);
+    if (r === void 0)
+      throw new _({
+        message: `Protocol error: Received a response for an unknown message ID: ${JSON.stringify(
+          t
+        )}`
+      });
+    this.responseHandlers.delete(e), r(
+      "result" in t ? t : new _({
+        message: t.error.message,
+        code: t.error.code,
+        data: t.error.data,
+        cause: t.error
+      })
+    );
+  }
+};
+const rn = async (t) => {
+  const e = {};
+  try {
+    const r = await t.listTools();
+    for (const { name: s, description: n, inputSchema: a } of r.tools) {
+      const i = async (u, l) => t.callTool({ name: s, arguments: u }, { signal: l?.abortSignal });
+      e[s] = Ot({
+        description: n,
+        inputSchema: It({
+          ...a,
+          properties: a.properties ?? {},
+          additionalProperties: !1
+        }),
+        execute: i
+      });
+    }
+    return e;
+  } catch (r) {
+    throw r;
+  }
+};
+function sn(t) {
+  const e = Object.entries(t);
+  if (e.length === 0)
+    return "";
+  let r = `
+# 工具调用
+
+你可以根据需要调用以下工具：
+
+<tools>
+  `;
+  return e.forEach(([s, n]) => {
+    const a = n, i = a.description || "无描述", u = a.parameters || a.inputSchema || {};
+    r += `${JSON.stringify({
+      name: s,
+      description: i,
+      parameters: u
+    }, null, 2)}
+`;
+  }), r += `
+</tools>
+
+## 工具调用格式
+
+要调用工具，请使用以下 XML 格式：
+Thought: [你的思考过程]
+<tool_call>
+  {"name": "toolName", "arguments": {"arg1": "value1"}}
+</tool_call>
+
+工具执行后，你将收到 <tool_response> 格式的结果。你可以继续思考或调用其他工具。
+
+## 使用示例
+
+如果用户要求"获取今天的日期"，你可以这样调用工具：
+Thought: 用户想要获取今天的日期，我需要调用日期相关的工具。
+<tool_call>{"name": "get-today", "arguments": {}}</tool_call>
+
+然后等待工具返回结果（Observation），再根据结果给出最终答案。
+
+## 任务完成
+
+当任务完成或无法继续时，直接给出最终答案即可。
+
+**重要提示**：
+- 必须严格按照 XML 格式调用工具
+- arguments 必须是有效的 JSON 格式
+- 如果不需要调用工具，直接给出最终答案即可
+`, r;
+}
+function Ne(t, e) {
+  if (!t || typeof t != "string")
+    return null;
+  const r = t.match(/<tool_call>([\s\S]*?)<\/tool_call>/i);
+  if (r)
+    try {
+      const s = r[1].trim(), n = JSON.parse(s), a = n.name || n.action || n.tool, i = n.arguments || n.args || n.input || {};
+      if (a && e[a])
+        return { toolName: a, arguments: i };
+    } catch {
+    }
+  return null;
+}
+const nn = {
+  openai: $t,
+  deepseek: jt
+};
+class xn {
+  constructor({ llmConfig: e, mcpServers: r }) {
+    if (this.mcpServers = {}, this.mcpClients = {}, this.mcpTools = {}, this.ignoreToolnames = [], this.responseMessages = [], this.useReActMode = !1, !e)
+      throw new Error("llmConfig is required to initialize AgentModelProvider");
+    if (this.mcpServers = r || {}, this.mcpClients = {}, this.mcpTools = {}, e.llm)
+      this.llm = e.llm;
+    else if (e.providerType) {
+      const s = e.providerType;
+      let n;
+      typeof s == "string" ? n = nn[s] : n = s, this.llm = n({
+        apiKey: e.apiKey,
+        baseURL: e.baseURL
+      });
+    } else
+      throw new Error("Either llmConfig.llm or llmConfig.providerType must be provided");
+    this.useReActMode = e.useReActMode ?? !1;
+  }
+  /** 创建一个 ai-sdk的 mcpClient, 创建失败则返回 null */
+  async _createOneClient(e) {
+    try {
+      let r;
+      if ("type" in e && e.type.toLocaleLowerCase() === "streamablehttp") {
+        const n = e, a = n.headers ? { headers: n.headers } : void 0;
+        r = new se(new URL(n.url), { requestInit: a });
+      } else if ("type" in e && e.type === "sse") {
+        const n = e, a = n.headers ? { headers: n.headers } : void 0;
+        r = new ne(new URL(n.url), { requestInit: a });
+      } else "type" in e && e.type === "extension" ? r = new zt(e.sessionId) : "transport" in e ? r = e.transport : r = e;
+      if (e.useAISdkClient ?? !1) {
+        const n = await en({ transport: r });
+        return n.__transport__ = r, n;
+      } else {
+        const n = new qt(
+          { name: "mcp-web-client", version: "1.0.0" },
+          { capabilities: { roots: { listChanged: !0 }, sampling: {}, elicitation: {} } }
+        );
+        return await n.connect(r), n.__transport__ = r, n;
+      }
+    } catch (r) {
+      return this.onError && this.onError(r?.message || "Failed to create MCP client", r), console.error("Failed to create MCP client", e, r), null;
+    }
+  }
+  /** 关闭一个 mcpClient */
+  async _closeOneClient(e) {
+    try {
+      const r = e.__transport__;
+      if (r && r instanceof Ut || r && r instanceof gt)
+        return;
+      await r?.terminateSession?.(), await r?.close?.(), await e?.close?.();
+    } catch {
+    }
+  }
+  /** 创建所有 mcpClients */
+  async _createMpcClients() {
+    const e = Object.entries(this.mcpServers), r = await Promise.all(
+      e.map(async ([s, n]) => {
+        const a = await this._createOneClient(n);
+        return { serverName: s, client: a };
+      })
+    );
+    this.mcpClients = {}, r.forEach(({ serverName: s, client: n }) => {
+      this.mcpClients[s] = n;
+    });
+  }
+  /** 兼容两种 client 类型的 tools 获取方法 */
+  async _getClientTools(e, r) {
+    if (!e)
+      return null;
+    try {
+      return typeof e.tools == "function" ? await e.tools() : await rn(e);
+    } catch (s) {
+      return this.onError && this.onError(s?.message || `Failed to query tools for ${r}`, s), console.error(`Failed to query tools for ${r}`, s), null;
+    }
+  }
+  /** 查询所有 mcpClients 的 tools, 失败则保存为null */
+  async _createMpcTools() {
+    const e = Object.entries(this.mcpClients), r = await Promise.all(
+      e.map(async ([s, n]) => {
+        const a = await this._getClientTools(n, s);
+        return { serverName: s, tools: a };
+      })
+    );
+    this.mcpTools = {}, r.forEach(({ serverName: s, tools: n }) => {
+      const a = n && typeof n == "object" ? n : {};
+      this.mcpTools[s] = a;
+    });
+  }
+  /** 关闭所有的 clients */
+  async closeAll() {
+    await Promise.all(
+      Object.values(this.mcpClients).map(async (e) => {
+        try {
+          await this._closeOneClient(e);
+        } catch (r) {
+          this.onError && this.onError(r?.message || "Failed to close client", r), console.error("Failed to close client", r);
+        }
+      })
+    );
+  }
+  /** 创建所有的 mcpClients，并更新它们的tools */
+  async initClientsAndTools() {
+    await this._createMpcClients(), await this._createMpcTools(), this.onUpdatedTools?.();
+  }
+  /** 仅刷新已连接 clients 的 tools（不重建 client，适合工具目录动态变化场景） */
+  async refreshTools() {
+    await this._createMpcTools(), this.onUpdatedTools?.();
+  }
+  /** 全量更新所有的 mcpServers */
+  async updateMcpServers(e) {
+    await this.closeAll(), this.mcpServers = e || this.mcpServers, await this.initClientsAndTools();
+  }
+  /** 插入一个新的mcpServer，如果已经存在则返回false */
+  async insertMcpServer(e, r) {
+    if (this.mcpServers[e])
+      return !1;
+    const s = await this._createOneClient(r);
+    if (!s)
+      return this.onError?.(`Failed to create MCP client: ${e}`), null;
+    this.mcpClients[e] = s;
+    const n = await this._getClientTools(s, e);
+    return this.mcpTools[e] = n && typeof n == "object" ? n : {}, this.mcpServers[e] = r, this.onUpdatedTools?.(), s;
+  }
+  /** 通过服务器名称删除mcpServer： mcpServers mcpClients  mcpTools ignoreToolnames  */
+  async removeMcpServer(e) {
+    if (!this.mcpServers[e])
+      return;
+    delete this.mcpServers[e];
+    const r = this.mcpClients[e];
+    delete this.mcpClients[e];
+    try {
+      await this._closeOneClient(r);
+    } catch {
+    }
+    const s = this.mcpTools[e];
+    delete this.mcpTools[e], s && Object.keys(s).forEach((n) => {
+      this.ignoreToolnames = this.ignoreToolnames.filter((a) => a !== n);
+    }), this.onUpdatedTools?.();
+  }
+  /** 创建临时允许调用的 tools 集合，合并 mcpTools 与 extraTool */
+  _tempMergeTools(e = {}, r = !0) {
+    const s = Object.values(this.mcpTools).reduce(
+      (n, a) => ({ ...n, ...a }),
+      {}
+    );
+    return Object.assign(s, e), r && this.ignoreToolnames.forEach((n) => {
+      delete s[n];
+    }), s;
+  }
+  /** 获取当前激活的 tools 名称列表（过滤 ignoreToolnames） */
+  _getActiveToolNames(e) {
+    return Object.keys(e).filter((r) => !this.ignoreToolnames.includes(r));
+  }
+  /** 生成 ReAct 模式的系统提示词（包含工具描述） */
+  _generateReActSystemPrompt(e, r, s) {
+    const n = sn(e);
+    return s ? `${s}${n}` : `你是一个智能助手，可以通过调用工具来完成任务。
+${n}`;
+  }
+  /** 执行 ReAct 模式下的工具调用 */
+  async _executeReActToolCall(e, r, s) {
+    const n = s[e];
+    if (!n)
+      return { success: !1, error: `工具 ${e} 不存在` };
+    try {
+      const a = n, i = a.execute || a.call;
+      return typeof i != "function" ? { success: !1, error: `工具 ${e} 没有可执行的函数` } : { success: !0, result: await i(r, {}) };
+    } catch (a) {
+      return { success: !1, error: a?.message || String(a) || "工具执行失败" };
+    }
+  }
+  /** ReAct 模式的对话实现 */
+  async _chatReAct(e, { model: r, maxSteps: s = 5, ...n }) {
+    if (!this.llm)
+      throw new Error("LLM is not initialized");
+    await this.initClientsAndTools();
+    const a = this._tempMergeTools(n.tools);
+    if (Object.keys(a).length === 0)
+      return this._chat(e, { model: r, maxSteps: s, ...n });
+    let u = [];
+    n.message && !n.messages ? u.push({ role: "user", content: n.message }) : n.messages ? u = [...n.messages] : u = [...this.responseMessages];
+    const l = typeof r == "string" ? r : r?.modelId || "default-model", p = { role: "system", content: this._generateReActSystemPrompt(a, l, n.system) }, g = u[0]?.role === "system" ? u : [p, ...u];
+    return e === ie ? this._chatReActStream(g, a, l, s, n) : this._chatReActNonStream(g, a, l, s, n);
+  }
+  /**
+   * 检查消息内容是否包含图片
+   * @param content 消息内容
+   * @returns 是否包含图片
+   */
+  _messageHasImage(e) {
+    return e && Array.isArray(e) ? e.some((r) => r && r.type === "image") : !1;
+  }
+  /**
+   * 从消息中移除图片，但保留文本内容
+   * @param message 原始消息
+   * @returns 移除图片后的消息（如果只有图片没有文本，返回 null）
+   */
+  _removeImageFromMessage(e) {
+    if (!e || !e.content)
+      return null;
+    if (!Array.isArray(e.content))
+      return e;
+    const r = e.content.filter((s) => s && s.type !== "image");
+    return r.length === 0 ? null : {
+      ...e,
+      content: r
+    };
+  }
+  /**
+   * 构建用于模型调用的消息列表
+   * 策略：保留所有文本消息，仅限制图片数量（类似 magentic-ui 的 maybe_remove_old_screenshots）
+   *
+   * @param systemMessage 系统提示词
+   * @param allMessages 所有消息历史（包括初始消息和后续对话）
+   * @param maxImages 最多保留的图片数量（默认3张）
+   * @returns 构建好的消息列表
+   */
+  _buildMessagesForModel(e, r, s = 3) {
+    const n = [];
+    e && n.push(e);
+    let a = 0;
+    const i = [];
+    for (let u = r.length - 1; u >= 0; u--) {
+      const l = r[u];
+      if (this._messageHasImage(l.content))
+        if (a < s)
+          i.unshift(l), a++;
+        else {
+          const p = this._removeImageFromMessage(l);
+          p && i.unshift(p);
+        }
+      else
+        i.unshift(l);
+    }
+    return n.push(...i), n;
+  }
+  /** ReAct 模式非流式对话 */
+  async _chatReActNonStream(e, r, s, n, a) {
+    let i = [...e];
+    const u = e[0]?.role === "system" ? e[0] : null, l = u ? e.slice(1) : e;
+    let c = 0;
+    const p = a.maxImages ?? 3;
+    for (; c < n; ) {
+      c++;
+      const d = this._buildMessagesForModel(u, l, p), { tools: m, ...y } = a, f = (await Pe({
+        // @ts-ignore ProviderV2 是所有llm的父类，在每一个具体的llm类都有一个选择model的函数用法
+        model: this.llm(s),
+        messages: d,
+        ...y
+      })).text, v = { role: "assistant", content: f };
+      l.push(v), i.push(v);
+      const b = Ne(f, r);
+      if (!b)
+        return this.responseMessages = i, {
+          text: f,
+          response: { messages: i }
+        };
+      const T = await this._executeReActToolCall(b.toolName, b.arguments, r), k = {
+        role: "user",
+        content: `<tool_response>
+${T.success ? JSON.stringify(T.result) : `工具执行失败 - ${T.error}`}
+</tool_response>`
+      };
+      l.push(k), i.push(k);
+    }
+    return this.responseMessages = i, {
+      text: i[i.length - 2]?.content || "",
+      response: { messages: i }
+    };
+  }
+  /** ReAct 模式流式对话 */
+  _chatReActStream(e, r, s, n, a) {
+    const i = this, u = this.llm(s);
+    let l, c;
+    const p = new Promise((d, m) => {
+      l = d, c = m;
+    });
+    return {
+      fullStream: new ReadableStream({
+        async start(d) {
+          let m = [...e];
+          const y = e[0]?.role === "system" ? e[0] : null, h = y ? e.slice(1) : [...e];
+          let f = 0, v = "";
+          const b = a.maxImages ?? 3;
+          d.enqueue({ type: "start" }), d.enqueue({ type: "start-step" });
+          try {
+            for (; f < n; ) {
+              f++;
+              const T = i._buildMessagesForModel(y, h, b), { tools: A, ...M } = a;
+              delete M.system, delete M.onFinish;
+              const k = await ie({
+                ...M,
+                model: u,
+                messages: T
+              });
+              let O = "";
+              for await (const P of k.fullStream)
+                P.type === "text-delta" ? (O += P.text || "", d.enqueue({
+                  type: "text-delta",
+                  text: P.text
+                })) : P.type === "text-start" ? d.enqueue({ type: "text-start" }) : P.type === "text-end" || P.type === "finish-step" || P.type === "finish" || P.type === "start" || P.type === "start-step" || d.enqueue(P);
+              v += O;
+              const H = { role: "assistant", content: v };
+              h.push(H), m.push(H);
+              const I = Ne(v, r);
+              if (!I) {
+                d.enqueue({ type: "text-end" }), d.enqueue({ type: "finish-step" }), d.enqueue({ type: "finish" }), d.close(), i.responseMessages = m, l({ messages: m });
+                return;
+              }
+              if (I.toolName === "computer" && I.arguments?.action === "terminate") {
+                d.enqueue({ type: "text-end" }), d.enqueue({ type: "finish-step" }), d.enqueue({ type: "finish" }), d.close(), i.responseMessages = m, l({ messages: m });
+                return;
+              }
+              const j = `react-${Date.now()}`;
+              d.enqueue({
+                type: "tool-input-start",
+                id: j,
+                toolName: I.toolName
+              });
+              const z = JSON.stringify(I.arguments, null, 2);
+              d.enqueue({
+                type: "tool-input-delta",
+                id: j,
+                delta: z
+              }), d.enqueue({
+                type: "tool-input-end",
+                id: j
+              }), d.enqueue({
+                type: "tool-call",
+                toolCallId: j,
+                toolName: I.toolName,
+                input: I.arguments
+              });
+              const x = await i._executeReActToolCall(I.toolName, I.arguments, r);
+              let B, N = x.result;
+              if (x.success && x.result && typeof x.result == "object" && x.result.screenshot) {
+                B = x.result.screenshot;
+                const { screenshot: P, ...G } = x.result;
+                N = G;
+              }
+              let F = "";
+              if (x.success) {
+                N && Array.isArray(N.content) && N.content.length > 0 && N.content[0].text ? F = N.content[0].text : F = JSON.stringify(N);
+                let P = `<tool_response>
+${F}
+</tool_response>`;
+                B && (P += `
+请检查截图以确认操作是否成功。如果成功，请继续下一步；如果失败，请重试。`), d.enqueue({
+                  type: "tool-result",
+                  toolCallId: j,
+                  result: P
+                });
+                const G = B ? {
+                  role: "user",
+                  content: [
+                    { type: "text", text: P },
+                    { type: "image", image: B }
+                  ]
+                } : {
+                  role: "user",
+                  content: P
+                };
+                h.push(G), m.push(G), v = "";
+              } else
+                F = `工具执行失败 - ${x.error}`, d.enqueue({
+                  type: "tool-error",
+                  toolCallId: j,
+                  input: I.arguments,
+                  error: { message: F }
+                });
+            }
+            d.enqueue({ type: "text-end" }), d.enqueue({ type: "finish-step" }), d.enqueue({ type: "finish" }), d.close(), i.responseMessages = m, l({ messages: m });
+          } catch (T) {
+            d.error(T), c(T);
+          }
+        }
+      }),
+      response: p
+    };
+  }
+  async _chat(e, { model: r, maxSteps: s = 5, ...n }) {
+    if (this.useReActMode)
+      return this._chatReAct(e, { model: r, maxSteps: s, ...n });
+    if (!this.llm)
+      throw new Error("LLM is not initialized");
+    await this.initClientsAndTools();
+    const a = n.tools || {}, i = this._tempMergeTools(a, !1), u = () => {
+      const m = this._tempMergeTools(a, !1);
+      Object.entries(m).forEach(([y, h]) => {
+        i[y] = h;
+      }), Object.keys(i).forEach((y) => {
+        y in m || delete i[y];
+      });
+    }, l = n.prepareStep, c = async (m) => {
+      u();
+      const y = this._getActiveToolNames(i), h = typeof l == "function" ? await l(m) : void 0, f = h && typeof h == "object" ? h : {};
+      return {
+        ...f,
+        activeTools: Array.isArray(f.activeTools) ? f.activeTools.filter((v) => y.includes(v)) : y
+      };
+    }, p = {
+      // @ts-ignore  ProviderV2 是所有llm的父类， 在每一个具体的llm 类都有一个选择model的函数用法
+      model: this.llm(r),
+      stopWhen: xt(s),
+      ...n,
+      tools: i,
+      prepareStep: c,
+      activeTools: this._getActiveToolNames(i)
+    };
+    let g = null;
+    if (n.message && !n.messages)
+      g = { role: "user", content: n.message }, this.responseMessages.push(g), p.messages = [...this.responseMessages];
+    else if (n.messages && n.messages.length > 0) {
+      const m = n.messages[n.messages.length - 1];
+      m.role === "user" && (g = m);
+    }
+    const d = e(p);
+    return d?.response?.then((m) => {
+      const y = m.messages?.[0];
+      g && y?.role !== "user" && this.responseMessages.push(g), this.responseMessages.push(...m.messages);
+    }), d;
+  }
+  async chat(e) {
+    return this._chat(Pe, e);
+  }
+  async chatStream(e) {
+    return this._chat(ie, e);
+  }
+}
+export {
+  xn as A,
+  zt as E,
+  _n as W,
+  Sn as a,
+  Pn as b,
+  bn as c,
+  qt as d,
+  Cn as e,
+  Rn as f,
+  rn as g,
+  Mn as h,
+  Tn as i,
+  En as j,
+  Ht as k,
+  An as l,
+  kn as m,
+  Dt as n,
+  In as o,
+  Zt as p,
+  On as s
+};