@gram-ai/elements 1.15.0 → 1.16.1

package/dist/server.js

@@ -1,45 +1,113 @@
-import { gc as mt, fe as se, gd as Rn, ge as En, fr as d, gf as ye, fs as S, fM as s, ev as v, ez as X, fZ as D, f_ as ne, fd as E, fB as Be, gg as gt, gh as ft, gi as De, ew as _t, fq as k, eu as vt, dR as Cn, aQ as xn, eS as Je, gj as In, gk as Pn, gl as On, ga as An } from "./index-cubKOZsm.js";
-var Un = (e) => Object.fromEntries(
-  Object.entries(e).map(([t, n]) => [
-    t,
-    {
-      ...n.description ? { description: n.description } : void 0,
-      inputSchema: mt(n.parameters)
-    }
-  ])
+import { go as Rn, gp as En, fo as le, fC as d, gq as be, fD as E, fX as s, eG as y, eK as X, g8 as j, g9 as oe, fn as x, fM as ze, gr as He, eH as gt, fB as k, eF as K, d$ as Cn, aV as xn, f1 as Ge, gs as In, gt as On, gu as Pn, gm as An } from "./index-CVZt-xeH.js";
+const $n = (e) => Object.fromEntries(Object.entries(e).map(([t, n]) => [
+  t,
+  {
+    ...n.description ? { description: n.description } : void 0,
+    inputSchema: Rn(n.parameters)
+  }
+]));
+var Un = ({
+  prefix: e,
+  size: t = 16,
+  alphabet: n = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  separator: r = "-"
+} = {}) => {
+  const o = () => {
+    const a = n.length, i = new Array(t);
+    for (let c = 0; c < t; c++)
+      i[c] = n[Math.random() * a | 0];
+    return i.join("");
+  };
+  if (e == null)
+    return o;
+  if (n.includes(r))
+    throw new En({
+      argument: "separator",
+      message: `The separator "${r}" must not be part of the alphabet "${n}".`
+    });
+  return () => `${e}${r}${o()}`;
+};
+Un();
+function _t(e = globalThis) {
+  var t, n, r;
+  return e.window ? "runtime/browser" : (t = e.navigator) != null && t.userAgent ? `runtime/${e.navigator.userAgent.toLowerCase()}` : (r = (n = e.process) == null ? void 0 : n.versions) != null && r.node ? `runtime/node.js/${e.process.version.substring(0)}` : e.EdgeRuntime ? "runtime/vercel-edge" : "runtime/unknown";
+}
+function Mn(e) {
+  if (e == null)
+    return {};
+  const t = {};
+  if (e instanceof Headers)
+    e.forEach((n, r) => {
+      t[r.toLowerCase()] = n;
+    });
+  else {
+    Array.isArray(e) || (e = Object.entries(e));
+    for (const [n, r] of e)
+      r != null && (t[n.toLowerCase()] = r);
+  }
+  return t;
+}
+function vt(e, ...t) {
+  const n = new Headers(Mn(e)), r = n.get("user-agent") || "";
+  return n.set(
+    "user-agent",
+    [r, ...t].filter(Boolean).join(" ")
+  ), Object.fromEntries(n.entries());
+}
+var Nn = Symbol.for("vercel.ai.validator");
+function jn(e) {
+  return { ...e, type: "dynamic" };
+}
+new Set(
+  "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
 );
-let ze;
-ze = globalThis.crypto;
-async function $n(e) {
-  return (await ze).getRandomValues(new Uint8Array(e));
-}
-async function Mn(e) {
-  const t = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~", n = Math.pow(2, 8) - Math.pow(2, 8) % t.length;
-  let r = "";
-  for (; r.length < e; ) {
-    const o = await $n(e - r.length);
-    for (const a of o)
-      a < n && (r += t[a % t.length]);
-  }
-  return r;
-}
-async function Nn(e) {
-  return await Mn(e);
-}
-async function Dn(e) {
-  const t = await (await ze).subtle.digest("SHA-256", new TextEncoder().encode(e));
+var Dn = Symbol.for("vercel.ai.schema");
+function Hn(e, {
+  validate: t
+} = {}) {
+  return {
+    [Dn]: !0,
+    _type: void 0,
+    // should never be used directly
+    [Nn]: !0,
+    get jsonSchema() {
+      return typeof e == "function" && (e = e()), e;
+    },
+    validate: t
+  };
+}
+let We;
+We = globalThis.crypto;
+async function Ln(e) {
+  return (await We).getRandomValues(new Uint8Array(e));
+}
+async function qn(e) {
+  const t = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
+  let n = "";
+  const r = await Ln(e);
+  for (let o = 0; o < e; o++) {
+    const a = r[o] % t.length;
+    n += t[a];
+  }
+  return n;
+}
+async function Vn(e) {
+  return await qn(e);
+}
+async function Bn(e) {
+  const t = await (await We).subtle.digest("SHA-256", new TextEncoder().encode(e));
   return btoa(String.fromCharCode(...new Uint8Array(t))).replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, "");
 }
-async function jn(e) {
+async function Jn(e) {
   if (e || (e = 43), e < 43 || e > 128)
     throw `Expected a length between 43 and 128. Received ${e}.`;
-  const t = await Nn(e), n = await Dn(t);
+  const t = await Vn(e), n = await Bn(t);
   return {
     code_verifier: t,
     code_challenge: n
   };
 }
-var qn = "AI_MCPClientError", yt = `vercel.ai.error.${qn}`, Hn = Symbol.for(yt), tt, nt, P = class extends (nt = ye, tt = Hn, nt) {
+var zn = "AI_MCPClientError", yt = `vercel.ai.error.${zn}`, Gn = Symbol.for(yt), rt, ot, O = class extends (ot = be, rt = Gn, ot) {
   constructor({
     name: e = "MCPClientError",
     message: t,
@@ -47,81 +115,81 @@ var qn = "AI_MCPClientError", yt = `vercel.ai.error.${qn}`, Hn = Symbol.for(yt),
     data: r,
     code: o
   }) {
-    super({ name: e, message: t, cause: n }), this[tt] = !0, this.data = r, this.code = o;
+    super({ name: e, message: t, cause: n }), this[rt] = !0, this.data = r, this.code = o;
   }
   static isInstance(e) {
-    return ye.hasMarker(e, yt);
+    return be.hasMarker(e, yt);
   }
-}, ie = "2025-06-18", Ln = [
-  ie,
+}, ue = "2025-06-18", Wn = [
+  ue,
   "2025-03-26",
   "2024-11-05"
-], Vn = se({
+], Fn = le({
   name: s(),
   version: s()
-}), Ie = se({
-  _meta: S(d({}).loose())
-}), Y = Ie, wt = d({
+}), Pe = le({
+  _meta: E(d({}).loose())
+}), Y = Pe, wt = d({
   method: s(),
-  params: S(Ie)
+  params: E(Pe)
 }), bt = d({
-  applyDefaults: S(X())
-}).loose(), Bn = se({
-  experimental: S(d({}).loose()),
-  logging: S(d({}).loose()),
-  prompts: S(
-    se({
-      listChanged: S(X())
+  applyDefaults: E(X())
+}).loose(), Kn = le({
+  experimental: E(d({}).loose()),
+  logging: E(d({}).loose()),
+  prompts: E(
+    le({
+      listChanged: E(X())
     })
   ),
-  resources: S(
-    se({
-      subscribe: S(X()),
-      listChanged: S(X())
+  resources: E(
+    le({
+      subscribe: E(X()),
+      listChanged: E(X())
     })
   ),
-  tools: S(
-    se({
-      listChanged: S(X())
+  tools: E(
+    le({
+      listChanged: E(X())
     })
   ),
-  elicitation: S(bt)
+  elicitation: E(bt)
 });
 d({
-  elicitation: S(bt)
+  elicitation: E(bt)
 }).loose();
-var Jn = Y.extend({
+var Zn = Y.extend({
   protocolVersion: s(),
-  capabilities: Bn,
-  serverInfo: Vn,
-  instructions: S(s())
-}), We = Y.extend({
-  nextCursor: S(s())
-}), zn = d({
+  capabilities: Kn,
+  serverInfo: Fn,
+  instructions: E(s())
+}), Fe = Y.extend({
+  nextCursor: E(s())
+}), Xn = d({
   name: s(),
-  description: S(s()),
+  description: E(s()),
   inputSchema: d({
-    type: E("object"),
-    properties: S(d({}).loose())
+    type: x("object"),
+    properties: E(d({}).loose())
   }).loose()
-}).loose(), Wn = We.extend({
-  tools: v(zn)
+}).loose(), Yn = Fe.extend({
+  tools: y(Xn)
 }), kt = d({
-  type: E("text"),
+  type: x("text"),
   text: s()
 }).loose(), Tt = d({
-  type: E("image"),
-  data: _t(),
+  type: x("image"),
+  data: gt(),
   mimeType: s()
-}).loose(), Gn = d({
+}).loose(), Qn = d({
   uri: s(),
   name: s(),
-  title: S(s()),
-  description: S(s()),
-  mimeType: S(s()),
-  size: S(k())
-}).loose(), Fn = We.extend({
-  resources: v(Gn)
+  title: E(s()),
+  description: E(s()),
+  mimeType: E(s()),
+  size: E(k())
+}).loose(), er = Fe.extend({
+  resources: y(Qn)
 }), St = d({
   /**
    * The URI of this resource.
@@ -130,104 +198,104 @@ var Jn = Y.extend({
   /**
    * Optional display name of the resource content.
    */
-  name: S(s()),
+  name: E(s()),
   /**
    * Optional human readable title.
    */
-  title: S(s()),
+  title: E(s()),
   /**
    * The MIME type of this resource, if known.
    */
-  mimeType: S(s())
+  mimeType: E(s())
 }).loose(), Rt = St.extend({
   text: s()
 }), Et = St.extend({
-  blob: _t()
+  blob: gt()
 }), Ct = d({
-  type: E("resource"),
-  resource: D([Rt, Et])
-}).loose(), Kn = Y.extend({
-  content: v(
-    D([kt, Tt, Ct])
+  type: x("resource"),
+  resource: j([Rt, Et])
+}).loose(), tr = Y.extend({
+  content: y(
+    j([kt, Tt, Ct])
   ),
   isError: X().default(!1).optional()
 }).or(
   Y.extend({
-    toolResult: ne()
+    toolResult: oe()
   })
-), Zn = d({
+), nr = d({
   uriTemplate: s(),
   name: s(),
-  title: S(s()),
-  description: S(s()),
-  mimeType: S(s())
-}).loose(), Xn = Y.extend({
-  resourceTemplates: v(Zn)
-}), Yn = Y.extend({
-  contents: v(
-    D([Rt, Et])
+  title: E(s()),
+  description: E(s()),
+  mimeType: E(s())
+}).loose(), rr = Y.extend({
+  resourceTemplates: y(nr)
+}), or = Y.extend({
+  contents: y(
+    j([Rt, Et])
   )
-}), Qn = d({
+}), sr = d({
   name: s(),
-  description: S(s()),
-  required: S(X())
-}).loose(), er = d({
+  description: E(s()),
+  required: E(X())
+}).loose(), ar = d({
   name: s(),
-  title: S(s()),
-  description: S(s()),
-  arguments: S(v(Qn))
-}).loose(), tr = We.extend({
-  prompts: v(er)
-}), nr = d({
-  role: D([E("user"), E("assistant")]),
-  content: D([
+  title: E(s()),
+  description: E(s()),
+  arguments: E(y(sr))
+}).loose(), ir = Fe.extend({
+  prompts: y(ar)
+}), lr = d({
+  role: j([x("user"), x("assistant")]),
+  content: j([
     kt,
     Tt,
     Ct
   ])
-}).loose(), rr = Y.extend({
-  description: S(s()),
-  messages: v(nr)
-}), or = Ie.extend({
+}).loose(), cr = Y.extend({
+  description: E(s()),
+  messages: y(lr)
+}), ur = Pe.extend({
   message: s(),
-  requestedSchema: ne()
-}), rt = wt.extend({
-  method: E("elicitation/create"),
-  params: or
-}), sr = Y.extend({
-  action: D([
-    E("accept"),
-    E("decline"),
-    E("cancel")
+  requestedSchema: oe()
+}), st = wt.extend({
+  method: x("elicitation/create"),
+  params: ur
+}), dr = Y.extend({
+  action: j([
+    x("accept"),
+    x("decline"),
+    x("cancel")
   ]),
-  content: S(Be(s(), ne()))
-}), Pe = "2.0", ar = d({
-  jsonrpc: E(Pe),
-  id: D([s(), k().int()])
-}).merge(wt).strict(), ir = d({
-  jsonrpc: E(Pe),
-  id: D([s(), k().int()]),
+  content: E(ze(s(), oe()))
+}), Ae = "2.0", pr = d({
+  jsonrpc: x(Ae),
+  id: j([s(), k().int()])
+}).merge(wt).strict(), hr = d({
+  jsonrpc: x(Ae),
+  id: j([s(), k().int()]),
   result: Y
-}).strict(), lr = d({
-  jsonrpc: E(Pe),
-  id: D([s(), k().int()]),
+}).strict(), mr = d({
+  jsonrpc: x(Ae),
+  id: j([s(), k().int()]),
   error: d({
     code: k().int(),
     message: s(),
-    data: S(ne())
+    data: E(oe())
   })
-}).strict(), cr = d({
-  jsonrpc: E(Pe)
+}).strict(), fr = d({
+  jsonrpc: x(Ae)
 }).merge(
   d({
     method: s(),
-    params: S(Ie)
+    params: E(Pe)
   })
-).strict(), ce = D([
-  ar,
-  cr,
-  ir,
-  lr
+).strict(), pe = j([
+  pr,
+  fr,
+  hr,
+  mr
 ]), xt = typeof __PACKAGE_VERSION__ < "u" ? __PACKAGE_VERSION__ : "0.0.0-test", It = d({
   access_token: s(),
   id_token: s().optional(),
@@ -236,7 +304,7 @@ var Jn = Y.extend({
   expires_in: k().optional(),
   scope: s().optional(),
   refresh_token: s().optional()
-}).strip(), J = s().url().superRefine((e, t) => {
+}).strip(), B = s().url().superRefine((e, t) => {
   if (!URL.canParse(e))
     return t.addIssue({
       code: Cn.custom,
@@ -249,112 +317,112 @@ var Jn = Y.extend({
     return t.protocol !== "javascript:" && t.protocol !== "data:" && t.protocol !== "vbscript:";
   },
   { message: "URL cannot use javascript:, data:, or vbscript: scheme" }
-), ur = d({
+), gr = d({
   resource: s().url(),
-  authorization_servers: v(J).optional(),
+  authorization_servers: y(B).optional(),
   jwks_uri: s().url().optional(),
-  scopes_supported: v(s()).optional(),
-  bearer_methods_supported: v(s()).optional(),
-  resource_signing_alg_values_supported: v(s()).optional(),
+  scopes_supported: y(s()).optional(),
+  bearer_methods_supported: y(s()).optional(),
+  resource_signing_alg_values_supported: y(s()).optional(),
   resource_name: s().optional(),
   resource_documentation: s().optional(),
   resource_policy_uri: s().url().optional(),
   resource_tos_uri: s().url().optional(),
   tls_client_certificate_bound_access_tokens: X().optional(),
-  authorization_details_types_supported: v(s()).optional(),
-  dpop_signing_alg_values_supported: v(s()).optional(),
+  authorization_details_types_supported: y(s()).optional(),
+  dpop_signing_alg_values_supported: y(s()).optional(),
   dpop_bound_access_tokens_required: X().optional()
-}).passthrough(), Pt = d({
+}).passthrough(), Ot = d({
   issuer: s(),
-  authorization_endpoint: J,
-  token_endpoint: J,
-  registration_endpoint: J.optional(),
-  scopes_supported: v(s()).optional(),
-  response_types_supported: v(s()),
-  grant_types_supported: v(s()).optional(),
-  code_challenge_methods_supported: v(s()),
-  token_endpoint_auth_methods_supported: v(s()).optional(),
-  token_endpoint_auth_signing_alg_values_supported: v(s()).optional()
-}).passthrough(), dr = d({
+  authorization_endpoint: B,
+  token_endpoint: B,
+  registration_endpoint: B.optional(),
+  scopes_supported: y(s()).optional(),
+  response_types_supported: y(s()),
+  grant_types_supported: y(s()).optional(),
+  code_challenge_methods_supported: y(s()),
+  token_endpoint_auth_methods_supported: y(s()).optional(),
+  token_endpoint_auth_signing_alg_values_supported: y(s()).optional()
+}).passthrough(), _r = d({
   issuer: s(),
-  authorization_endpoint: J,
-  token_endpoint: J,
-  userinfo_endpoint: J.optional(),
-  jwks_uri: J,
-  registration_endpoint: J.optional(),
-  scopes_supported: v(s()).optional(),
-  response_types_supported: v(s()),
-  grant_types_supported: v(s()).optional(),
-  subject_types_supported: v(s()),
-  id_token_signing_alg_values_supported: v(s()),
-  claims_supported: v(s()).optional(),
-  token_endpoint_auth_methods_supported: v(s()).optional()
-}).passthrough(), pr = dr.merge(
-  Pt.pick({
+  authorization_endpoint: B,
+  token_endpoint: B,
+  userinfo_endpoint: B.optional(),
+  jwks_uri: B,
+  registration_endpoint: B.optional(),
+  scopes_supported: y(s()).optional(),
+  response_types_supported: y(s()),
+  grant_types_supported: y(s()).optional(),
+  subject_types_supported: y(s()),
+  id_token_signing_alg_values_supported: y(s()),
+  claims_supported: y(s()).optional(),
+  token_endpoint_auth_methods_supported: y(s()).optional()
+}).passthrough(), vr = _r.merge(
+  Ot.pick({
     code_challenge_methods_supported: !0
   })
-), hr = d({
+), yr = d({
   client_id: s(),
   client_secret: s().optional(),
   client_id_issued_at: k().optional(),
   client_secret_expires_at: k().optional()
-}).strip(), mr = d({
-  redirect_uris: v(J),
+}).strip(), wr = d({
+  redirect_uris: y(B),
   token_endpoint_auth_method: s().optional(),
-  grant_types: v(s()).optional(),
-  response_types: v(s()).optional(),
+  grant_types: y(s()).optional(),
+  response_types: y(s()).optional(),
   client_name: s().optional(),
-  client_uri: J.optional(),
-  logo_uri: J.optional(),
+  client_uri: B.optional(),
+  logo_uri: B.optional(),
   scope: s().optional(),
-  contacts: v(s()).optional(),
-  tos_uri: J.optional(),
+  contacts: y(s()).optional(),
+  tos_uri: B.optional(),
   policy_uri: s().optional(),
-  jwks_uri: J.optional(),
-  jwks: vt().optional(),
+  jwks_uri: B.optional(),
+  jwks: K().optional(),
   software_id: s().optional(),
   software_version: s().optional(),
   software_statement: s().optional()
-}).strip(), gr = d({
+}).strip(), br = d({
   error: s(),
   error_description: s().optional(),
   error_uri: s().optional()
-}), fr = mr.merge(
-  hr
-), _r = "AI_MCPClientOAuthError", Ot = `vercel.ai.error.${_r}`, vr = Symbol.for(Ot), ot, st, me = class extends (st = ye, ot = vr, st) {
+}), kr = wr.merge(
+  yr
+), Tr = "AI_MCPClientOAuthError", Pt = `vercel.ai.error.${Tr}`, Sr = Symbol.for(Pt), at, it, _e = class extends (it = be, at = Sr, it) {
   constructor({
     name: e = "MCPClientOAuthError",
     message: t,
     cause: n
   }) {
-    super({ name: e, message: t, cause: n }), this[ot] = !0;
+    super({ name: e, message: t, cause: n }), this[at] = !0;
   }
   static isInstance(e) {
-    return ye.hasMarker(e, Ot);
+    return be.hasMarker(e, Pt);
   }
-}, ae = class extends me {
+}, ce = class extends _e {
 };
-ae.errorCode = "server_error";
-var we = class extends me {
+ce.errorCode = "server_error";
+var ke = class extends _e {
 };
-we.errorCode = "invalid_client";
-var be = class extends me {
+ke.errorCode = "invalid_client";
+var Te = class extends _e {
 };
-be.errorCode = "invalid_grant";
-var ke = class extends me {
+Te.errorCode = "invalid_grant";
+var Se = class extends _e {
 };
-ke.errorCode = "unauthorized_client";
-var yr = {
-  [ae.errorCode]: ae,
-  [we.errorCode]: we,
-  [be.errorCode]: be,
-  [ke.errorCode]: ke
+Se.errorCode = "unauthorized_client";
+var Rr = {
+  [ce.errorCode]: ce,
+  [ke.errorCode]: ke,
+  [Te.errorCode]: Te,
+  [Se.errorCode]: Se
 };
-function wr(e) {
+function Er(e) {
   const t = typeof e == "string" ? new URL(e) : new URL(e.href);
   return t.hash = "", t;
 }
-function br({
+function Cr({
   requestedResource: e,
   configuredResource: t
 }) {
@@ -364,12 +432,12 @@ function br({
   const o = n.pathname.endsWith("/") ? n.pathname : n.pathname + "/", a = r.pathname.endsWith("/") ? r.pathname : r.pathname + "/";
   return o.startsWith(a);
 }
-var Te = class extends Error {
+var Re = class extends Error {
   constructor(e = "Unauthorized") {
     super(e), this.name = "UnauthorizedError";
   }
 };
-function Se(e) {
+function Ee(e) {
   var t;
   const n = (t = e.headers.get("www-authenticate")) != null ? t : e.headers.get("WWW-Authenticate");
   if (!n)
@@ -377,53 +445,53 @@ function Se(e) {
   const [r, o] = n.split(" ");
   if (r.toLowerCase() !== "bearer" || !o)
     return;
-  const a = /resource_metadata="([^"]*)"/, l = n.match(a);
-  if (l)
+  const a = /resource_metadata="([^"]*)"/, i = n.match(a);
+  if (i)
     try {
-      return new URL(l[1]);
+      return new URL(i[1]);
     } catch {
       return;
     }
 }
-function kr(e, t = "", n = {}) {
+function xr(e, t = "", n = {}) {
   return t.endsWith("/") && (t = t.slice(0, -1)), n.prependPathname ? `${t}/.well-known/${e}` : `/.well-known/${e}${t}`;
 }
-async function Ge(e, t, n = fetch) {
+async function Ke(e, t, n = fetch) {
   try {
     return await n(e, { headers: t });
   } catch (r) {
     if (r instanceof TypeError)
-      return t ? Ge(e, void 0, n) : void 0;
+      return t ? Ke(e, void 0, n) : void 0;
     throw r;
   }
 }
-async function at(e, t, n = fetch) {
-  return await Ge(e, {
+async function lt(e, t, n = fetch) {
+  return await Ke(e, {
     "MCP-Protocol-Version": t
   }, n);
 }
-function Tr(e, t) {
+function Ir(e, t) {
   return !e || e.status >= 400 && e.status < 500 && t !== "/";
 }
-async function Sr(e, t, n, r) {
+async function Or(e, t, n, r) {
   var o, a;
-  const l = new URL(e), c = (o = r?.protocolVersion) != null ? o : ie;
-  let i;
+  const i = new URL(e), c = (o = r?.protocolVersion) != null ? o : ue;
+  let l;
   if (r?.metadataUrl)
-    i = new URL(r.metadataUrl);
+    l = new URL(r.metadataUrl);
   else {
-    const h = kr(t, l.pathname);
-    i = new URL(h, (a = r?.metadataServerUrl) != null ? a : l), i.search = l.search;
+    const h = xr(t, i.pathname);
+    l = new URL(h, (a = r?.metadataServerUrl) != null ? a : i), l.search = i.search;
   }
-  let u = await at(i, c, n);
-  if (!r?.metadataUrl && Tr(u, l.pathname)) {
-    const h = new URL(`/.well-known/${t}`, l);
-    u = await at(h, c, n);
+  let u = await lt(l, c, n);
+  if (!r?.metadataUrl && Ir(u, i.pathname)) {
+    const h = new URL(`/.well-known/${t}`, i);
+    u = await lt(h, c, n);
   }
   return u;
 }
-async function Rr(e, t, n = fetch) {
-  const r = await Sr(
+async function Pr(e, t, n = fetch) {
+  const r = await Or(
     e,
     "oauth-protected-resource",
     n,
@@ -440,9 +508,9 @@ async function Rr(e, t, n = fetch) {
     throw new Error(
       `HTTP ${r.status} trying to load well-known OAuth protected resource metadata.`
     );
-  return ur.parse(await r.json());
+  return gr.parse(await r.json());
 }
-function Er(e) {
+function Ar(e) {
   const t = typeof e == "string" ? new URL(e) : e, n = t.pathname !== "/", r = [];
   if (!n)
     return r.push({
@@ -470,85 +538,85 @@ function Er(e) {
     type: "oidc"
   }), r;
 }
-async function Cr(e, {
+async function $r(e, {
   fetchFn: t = fetch,
-  protocolVersion: n = ie
+  protocolVersion: n = ue
 } = {}) {
   var r;
-  const o = { "MCP-Protocol-Version": n }, a = Er(e);
-  for (const { url: l, type: c } of a) {
-    const i = await Ge(l, o, t);
-    if (i) {
-      if (!i.ok) {
-        if (i.status >= 400 && i.status < 500)
+  const o = { "MCP-Protocol-Version": n }, a = Ar(e);
+  for (const { url: i, type: c } of a) {
+    const l = await Ke(i, o, t);
+    if (l) {
+      if (!l.ok) {
+        if (l.status >= 400 && l.status < 500)
           continue;
         throw new Error(
-          `HTTP ${i.status} trying to load ${c === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${l}`
+          `HTTP ${l.status} trying to load ${c === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${i}`
         );
       }
       if (c === "oauth")
-        return Pt.parse(await i.json());
+        return Ot.parse(await l.json());
       {
-        const u = pr.parse(
-          await i.json()
+        const u = vr.parse(
+          await l.json()
         );
         if (!((r = u.code_challenge_methods_supported) != null && r.includes("S256")))
           throw new Error(
-            `Incompatible OIDC provider at ${l}: does not support S256 code challenge method required by MCP specification`
+            `Incompatible OIDC provider at ${i}: does not support S256 code challenge method required by MCP specification`
           );
         return u;
       }
     }
   }
 }
-async function xr(e, {
+async function Ur(e, {
   metadata: t,
   clientInformation: n,
   redirectUrl: r,
   scope: o,
   state: a,
-  resource: l
+  resource: i
 }) {
-  const c = "code", i = "S256";
+  const c = "code", l = "S256";
   let u;
   if (t) {
     if (u = new URL(t.authorization_endpoint), !t.response_types_supported.includes(c))
       throw new Error(
         `Incompatible auth server: does not support response type ${c}`
       );
-    if (!t.code_challenge_methods_supported || !t.code_challenge_methods_supported.includes(i))
+    if (!t.code_challenge_methods_supported || !t.code_challenge_methods_supported.includes(l))
       throw new Error(
-        `Incompatible auth server: does not support code challenge method ${i}`
+        `Incompatible auth server: does not support code challenge method ${l}`
       );
   } else
     u = new URL("/authorize", e);
-  const h = await jn(), f = h.code_verifier, m = h.code_challenge;
-  return u.searchParams.set("response_type", c), u.searchParams.set("client_id", n.client_id), u.searchParams.set("code_challenge", m), u.searchParams.set(
+  const h = await Jn(), g = h.code_verifier, f = h.code_challenge;
+  return u.searchParams.set("response_type", c), u.searchParams.set("client_id", n.client_id), u.searchParams.set("code_challenge", f), u.searchParams.set(
     "code_challenge_method",
-    i
-  ), u.searchParams.set("redirect_uri", String(r)), a && u.searchParams.set("state", a), o && u.searchParams.set("scope", o), o?.includes("offline_access") && u.searchParams.append("prompt", "consent"), l && u.searchParams.set("resource", l.href), { authorizationUrl: u, codeVerifier: f };
+    l
+  ), u.searchParams.set("redirect_uri", String(r)), a && u.searchParams.set("state", a), o && u.searchParams.set("scope", o), o?.includes("offline_access") && u.searchParams.append("prompt", "consent"), i && u.searchParams.set("resource", i.href), { authorizationUrl: u, codeVerifier: g };
 }
 function At(e, t) {
   const n = e.client_secret !== void 0;
   return t.length === 0 ? n ? "client_secret_post" : "none" : n && t.includes("client_secret_basic") ? "client_secret_basic" : n && t.includes("client_secret_post") ? "client_secret_post" : t.includes("none") ? "none" : n ? "client_secret_post" : "none";
 }
-function Ut(e, t, n, r) {
+function $t(e, t, n, r) {
   const { client_id: o, client_secret: a } = t;
   switch (e) {
     case "client_secret_basic":
-      Ir(o, a, n);
+      Mr(o, a, n);
       return;
     case "client_secret_post":
-      Pr(o, a, r);
+      Nr(o, a, r);
       return;
     case "none":
-      Or(o, r);
+      jr(o, r);
       return;
     default:
       throw new Error(`Unsupported client authentication method: ${e}`);
   }
 }
-function Ir(e, t, n) {
+function Mr(e, t, n) {
   if (!t)
     throw new Error(
       "client_secret_basic authentication requires a client_secret"
@@ -556,116 +624,116 @@ function Ir(e, t, n) {
   const r = btoa(`${e}:${t}`);
   n.set("Authorization", `Basic ${r}`);
 }
-function Pr(e, t, n) {
+function Nr(e, t, n) {
   n.set("client_id", e), t && n.set("client_secret", t);
 }
-function Or(e, t) {
+function jr(e, t) {
   t.set("client_id", e);
 }
-async function Fe(e) {
+async function Ze(e) {
   const t = e instanceof Response ? e.status : void 0, n = e instanceof Response ? await e.text() : e;
   try {
-    const r = gr.parse(JSON.parse(n)), { error: o, error_description: a, error_uri: l } = r, c = yr[o] || ae;
+    const r = br.parse(JSON.parse(n)), { error: o, error_description: a, error_uri: i } = r, c = Rr[o] || ce;
     return new c({
       message: a || "",
-      cause: l
+      cause: i
     });
   } catch (r) {
     const o = `${t ? `HTTP ${t}: ` : ""}Invalid OAuth error response: ${r}. Raw body: ${n}`;
-    return new ae({ message: o });
+    return new ce({ message: o });
   }
 }
-async function Ar(e, {
+async function Dr(e, {
   metadata: t,
   clientInformation: n,
   authorizationCode: r,
   codeVerifier: o,
   redirectUri: a,
-  resource: l,
+  resource: i,
   addClientAuthentication: c,
-  fetchFn: i
+  fetchFn: l
 }) {
   var u;
-  const h = "authorization_code", f = t?.token_endpoint ? new URL(t.token_endpoint) : new URL("/token", e);
+  const h = "authorization_code", g = t?.token_endpoint ? new URL(t.token_endpoint) : new URL("/token", e);
   if (t?.grant_types_supported && !t.grant_types_supported.includes(h))
     throw new Error(
       `Incompatible auth server: does not support grant type ${h}`
     );
-  const m = new Headers({
+  const f = new Headers({
     "Content-Type": "application/x-www-form-urlencoded",
     Accept: "application/json"
-  }), _ = new URLSearchParams({
+  }), v = new URLSearchParams({
     grant_type: h,
     code: r,
     code_verifier: o,
     redirect_uri: String(a)
   });
   if (c)
-    c(m, _, e, t);
+    c(f, v, e, t);
   else {
-    const p = (u = t?.token_endpoint_auth_methods_supported) != null ? u : [], b = At(
+    const p = (u = t?.token_endpoint_auth_methods_supported) != null ? u : [], w = At(
       n,
       p
     );
-    Ut(b, n, m, _);
+    $t(w, n, f, v);
   }
-  l && _.set("resource", l.href);
-  const g = await (i ?? fetch)(f, {
+  i && v.set("resource", i.href);
+  const m = await (l ?? fetch)(g, {
     method: "POST",
-    headers: m,
-    body: _
+    headers: f,
+    body: v
   });
-  if (!g.ok)
-    throw await Fe(g);
-  return It.parse(await g.json());
+  if (!m.ok)
+    throw await Ze(m);
+  return It.parse(await m.json());
 }
-async function Ur(e, {
+async function Hr(e, {
   metadata: t,
   clientInformation: n,
   refreshToken: r,
   resource: o,
   addClientAuthentication: a,
-  fetchFn: l
+  fetchFn: i
 }) {
   var c;
-  const i = "refresh_token";
+  const l = "refresh_token";
   let u;
   if (t) {
-    if (u = new URL(t.token_endpoint), t.grant_types_supported && !t.grant_types_supported.includes(i))
+    if (u = new URL(t.token_endpoint), t.grant_types_supported && !t.grant_types_supported.includes(l))
       throw new Error(
-        `Incompatible auth server: does not support grant type ${i}`
+        `Incompatible auth server: does not support grant type ${l}`
       );
   } else
     u = new URL("/token", e);
   const h = new Headers({
     "Content-Type": "application/x-www-form-urlencoded"
-  }), f = new URLSearchParams({
-    grant_type: i,
+  }), g = new URLSearchParams({
+    grant_type: l,
     refresh_token: r
   });
   if (a)
-    a(h, f, e, t);
+    a(h, g, e, t);
   else {
-    const _ = (c = t?.token_endpoint_auth_methods_supported) != null ? c : [], g = At(
+    const v = (c = t?.token_endpoint_auth_methods_supported) != null ? c : [], m = At(
       n,
-      _
+      v
     );
-    Ut(g, n, h, f);
+    $t(m, n, h, g);
   }
-  o && f.set("resource", o.href);
-  const m = await (l ?? fetch)(u, {
+  o && g.set("resource", o.href);
+  const f = await (i ?? fetch)(u, {
     method: "POST",
     headers: h,
-    body: f
+    body: g
   });
-  if (!m.ok)
-    throw await Fe(m);
+  if (!f.ok)
+    throw await Ze(f);
   return It.parse({
     refresh_token: r,
-    ...await m.json()
+    ...await f.json()
   });
 }
-async function $r(e, {
+async function Lr(e, {
   metadata: t,
   clientMetadata: n,
   fetchFn: r
@@ -687,30 +755,30 @@ async function $r(e, {
     body: JSON.stringify(n)
   });
   if (!a.ok)
-    throw await Fe(a);
-  return fr.parse(await a.json());
+    throw await Ze(a);
+  return kr.parse(await a.json());
 }
-async function Re(e, t) {
+async function Ce(e, t) {
   var n, r;
   try {
-    return await Ue(e, t);
+    return await Me(e, t);
   } catch (o) {
-    if (o instanceof we || o instanceof ke)
-      return await ((n = e.invalidateCredentials) == null ? void 0 : n.call(e, "all")), await Ue(e, t);
-    if (o instanceof be)
-      return await ((r = e.invalidateCredentials) == null ? void 0 : r.call(e, "tokens")), await Ue(e, t);
+    if (o instanceof ke || o instanceof Se)
+      return await ((n = e.invalidateCredentials) == null ? void 0 : n.call(e, "all")), await Me(e, t);
+    if (o instanceof Te)
+      return await ((r = e.invalidateCredentials) == null ? void 0 : r.call(e, "tokens")), await Me(e, t);
     throw o;
   }
 }
-async function Mr(e, t, n) {
-  const r = wr(e);
+async function qr(e, t, n) {
+  const r = Er(e);
   if (t.validateResourceURL)
     return await t.validateResourceURL(
       r,
       n?.resource
     );
   if (n) {
-    if (!br({
+    if (!Cr({
       requestedResource: r,
       configuredResource: n.resource
     }))
@@ -720,28 +788,28 @@ async function Mr(e, t, n) {
     return new URL(n.resource);
   }
 }
-async function Ue(e, {
+async function Me(e, {
   serverUrl: t,
   authorizationCode: n,
   scope: r,
   resourceMetadataUrl: o,
   fetchFn: a
 }) {
-  let l, c;
+  let i, c;
   try {
-    l = await Rr(
+    i = await Pr(
       t,
       { resourceMetadataUrl: o },
       a
-    ), l.authorization_servers && l.authorization_servers.length > 0 && (c = l.authorization_servers[0]);
+    ), i.authorization_servers && i.authorization_servers.length > 0 && (c = i.authorization_servers[0]);
   } catch {
   }
   c || (c = t);
-  const i = await Mr(
+  const l = await qr(
     t,
     e,
-    l
-  ), u = await Cr(
+    i
+  ), u = await $r(
     c,
     {
       fetchFn: a
@@ -757,7 +825,7 @@ async function Ue(e, {
       throw new Error(
         "OAuth client information must be saveable for dynamic registration"
       );
-    const p = await $r(c, {
+    const p = await Lr(c, {
       metadata: u,
       clientMetadata: e.clientMetadata,
       fetchFn: a
@@ -765,26 +833,26 @@ async function Ue(e, {
     await e.saveClientInformation(p), h = p;
   }
   if (n !== void 0) {
-    const p = await e.codeVerifier(), b = await Ar(c, {
+    const p = await e.codeVerifier(), w = await Dr(c, {
       metadata: u,
       clientInformation: h,
       authorizationCode: n,
       codeVerifier: p,
       redirectUri: e.redirectUrl,
-      resource: i,
+      resource: l,
       addClientAuthentication: e.addClientAuthentication,
       fetchFn: a
     });
-    return await e.saveTokens(b), "AUTHORIZED";
+    return await e.saveTokens(w), "AUTHORIZED";
   }
-  const f = await e.tokens();
-  if (f?.refresh_token)
+  const g = await e.tokens();
+  if (g?.refresh_token)
     try {
-      const p = await Ur(c, {
+      const p = await Hr(c, {
         metadata: u,
         clientInformation: h,
-        refreshToken: f.refresh_token,
-        resource: i,
+        refreshToken: g.refresh_token,
+        resource: l,
         addClientAuthentication: e.addClientAuthentication,
         fetchFn: a
       });
@@ -792,23 +860,23 @@ async function Ue(e, {
     } catch (p) {
       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.
-        !(!(p instanceof me) || p instanceof ae)
+        !(!(p instanceof _e) || p instanceof ce)
       ) throw p;
     }
-  const m = e.state ? await e.state() : void 0, { authorizationUrl: _, codeVerifier: g } = await xr(
+  const f = e.state ? await e.state() : void 0, { authorizationUrl: v, codeVerifier: m } = await Ur(
     c,
     {
       metadata: u,
       clientInformation: h,
-      state: m,
+      state: f,
       redirectUrl: e.redirectUrl,
       scope: r || e.clientMetadata.scope,
-      resource: i
+      resource: l
     }
   );
-  return await e.saveCodeVerifier(g), await e.redirectToAuthorization(_), "REDIRECT";
+  return await e.saveCodeVerifier(m), await e.redirectToAuthorization(v), "REDIRECT";
 }
-var Nr = class {
+var Vr = class {
   constructor({
     url: e,
     headers: t,
@@ -820,16 +888,16 @@ var Nr = class {
     const t = {
       ...this.headers,
       ...e,
-      "mcp-protocol-version": ie
+      "mcp-protocol-version": ue
     };
     if (this.authProvider) {
       const n = await this.authProvider.tokens();
       n?.access_token && (t.Authorization = `Bearer ${n.access_token}`);
     }
-    return gt(
+    return vt(
       t,
       `ai-sdk/${xt}`,
-      ft()
+      _t()
     );
   }
   async start() {
@@ -838,7 +906,7 @@ var Nr = class {
         return e();
       this.abortController = new AbortController();
       const n = async (r = !1) => {
-        var o, a, l, c, i;
+        var o, a, i, c, l;
         try {
           const u = await this.commonHeaders({
             Accept: "text/event-stream"
@@ -847,74 +915,74 @@ var Nr = class {
             signal: (o = this.abortController) == null ? void 0 : o.signal
           });
           if (h.status === 401 && this.authProvider && !r) {
-            this.resourceMetadataUrl = Se(h);
+            this.resourceMetadataUrl = Ee(h);
             try {
-              if (await Re(this.authProvider, {
+              if (await Ce(this.authProvider, {
                 serverUrl: this.url,
                 resourceMetadataUrl: this.resourceMetadataUrl
               }) !== "AUTHORIZED") {
-                const p = new Te();
+                const p = new Re();
                 return (a = this.onerror) == null || a.call(this, p), t(p);
               }
-            } catch (g) {
-              return (l = this.onerror) == null || l.call(this, g), t(g);
+            } catch (m) {
+              return (i = this.onerror) == null || i.call(this, m), t(m);
             }
             return n(!0);
           }
           if (!h.ok || !h.body) {
-            let g = `MCP SSE Transport Error: ${h.status} ${h.statusText}`;
-            h.status === 405 && (g += ". This server does not support SSE transport. Try using `http` transport instead");
-            const p = new P({
-              message: g
+            let m = `MCP SSE Transport Error: ${h.status} ${h.statusText}`;
+            h.status === 405 && (m += ". This server does not support SSE transport. Try using `http` transport instead");
+            const p = new O({
+              message: m
             });
             return (c = this.onerror) == null || c.call(this, p), t(p);
           }
-          const m = h.body.pipeThrough(new TextDecoderStream()).pipeThrough(new De()).getReader(), _ = async () => {
-            var g, p, b;
+          const f = h.body.pipeThrough(new TextDecoderStream()).pipeThrough(new He()).getReader(), v = async () => {
+            var m, p, w;
             try {
               for (; ; ) {
-                const { done: y, value: T } = await m.read();
-                if (y) {
+                const { done: b, value: R } = await f.read();
+                if (b) {
                   if (this.connected)
-                    throw this.connected = !1, new P({
+                    throw this.connected = !1, new O({
                       message: "MCP SSE Transport Error: Connection closed unexpectedly"
                     });
                   return;
                 }
-                const { event: w, data: A } = T;
-                if (w === "endpoint") {
-                  if (this.endpoint = new URL(A, this.url), this.endpoint.origin !== this.url.origin)
-                    throw new P({
+                const { event: T, data: S } = R;
+                if (T === "endpoint") {
+                  if (this.endpoint = new URL(S, this.url), this.endpoint.origin !== this.url.origin)
+                    throw new O({
                       message: `MCP SSE Transport Error: Endpoint origin does not match connection origin: ${this.endpoint.origin}`
                     });
                   this.connected = !0, e();
-                } else if (w === "message")
+                } else if (T === "message")
                   try {
-                    const x = ce.parse(
-                      JSON.parse(A)
+                    const M = pe.parse(
+                      JSON.parse(S)
                     );
-                    (g = this.onmessage) == null || g.call(this, x);
-                  } catch (x) {
-                    const $ = new P({
+                    (m = this.onmessage) == null || m.call(this, M);
+                  } catch (M) {
+                    const $ = new O({
                       message: "MCP SSE Transport Error: Failed to parse message",
-                      cause: x
+                      cause: M
                     });
                     (p = this.onerror) == null || p.call(this, $);
                   }
               }
-            } catch (y) {
-              if (y instanceof Error && y.name === "AbortError")
+            } catch (b) {
+              if (b instanceof Error && b.name === "AbortError")
                 return;
-              (b = this.onerror) == null || b.call(this, y), t(y);
+              (w = this.onerror) == null || w.call(this, b), t(b);
             }
           };
           this.sseConnection = {
-            close: () => m.cancel()
-          }, _();
+            close: () => f.cancel()
+          }, v();
         } catch (u) {
           if (u instanceof Error && u.name === "AbortError")
             return;
-          (i = this.onerror) == null || i.call(this, u), t(u);
+          (l = this.onerror) == null || l.call(this, u), t(u);
         }
       };
       n();
@@ -926,11 +994,11 @@ var Nr = class {
   }
   async send(e) {
     if (!this.endpoint || !this.connected)
-      throw new P({
+      throw new O({
         message: "MCP SSE Transport Error: Not connected"
       });
     const t = this.endpoint, n = async (r = !1) => {
-      var o, a, l, c, i;
+      var o, a, i, c, l;
       try {
         const h = {
           method: "POST",
@@ -939,39 +1007,39 @@ var Nr = class {
           }),
           body: JSON.stringify(e),
           signal: (o = this.abortController) == null ? void 0 : o.signal
-        }, f = await fetch(t, h);
-        if (f.status === 401 && this.authProvider && !r) {
-          this.resourceMetadataUrl = Se(f);
+        }, g = await fetch(t, h);
+        if (g.status === 401 && this.authProvider && !r) {
+          this.resourceMetadataUrl = Ee(g);
           try {
-            if (await Re(this.authProvider, {
+            if (await Ce(this.authProvider, {
               serverUrl: this.url,
               resourceMetadataUrl: this.resourceMetadataUrl
             }) !== "AUTHORIZED") {
-              const _ = new Te();
-              (a = this.onerror) == null || a.call(this, _);
+              const v = new Re();
+              (a = this.onerror) == null || a.call(this, v);
               return;
             }
-          } catch (m) {
-            (l = this.onerror) == null || l.call(this, m);
+          } catch (f) {
+            (i = this.onerror) == null || i.call(this, f);
             return;
           }
           return n(!0);
         }
-        if (!f.ok) {
-          const m = await f.text().catch(() => null), _ = new P({
-            message: `MCP SSE Transport Error: POSTing to endpoint (HTTP ${f.status}): ${m}`
+        if (!g.ok) {
+          const f = await g.text().catch(() => null), v = new O({
+            message: `MCP SSE Transport Error: POSTing to endpoint (HTTP ${g.status}): ${f}`
           });
-          (c = this.onerror) == null || c.call(this, _);
+          (c = this.onerror) == null || c.call(this, v);
           return;
         }
       } catch (u) {
-        (i = this.onerror) == null || i.call(this, u);
+        (l = this.onerror) == null || l.call(this, u);
         return;
       }
     };
     await n();
   }
-}, Dr = class {
+}, Br = class {
   constructor({
     url: e,
     headers: t,
@@ -988,21 +1056,21 @@ var Nr = class {
     const t = {
       ...this.headers,
       ...e,
-      "mcp-protocol-version": ie
+      "mcp-protocol-version": ue
     };
     if (this.sessionId && (t["mcp-session-id"] = this.sessionId), this.authProvider) {
       const n = await this.authProvider.tokens();
       n?.access_token && (t.Authorization = `Bearer ${n.access_token}`);
     }
-    return gt(
+    return vt(
       t,
       `ai-sdk/${xt}`,
-      ft()
+      _t()
     );
   }
   async start() {
     if (this.abortController)
-      throw new P({
+      throw new O({
         message: "MCP HTTP Transport Error: Transport already started. Note: client.connect() calls start() automatically."
       });
     this.abortController = new AbortController(), this.openInboundSse();
@@ -1026,9 +1094,9 @@ var Nr = class {
   }
   async send(e) {
     const t = async (n = !1) => {
-      var r, o, a, l, c, i, u;
+      var r, o, a, i, c, l, u;
       try {
-        const f = {
+        const g = {
           method: "POST",
           headers: await this.commonHeaders({
             "Content-Type": "application/json",
@@ -1036,78 +1104,78 @@ var Nr = class {
           }),
           body: JSON.stringify(e),
           signal: (r = this.abortController) == null ? void 0 : r.signal
-        }, m = await fetch(this.url, f), _ = m.headers.get("mcp-session-id");
-        if (_ && (this.sessionId = _), m.status === 401 && this.authProvider && !n) {
-          this.resourceMetadataUrl = Se(m);
+        }, f = await fetch(this.url, g), v = f.headers.get("mcp-session-id");
+        if (v && (this.sessionId = v), f.status === 401 && this.authProvider && !n) {
+          this.resourceMetadataUrl = Ee(f);
           try {
-            if (await Re(this.authProvider, {
+            if (await Ce(this.authProvider, {
               serverUrl: this.url,
               resourceMetadataUrl: this.resourceMetadataUrl
             }) !== "AUTHORIZED")
-              throw new Te();
-          } catch (b) {
-            throw (o = this.onerror) == null || o.call(this, b), b;
+              throw new Re();
+          } catch (w) {
+            throw (o = this.onerror) == null || o.call(this, w), w;
           }
           return t(!0);
         }
-        if (m.status === 202) {
+        if (f.status === 202) {
           this.inboundSseConnection || this.openInboundSse();
           return;
         }
-        if (!m.ok) {
-          const b = await m.text().catch(() => null);
-          let y = `MCP HTTP Transport Error: POSTing to endpoint (HTTP ${m.status}): ${b}`;
-          m.status === 404 && (y += ". This server does not support HTTP transport. Try using `sse` transport instead");
-          const T = new P({
-            message: y
+        if (!f.ok) {
+          const w = await f.text().catch(() => null);
+          let b = `MCP HTTP Transport Error: POSTing to endpoint (HTTP ${f.status}): ${w}`;
+          f.status === 404 && (b += ". This server does not support HTTP transport. Try using `sse` transport instead");
+          const R = new O({
+            message: b
           });
-          throw (a = this.onerror) == null || a.call(this, T), T;
+          throw (a = this.onerror) == null || a.call(this, R), R;
         }
-        const g = m.headers.get("content-type") || "";
-        if (g.includes("application/json")) {
-          const b = await m.json(), y = Array.isArray(b) ? b.map((T) => ce.parse(T)) : [ce.parse(b)];
-          for (const T of y) (l = this.onmessage) == null || l.call(this, T);
+        const m = f.headers.get("content-type") || "";
+        if (m.includes("application/json")) {
+          const w = await f.json(), b = Array.isArray(w) ? w.map((R) => pe.parse(R)) : [pe.parse(w)];
+          for (const R of b) (i = this.onmessage) == null || i.call(this, R);
           return;
         }
-        if (g.includes("text/event-stream")) {
-          if (!m.body) {
-            const w = new P({
+        if (m.includes("text/event-stream")) {
+          if (!f.body) {
+            const T = new O({
               message: "MCP HTTP Transport Error: text/event-stream response without body"
             });
-            throw (c = this.onerror) == null || c.call(this, w), w;
+            throw (c = this.onerror) == null || c.call(this, T), T;
           }
-          const y = m.body.pipeThrough(new TextDecoderStream()).pipeThrough(new De()).getReader();
+          const b = f.body.pipeThrough(new TextDecoderStream()).pipeThrough(new He()).getReader();
           (async () => {
-            var w, A, x;
+            var T, S, M;
             try {
               for (; ; ) {
-                const { done: $, value: M } = await y.read();
+                const { done: $, value: A } = await b.read();
                 if ($) return;
-                const { event: H, data: W } = M;
-                if (H === "message")
+                const { event: I, data: z } = A;
+                if (I === "message")
                   try {
-                    const z = ce.parse(JSON.parse(W));
-                    (w = this.onmessage) == null || w.call(this, z);
-                  } catch (z) {
-                    const G = new P({
+                    const J = pe.parse(JSON.parse(z));
+                    (T = this.onmessage) == null || T.call(this, J);
+                  } catch (J) {
+                    const G = new O({
                       message: "MCP HTTP Transport Error: Failed to parse message",
-                      cause: z
+                      cause: J
                     });
-                    (A = this.onerror) == null || A.call(this, G);
+                    (S = this.onerror) == null || S.call(this, G);
                   }
               }
             } catch ($) {
               if ($ instanceof Error && $.name === "AbortError")
                 return;
-              (x = this.onerror) == null || x.call(this, $);
+              (M = this.onerror) == null || M.call(this, $);
             }
           })();
           return;
         }
-        const p = new P({
-          message: `MCP HTTP Transport Error: Unexpected content type: ${g}`
+        const p = new O({
+          message: `MCP HTTP Transport Error: Unexpected content type: ${m}`
         });
-        throw (i = this.onerror) == null || i.call(this, p), p;
+        throw (l = this.onerror) == null || l.call(this, p), p;
       } catch (h) {
         throw (u = this.onerror) == null || u.call(this, h), h;
       }
@@ -1131,7 +1199,7 @@ var Nr = class {
     if (t > 0 && this.inboundReconnectAttempts >= t) {
       (e = this.onerror) == null || e.call(
         this,
-        new P({
+        new O({
           message: `MCP HTTP Transport Error: Maximum reconnection attempts (${t}) exceeded.`
         })
       );
@@ -1145,30 +1213,30 @@ var Nr = class {
   }
   // Open optional inbound SSE stream; best-effort and resumable
   async openInboundSse(e = !1, t) {
-    var n, r, o, a, l, c;
+    var n, r, o, a, i, c;
     try {
-      const i = await this.commonHeaders({
+      const l = await this.commonHeaders({
         Accept: "text/event-stream"
       });
-      t && (i["last-event-id"] = t);
+      t && (l["last-event-id"] = t);
       const u = await fetch(this.url.href, {
         method: "GET",
-        headers: i,
+        headers: l,
         signal: (n = this.abortController) == null ? void 0 : n.signal
       }), h = u.headers.get("mcp-session-id");
       if (h && (this.sessionId = h), u.status === 401 && this.authProvider && !e) {
-        this.resourceMetadataUrl = Se(u);
+        this.resourceMetadataUrl = Ee(u);
         try {
-          if (await Re(this.authProvider, {
+          if (await Ce(this.authProvider, {
             serverUrl: this.url,
             resourceMetadataUrl: this.resourceMetadataUrl
           }) !== "AUTHORIZED") {
-            const p = new Te();
+            const p = new Re();
             (r = this.onerror) == null || r.call(this, p);
             return;
           }
-        } catch (g) {
-          (o = this.onerror) == null || o.call(this, g);
+        } catch (m) {
+          (o = this.onerror) == null || o.call(this, m);
           return;
         }
         return this.openInboundSse(!0, t);
@@ -1176,79 +1244,79 @@ var Nr = class {
       if (u.status === 405)
         return;
       if (!u.ok || !u.body) {
-        const g = new P({
+        const m = new O({
           message: `MCP HTTP Transport Error: GET SSE failed: ${u.status} ${u.statusText}`
         });
-        (a = this.onerror) == null || a.call(this, g);
+        (a = this.onerror) == null || a.call(this, m);
         return;
       }
-      const m = u.body.pipeThrough(new TextDecoderStream()).pipeThrough(new De()).getReader(), _ = async () => {
-        var g, p, b, y;
+      const f = u.body.pipeThrough(new TextDecoderStream()).pipeThrough(new He()).getReader(), v = async () => {
+        var m, p, w, b;
         try {
           for (; ; ) {
-            const { done: T, value: w } = await m.read();
-            if (T) return;
-            const { event: A, data: x, id: $ } = w;
-            if ($ && (this.lastInboundEventId = $), A === "message")
+            const { done: R, value: T } = await f.read();
+            if (R) return;
+            const { event: S, data: M, id: $ } = T;
+            if ($ && (this.lastInboundEventId = $), S === "message")
               try {
-                const M = ce.parse(JSON.parse(x));
-                (g = this.onmessage) == null || g.call(this, M);
-              } catch (M) {
-                const H = new P({
+                const A = pe.parse(JSON.parse(M));
+                (m = this.onmessage) == null || m.call(this, A);
+              } catch (A) {
+                const I = new O({
                   message: "MCP HTTP Transport Error: Failed to parse message",
-                  cause: M
+                  cause: A
                 });
-                (p = this.onerror) == null || p.call(this, H);
+                (p = this.onerror) == null || p.call(this, I);
               }
           }
-        } catch (T) {
-          if (T instanceof Error && T.name === "AbortError")
+        } catch (R) {
+          if (R instanceof Error && R.name === "AbortError")
             return;
-          (b = this.onerror) == null || b.call(this, T), (y = this.abortController) != null && y.signal.aborted || this.scheduleInboundSseReconnection();
+          (w = this.onerror) == null || w.call(this, R), (b = this.abortController) != null && b.signal.aborted || this.scheduleInboundSseReconnection();
         }
       };
       this.inboundSseConnection = {
-        close: () => m.cancel()
-      }, this.inboundReconnectAttempts = 0, _();
-    } catch (i) {
-      if (i instanceof Error && i.name === "AbortError")
+        close: () => f.cancel()
+      }, this.inboundReconnectAttempts = 0, v();
+    } catch (l) {
+      if (l instanceof Error && l.name === "AbortError")
         return;
-      (l = this.onerror) == null || l.call(this, i), (c = this.abortController) != null && c.signal.aborted || this.scheduleInboundSseReconnection();
+      (i = this.onerror) == null || i.call(this, l), (c = this.abortController) != null && c.signal.aborted || this.scheduleInboundSseReconnection();
     }
   }
 };
-function jr(e) {
+function Jr(e) {
   switch (e.type) {
     case "sse":
-      return new Nr(e);
+      return new Vr(e);
     case "http":
-      return new Dr(e);
+      return new Br(e);
     default:
-      throw new P({
+      throw new O({
         message: "Unsupported or invalid transport configuration. If you are using a custom transport, make sure it implements the MCPTransport interface."
       });
   }
 }
-function qr(e) {
+function zr(e) {
   return "start" in e && typeof e.start == "function" && "send" in e && typeof e.send == "function" && "close" in e && typeof e.close == "function";
 }
-var Hr = "1.0.0";
-async function Lr(e) {
-  const t = new Vr(e);
+var Gr = "1.0.0";
+async function Wr(e) {
+  const t = new Fr(e);
   return await t.init(), t;
 }
-var Vr = class {
+var Fr = class {
   constructor({
     transport: e,
     name: t = "ai-sdk-mcp-client",
-    version: n = Hr,
+    version: n = Gr,
     onUncaughtError: r,
     capabilities: o
   }) {
-    this.requestMessageId = 0, this.responseHandlers = /* @__PURE__ */ new Map(), this.serverCapabilities = {}, this.isClosed = !0, this.onUncaughtError = r, this.clientCapabilities = o ?? {}, qr(e) ? this.transport = e : this.transport = jr(e), this.transport.onclose = () => this.onClose(), this.transport.onerror = (a) => this.onError(a), this.transport.onmessage = (a) => {
+    this.requestMessageId = 0, this.responseHandlers = /* @__PURE__ */ new Map(), this.serverCapabilities = {}, this.isClosed = !0, this.onUncaughtError = r, this.clientCapabilities = o ?? {}, zr(e) ? this.transport = e : this.transport = Jr(e), 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 P({
+          new O({
             message: "Unsupported message type"
           })
         );
@@ -1267,19 +1335,19 @@ var Vr = class {
         request: {
           method: "initialize",
           params: {
-            protocolVersion: ie,
+            protocolVersion: ue,
             capabilities: this.clientCapabilities,
             clientInfo: this.clientInfo
           }
         },
-        resultSchema: Jn
+        resultSchema: Zn
       });
       if (e === void 0)
-        throw new P({
+        throw new O({
           message: "Server sent invalid initialize result"
         });
-      if (!Ln.includes(e.protocolVersion))
-        throw new P({
+      if (!Wn.includes(e.protocolVersion))
+        throw new O({
           message: `Server's protocol version is not supported: ${e.protocolVersion}`
         });
       return this.serverCapabilities = e.capabilities, await this.notification({
@@ -1300,7 +1368,7 @@ var Vr = class {
       case "tools/list":
       case "tools/call":
         if (!this.serverCapabilities.tools)
-          throw new P({
+          throw new O({
             message: "Server does not support tools"
           });
         break;
@@ -1308,19 +1376,19 @@ var Vr = class {
       case "resources/read":
       case "resources/templates/list":
         if (!this.serverCapabilities.resources)
-          throw new P({
+          throw new O({
             message: "Server does not support resources"
           });
         break;
       case "prompts/list":
       case "prompts/get":
         if (!this.serverCapabilities.prompts)
-          throw new P({
+          throw new O({
             message: "Server does not support prompts"
           });
         break;
       default:
-        throw new P({
+        throw new O({
           message: `Unsupported method: ${e}`
         });
     }
@@ -1333,24 +1401,24 @@ var Vr = class {
     return new Promise((r, o) => {
       if (this.isClosed)
         return o(
-          new P({
+          new O({
             message: "Attempted to send a request from a closed client"
           })
         );
       this.assertCapability(e.method);
       const a = n?.signal;
       a?.throwIfAborted();
-      const l = this.requestMessageId++, c = {
+      const i = this.requestMessageId++, c = {
         ...e,
         jsonrpc: "2.0",
-        id: l
-      }, i = () => {
-        this.responseHandlers.delete(l);
+        id: i
+      }, l = () => {
+        this.responseHandlers.delete(i);
       };
-      this.responseHandlers.set(l, (u) => {
+      this.responseHandlers.set(i, (u) => {
         if (a?.aborted)
           return o(
-            new P({
+            new O({
               message: "Request was aborted",
               cause: a.reason
             })
@@ -1361,14 +1429,14 @@ var Vr = class {
           const h = t.parse(u.result);
           r(h);
         } catch (h) {
-          const f = new P({
+          const g = new O({
             message: "Failed to parse server response",
             cause: h
           });
-          o(f);
+          o(g);
         }
       }), this.transport.send(c).catch((u) => {
-        i(), o(u);
+        l(), o(u);
       });
     });
   }
@@ -1379,7 +1447,7 @@ var Vr = class {
     try {
       return this.request({
         request: { method: "tools/list", params: e },
-        resultSchema: Wn,
+        resultSchema: Yn,
         options: t
       });
     } catch (n) {
@@ -1394,7 +1462,7 @@ var Vr = class {
     try {
       return this.request({
         request: { method: "tools/call", params: { name: e, arguments: t } },
-        resultSchema: Kn,
+        resultSchema: tr,
         options: {
           signal: n?.abortSignal
         }
@@ -1410,7 +1478,7 @@ var Vr = class {
     try {
       return this.request({
         request: { method: "resources/list", params: e },
-        resultSchema: Fn,
+        resultSchema: er,
         options: t
       });
     } catch (n) {
@@ -1424,7 +1492,7 @@ var Vr = class {
     try {
       return this.request({
         request: { method: "resources/read", params: { uri: e } },
-        resultSchema: Yn,
+        resultSchema: or,
         options: t
       });
     } catch (n) {
@@ -1437,7 +1505,7 @@ var Vr = class {
     try {
       return this.request({
         request: { method: "resources/templates/list" },
-        resultSchema: Xn,
+        resultSchema: rr,
         options: e
       });
     } catch (t) {
@@ -1451,7 +1519,7 @@ var Vr = class {
     try {
       return this.request({
         request: { method: "prompts/list", params: e },
-        resultSchema: tr,
+        resultSchema: ir,
         options: t
       });
     } catch (n) {
@@ -1466,7 +1534,7 @@ var Vr = class {
     try {
       return this.request({
         request: { method: "prompts/get", params: { name: e, arguments: t } },
-        resultSchema: rr,
+        resultSchema: cr,
         options: n
       });
     } catch (r) {
@@ -1491,25 +1559,25 @@ var Vr = class {
     const n = {};
     try {
       const r = await this.listTools();
-      for (const { name: o, description: a, inputSchema: l } of r.tools) {
+      for (const { name: o, description: a, inputSchema: i } of r.tools) {
         if (e !== "automatic" && !(o in e))
           continue;
-        const c = this, i = async (h, f) => {
-          var m;
-          return (m = f?.abortSignal) == null || m.throwIfAborted(), c.callTool({ name: o, args: h, options: f });
-        }, u = e === "automatic" ? Rn({
+        const c = this, l = async (h, g) => {
+          var f;
+          return (f = g?.abortSignal) == null || f.throwIfAborted(), c.callTool({ name: o, args: h, options: g });
+        }, u = e === "automatic" ? jn({
           description: a,
-          inputSchema: mt({
-            ...l,
-            properties: (t = l.properties) != null ? t : {},
+          inputSchema: Hn({
+            ...i,
+            properties: (t = i.properties) != null ? t : {},
             additionalProperties: !1
           }),
-          execute: i
-        }) : En({
+          execute: l
+        }) : {
           description: a,
           inputSchema: e[o].inputSchema,
-          execute: i
-        });
+          execute: l
+        };
         n[o] = u;
       }
       return n;
@@ -1548,8 +1616,8 @@ var Vr = class {
     return this.getPromptInternal({ name: e, args: t, options: n });
   }
   onElicitationRequest(e, t) {
-    if (e !== rt)
-      throw new P({
+    if (e !== st)
+      throw new O({
         message: "Unsupported request schema. Only ElicitationRequestSchema is supported."
       });
     this.elicitationRequestHandler = t;
@@ -1578,7 +1646,7 @@ var Vr = class {
         });
         return;
       }
-      const t = rt.safeParse({
+      const t = st.safeParse({
         method: e.method,
         params: e.params
       });
@@ -1595,7 +1663,7 @@ var Vr = class {
         return;
       }
       try {
-        const n = await this.elicitationRequestHandler(t.data), r = sr.parse(n);
+        const n = await this.elicitationRequestHandler(t.data), r = dr.parse(n);
         await this.transport.send({
           jsonrpc: "2.0",
           id: e.id,
@@ -1618,7 +1686,7 @@ var Vr = class {
   onClose() {
     if (this.isClosed) return;
     this.isClosed = !0;
-    const e = new P({
+    const e = new O({
       message: "Connection closed"
     });
     for (const t of this.responseHandlers.values())
@@ -1631,13 +1699,13 @@ var Vr = class {
   onResponse(e) {
     const t = Number(e.id), n = this.responseHandlers.get(t);
     if (n === void 0)
-      throw new P({
+      throw new O({
         message: `Protocol error: Received a response for an unknown message ID: ${JSON.stringify(
           e
         )}`
       });
     this.responseHandlers.delete(t), n(
-      "result" in e ? e : new P({
+      "result" in e ? e : new O({
         message: e.error.message,
         code: e.error.code,
         data: e.error.data,
@@ -1645,14 +1713,14 @@ var Vr = class {
       })
     );
   }
-}, Br = Object.defineProperty, Jr = Object.defineProperties, zr = Object.getOwnPropertyDescriptors, it = Object.getOwnPropertySymbols, Wr = Object.prototype.hasOwnProperty, Gr = Object.prototype.propertyIsEnumerable, lt = (e, t, n) => t in e ? Br(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n, O = (e, t) => {
+}, Kr = Object.defineProperty, Zr = Object.defineProperties, Xr = Object.getOwnPropertyDescriptors, ct = Object.getOwnPropertySymbols, Yr = Object.prototype.hasOwnProperty, Qr = Object.prototype.propertyIsEnumerable, ut = (e, t, n) => t in e ? Kr(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n, P = (e, t) => {
   for (var n in t || (t = {}))
-    Wr.call(t, n) && lt(e, n, t[n]);
-  if (it)
-    for (var n of it(t))
-      Gr.call(t, n) && lt(e, n, t[n]);
+    Yr.call(t, n) && ut(e, n, t[n]);
+  if (ct)
+    for (var n of ct(t))
+      Qr.call(t, n) && ut(e, n, t[n]);
   return e;
-}, Ee = (e, t) => Jr(e, zr(t)), $t = "vercel.ai.error", Fr = Symbol.for($t), Mt, Kr = class Nt extends Error {
+}, xe = (e, t) => Zr(e, Xr(t)), Ut = "vercel.ai.error", eo = Symbol.for(Ut), Mt, to = class Nt extends Error {
   /**
    * Creates an AI SDK Error.
    *
@@ -1674,15 +1742,15 @@ var Vr = class {
    * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
    */
   static isInstance(t) {
-    return Nt.hasMarker(t, $t);
+    return Nt.hasMarker(t, Ut);
   }
   static hasMarker(t, n) {
     const r = Symbol.for(n);
     return t != null && typeof t == "object" && r in t && typeof t[r] == "boolean" && t[r] === !0;
   }
 };
-Mt = Fr;
-var q = Kr, Dt = "AI_APICallError", jt = `vercel.ai.error.${Dt}`, Zr = Symbol.for(jt), qt, K = class extends q {
+Mt = eo;
+var L = to, jt = "AI_APICallError", Dt = `vercel.ai.error.${jt}`, no = Symbol.for(Dt), Ht, F = class extends L {
   constructor({
     message: e,
     url: t,
@@ -1690,48 +1758,48 @@ var q = Kr, Dt = "AI_APICallError", jt = `vercel.ai.error.${Dt}`, Zr = Symbol.fo
     statusCode: r,
     responseHeaders: o,
     responseBody: a,
-    cause: l,
+    cause: i,
     isRetryable: c = r != null && (r === 408 || // request timeout
     r === 409 || // conflict
     r === 429 || // too many requests
     r >= 500),
     // server error
-    data: i
+    data: l
   }) {
-    super({ name: Dt, message: e, cause: l }), this[qt] = !0, this.url = t, this.requestBodyValues = n, this.statusCode = r, this.responseHeaders = o, this.responseBody = a, this.isRetryable = c, this.data = i;
+    super({ name: jt, message: e, cause: i }), this[Ht] = !0, this.url = t, this.requestBodyValues = n, this.statusCode = r, this.responseHeaders = o, this.responseBody = a, this.isRetryable = c, this.data = l;
   }
   static isInstance(e) {
-    return q.hasMarker(e, jt);
+    return L.hasMarker(e, Dt);
   }
 };
-qt = Zr;
-var Ht = "AI_EmptyResponseBodyError", Lt = `vercel.ai.error.${Ht}`, Xr = Symbol.for(Lt), Vt, Yr = class extends q {
+Ht = no;
+var Lt = "AI_EmptyResponseBodyError", qt = `vercel.ai.error.${Lt}`, ro = Symbol.for(qt), Vt, oo = class extends L {
   // used in isInstance
   constructor({ message: e = "Empty response body" } = {}) {
-    super({ name: Ht, message: e }), this[Vt] = !0;
+    super({ name: Lt, message: e }), this[Vt] = !0;
   }
   static isInstance(e) {
-    return q.hasMarker(e, Lt);
+    return L.hasMarker(e, qt);
   }
 };
-Vt = Xr;
+Vt = ro;
 function Bt(e) {
   return e == null ? "unknown error" : typeof e == "string" ? e : e instanceof Error ? e.message : JSON.stringify(e);
 }
-var Jt = "AI_InvalidArgumentError", zt = `vercel.ai.error.${Jt}`, Qr = Symbol.for(zt), Wt, Gt = class extends q {
+var Jt = "AI_InvalidArgumentError", zt = `vercel.ai.error.${Jt}`, so = Symbol.for(zt), Gt, Wt = class extends L {
   constructor({
     message: e,
     cause: t,
     argument: n
   }) {
-    super({ name: Jt, message: e, cause: t }), this[Wt] = !0, this.argument = n;
+    super({ name: Jt, message: e, cause: t }), this[Gt] = !0, this.argument = n;
   }
   static isInstance(e) {
-    return q.hasMarker(e, zt);
+    return L.hasMarker(e, zt);
   }
 };
-Wt = Qr;
-var Ft = "AI_InvalidPromptError", Kt = `vercel.ai.error.${Ft}`, eo = Symbol.for(Kt), Zt, to = class extends q {
+Gt = so;
+var Ft = "AI_InvalidPromptError", Kt = `vercel.ai.error.${Ft}`, ao = Symbol.for(Kt), Zt, io = class extends L {
   constructor({
     prompt: e,
     message: t,
@@ -1740,11 +1808,11 @@ var Ft = "AI_InvalidPromptError", Kt = `vercel.ai.error.${Ft}`, eo = Symbol.for(
     super({ name: Ft, message: `Invalid prompt: ${t}`, cause: n }), this[Zt] = !0, this.prompt = e;
   }
   static isInstance(e) {
-    return q.hasMarker(e, Kt);
+    return L.hasMarker(e, Kt);
   }
 };
-Zt = eo;
-var Xt = "AI_InvalidResponseDataError", Yt = `vercel.ai.error.${Xt}`, no = Symbol.for(Yt), Qt, le = class extends q {
+Zt = ao;
+var Xt = "AI_InvalidResponseDataError", Yt = `vercel.ai.error.${Xt}`, lo = Symbol.for(Yt), Qt, de = class extends L {
   constructor({
     data: e,
     message: t = `Invalid response data: ${JSON.stringify(e)}.`
@@ -1752,11 +1820,11 @@ var Xt = "AI_InvalidResponseDataError", Yt = `vercel.ai.error.${Xt}`, no = Symbo
     super({ name: Xt, message: t }), this[Qt] = !0, this.data = e;
   }
   static isInstance(e) {
-    return q.hasMarker(e, Yt);
+    return L.hasMarker(e, Yt);
   }
 };
-Qt = no;
-var en = "AI_JSONParseError", tn = `vercel.ai.error.${en}`, ro = Symbol.for(tn), nn, Ce = class extends q {
+Qt = lo;
+var en = "AI_JSONParseError", tn = `vercel.ai.error.${en}`, co = Symbol.for(tn), nn, Ie = class extends L {
   constructor({ text: e, cause: t }) {
     super({
       name: en,
@@ -1766,21 +1834,21 @@ Error message: ${Bt(t)}`,
     }), this[nn] = !0, this.text = e;
   }
   static isInstance(e) {
-    return q.hasMarker(e, tn);
+    return L.hasMarker(e, tn);
   }
 };
-nn = ro;
-var rn = "AI_LoadAPIKeyError", on = `vercel.ai.error.${rn}`, oo = Symbol.for(on), sn, _e = class extends q {
+nn = co;
+var rn = "AI_LoadAPIKeyError", on = `vercel.ai.error.${rn}`, uo = Symbol.for(on), sn, ye = class extends L {
   // used in isInstance
   constructor({ message: e }) {
     super({ name: rn, message: e }), this[sn] = !0;
   }
   static isInstance(e) {
-    return q.hasMarker(e, on);
+    return L.hasMarker(e, on);
   }
 };
-sn = oo;
-var an = "AI_NoContentGeneratedError", ln = `vercel.ai.error.${an}`, so = Symbol.for(ln), cn, un = class extends q {
+sn = uo;
+var an = "AI_NoContentGeneratedError", ln = `vercel.ai.error.${an}`, po = Symbol.for(ln), cn, un = class extends L {
   // used in isInstance
   constructor({
     message: e = "No content generated."
@@ -1788,11 +1856,11 @@ var an = "AI_NoContentGeneratedError", ln = `vercel.ai.error.${an}`, so = Symbol
     super({ name: an, message: e }), this[cn] = !0;
   }
   static isInstance(e) {
-    return q.hasMarker(e, ln);
+    return L.hasMarker(e, ln);
   }
 };
-cn = so;
-var dn = "AI_TypeValidationError", pn = `vercel.ai.error.${dn}`, ao = Symbol.for(pn), hn, io = class je extends q {
+cn = po;
+var dn = "AI_TypeValidationError", pn = `vercel.ai.error.${dn}`, ho = Symbol.for(pn), hn, mo = class Le extends L {
   constructor({ value: t, cause: n }) {
     super({
       name: dn,
@@ -1802,7 +1870,7 @@ Error message: ${Bt(n)}`,
     }), this[hn] = !0, this.value = t;
   }
   static isInstance(t) {
-    return q.hasMarker(t, pn);
+    return L.hasMarker(t, pn);
   }
   /**
    * Wraps an error into a TypeValidationError.
@@ -1818,129 +1886,129 @@ Error message: ${Bt(n)}`,
     value: t,
     cause: n
   }) {
-    return je.isInstance(n) && n.value === t ? n : new je({ value: t, cause: n });
+    return Le.isInstance(n) && n.value === t ? n : new Le({ value: t, cause: n });
   }
 };
-hn = ao;
-var ue = io, mn = "AI_UnsupportedFunctionalityError", gn = `vercel.ai.error.${mn}`, lo = Symbol.for(gn), fn, ee = class extends q {
+hn = ho;
+var he = mo, mn = "AI_UnsupportedFunctionalityError", fn = `vercel.ai.error.${mn}`, fo = Symbol.for(fn), gn, te = class extends L {
   constructor({
     functionality: e,
     message: t = `'${e}' functionality not supported.`
   }) {
-    super({ name: mn, message: t }), this[fn] = !0, this.functionality = e;
+    super({ name: mn, message: t }), this[gn] = !0, this.functionality = e;
   }
   static isInstance(e) {
-    return q.hasMarker(e, gn);
+    return L.hasMarker(e, fn);
   }
 };
-fn = lo;
-var ct = class extends Error {
+gn = fo;
+var dt = class extends Error {
   constructor(e, t) {
     super(e), this.name = "ParseError", this.type = t.type, this.field = t.field, this.value = t.value, this.line = t.line;
   }
 };
-function $e(e) {
+function Ne(e) {
 }
-function co(e) {
+function go(e) {
   if (typeof e == "function")
     throw new TypeError(
       "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
     );
-  const { onEvent: t = $e, onError: n = $e, onRetry: r = $e, onComment: o } = e;
-  let a = "", l = !0, c, i = "", u = "";
+  const { onEvent: t = Ne, onError: n = Ne, onRetry: r = Ne, onComment: o } = e;
+  let a = "", i = !0, c, l = "", u = "";
   function h(p) {
-    const b = l ? p.replace(/^\xEF\xBB\xBF/, "") : p, [y, T] = uo(`${a}${b}`);
-    for (const w of y)
-      f(w);
-    a = T, l = !1;
+    const w = i ? p.replace(/^\xEF\xBB\xBF/, "") : p, [b, R] = _o(`${a}${w}`);
+    for (const T of b)
+      g(T);
+    a = R, i = !1;
   }
-  function f(p) {
+  function g(p) {
     if (p === "") {
-      _();
+      v();
       return;
     }
     if (p.startsWith(":")) {
       o && o(p.slice(p.startsWith(": ") ? 2 : 1));
       return;
     }
-    const b = p.indexOf(":");
-    if (b !== -1) {
-      const y = p.slice(0, b), T = p[b + 1] === " " ? 2 : 1, w = p.slice(b + T);
-      m(y, w, p);
+    const w = p.indexOf(":");
+    if (w !== -1) {
+      const b = p.slice(0, w), R = p[w + 1] === " " ? 2 : 1, T = p.slice(w + R);
+      f(b, T, p);
       return;
     }
-    m(p, "", p);
+    f(p, "", p);
   }
-  function m(p, b, y) {
+  function f(p, w, b) {
     switch (p) {
       case "event":
-        u = b;
+        u = w;
         break;
       case "data":
-        i = `${i}${b}
+        l = `${l}${w}
 `;
         break;
       case "id":
-        c = b.includes("\0") ? void 0 : b;
+        c = w.includes("\0") ? void 0 : w;
         break;
       case "retry":
-        /^\d+$/.test(b) ? r(parseInt(b, 10)) : n(
-          new ct(`Invalid \`retry\` value: "${b}"`, {
+        /^\d+$/.test(w) ? r(parseInt(w, 10)) : n(
+          new dt(`Invalid \`retry\` value: "${w}"`, {
             type: "invalid-retry",
-            value: b,
-            line: y
+            value: w,
+            line: b
           })
         );
         break;
       default:
         n(
-          new ct(
+          new dt(
             `Unknown field "${p.length > 20 ? `${p.slice(0, 20)}…` : p}"`,
-            { type: "unknown-field", field: p, value: b, line: y }
+            { type: "unknown-field", field: p, value: w, line: b }
           )
         );
         break;
     }
   }
-  function _() {
-    i.length > 0 && t({
+  function v() {
+    l.length > 0 && t({
       id: c,
       event: u || 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: i.endsWith(`
-`) ? i.slice(0, -1) : i
-    }), c = void 0, i = "", u = "";
+      data: l.endsWith(`
+`) ? l.slice(0, -1) : l
+    }), c = void 0, l = "", u = "";
   }
-  function g(p = {}) {
-    a && p.consume && f(a), l = !0, c = void 0, i = "", u = "", a = "";
+  function m(p = {}) {
+    a && p.consume && g(a), i = !0, c = void 0, l = "", u = "", a = "";
   }
-  return { feed: h, reset: g };
+  return { feed: h, reset: m };
 }
-function uo(e) {
+function _o(e) {
   const t = [];
   let n = "", r = 0;
   for (; r < e.length; ) {
     const o = e.indexOf("\r", r), a = e.indexOf(`
 `, r);
-    let l = -1;
-    if (o !== -1 && a !== -1 ? l = Math.min(o, a) : o !== -1 ? l = o : a !== -1 && (l = a), l === -1) {
+    let i = -1;
+    if (o !== -1 && a !== -1 ? i = Math.min(o, a) : o !== -1 ? i = o : a !== -1 && (i = a), i === -1) {
       n = e.slice(r);
       break;
     } else {
-      const c = e.slice(r, l);
-      t.push(c), r = l + 1, e[r - 1] === "\r" && e[r] === `
+      const c = e.slice(r, i);
+      t.push(c), r = i + 1, e[r - 1] === "\r" && e[r] === `
 ` && r++;
     }
   }
   return [t, n];
 }
-var po = class extends TransformStream {
+var vo = class extends TransformStream {
   constructor({ onError: e, onRetry: t, onComment: n } = {}) {
     let r;
     super({
       start(o) {
-        r = co({
+        r = go({
           onEvent: (a) => {
             o.enqueue(a);
           },
@@ -1958,52 +2026,52 @@ var po = class extends TransformStream {
   }
 };
 new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
-function de(...e) {
+function me(...e) {
   return e.reduce(
-    (t, n) => O(O({}, t), n ?? {}),
+    (t, n) => P(P({}, t), n ?? {}),
     {}
   );
 }
-function Oe(e) {
+function $e(e) {
   return Object.fromEntries([...e.headers]);
 }
-var ho = ({
+var yo = ({
   prefix: e,
   size: t = 16,
   alphabet: n = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
   separator: r = "-"
 } = {}) => {
   const o = () => {
-    const a = n.length, l = new Array(t);
+    const a = n.length, i = new Array(t);
     for (let c = 0; c < t; c++)
-      l[c] = n[Math.random() * a | 0];
-    return l.join("");
+      i[c] = n[Math.random() * a | 0];
+    return i.join("");
   };
   if (e == null)
     return o;
   if (n.includes(r))
-    throw new Gt({
+    throw new Wt({
       argument: "separator",
       message: `The separator "${r}" must not be part of the alphabet "${n}".`
     });
   return () => `${e}${r}${o()}`;
-}, F = ho();
+}, W = yo();
 function qe(e) {
   return (e instanceof Error || e instanceof DOMException) && (e.name === "AbortError" || e.name === "ResponseAborted" || // Next.js
   e.name === "TimeoutError");
 }
-var mo = ["fetch failed", "failed to fetch"];
-function go({
+var wo = ["fetch failed", "failed to fetch"];
+function bo({
   error: e,
   url: t,
   requestBodyValues: n
 }) {
   if (qe(e))
     return e;
-  if (e instanceof TypeError && mo.includes(e.message.toLowerCase())) {
+  if (e instanceof TypeError && wo.includes(e.message.toLowerCase())) {
     const r = e.cause;
     if (r != null)
-      return new K({
+      return new F({
         message: `Cannot connect to API: ${r.message}`,
         cause: r,
         url: t,
@@ -2014,12 +2082,12 @@ function go({
   }
   return e;
 }
-function fo(e) {
+function ko(e) {
   return Object.fromEntries(
     Object.entries(e).filter(([t, n]) => n != null)
   );
 }
-function _o({
+function To({
   apiKey: e,
   environmentVariableName: t,
   apiKeyParameterName: n = "apiKey",
@@ -2028,29 +2096,29 @@ function _o({
   if (typeof e == "string")
     return e;
   if (e != null)
-    throw new _e({
+    throw new ye({
       message: `${r} API key must be a string.`
     });
   if (typeof process > "u")
-    throw new _e({
+    throw new ye({
       message: `${r} API key is missing. Pass it using the '${n}' parameter. Environment variables is not supported in this environment.`
     });
   if (e = process.env[t], e == null)
-    throw new _e({
+    throw new ye({
       message: `${r} API key is missing. Pass it using the '${n}' parameter or the ${t} environment variable.`
     });
   if (typeof e != "string")
-    throw new _e({
+    throw new ye({
       message: `${r} API key must be a string. The value of the ${t} environment variable is not a string.`
     });
   return e;
 }
-var vo = /"__proto__"\s*:/, yo = /"constructor"\s*:/;
-function wo(e) {
+var So = /"__proto__"\s*:/, Ro = /"constructor"\s*:/;
+function Eo(e) {
   const t = JSON.parse(e);
-  return t === null || typeof t != "object" || vo.test(e) === !1 && yo.test(e) === !1 ? t : bo(t);
+  return t === null || typeof t != "object" || So.test(e) === !1 && Ro.test(e) === !1 ? t : Co(t);
 }
-function bo(e) {
+function Co(e) {
   let t = [e];
   for (; t.length; ) {
     const n = t;
@@ -2068,77 +2136,77 @@ function bo(e) {
   }
   return e;
 }
-function Ke(e) {
+function Xe(e) {
   const { stackTraceLimit: t } = Error;
   Error.stackTraceLimit = 0;
   try {
-    return wo(e);
+    return Eo(e);
   } finally {
     Error.stackTraceLimit = t;
   }
 }
-var He = Symbol.for("vercel.ai.validator");
-function ko(e) {
-  return { [He]: !0, validate: e };
+var Ve = Symbol.for("vercel.ai.validator");
+function xo(e) {
+  return { [Ve]: !0, validate: e };
 }
-function To(e) {
-  return typeof e == "object" && e !== null && He in e && e[He] === !0 && "validate" in e;
+function Io(e) {
+  return typeof e == "object" && e !== null && Ve in e && e[Ve] === !0 && "validate" in e;
 }
-function So(e) {
-  return To(e) ? e : Ro(e);
+function Oo(e) {
+  return Io(e) ? e : Po(e);
 }
-function Ro(e) {
-  return ko(async (t) => {
+function Po(e) {
+  return xo(async (t) => {
     const n = await e["~standard"].validate(t);
     return n.issues == null ? { success: !0, value: n.value } : {
       success: !1,
-      error: new ue({
+      error: new he({
         value: t,
         cause: n.issues
       })
     };
   });
 }
-async function Eo({
+async function Ao({
   value: e,
   schema: t
 }) {
   const n = await _n({ value: e, schema: t });
   if (!n.success)
-    throw ue.wrap({ value: e, cause: n.error });
+    throw he.wrap({ value: e, cause: n.error });
   return n.value;
 }
 async function _n({
   value: e,
   schema: t
 }) {
-  const n = So(t);
+  const n = Oo(t);
   try {
     if (n.validate == null)
       return { success: !0, value: e, rawValue: e };
     const r = await n.validate(e);
     return r.success ? { success: !0, value: r.value, rawValue: e } : {
       success: !1,
-      error: ue.wrap({ value: e, cause: r.error }),
+      error: he.wrap({ value: e, cause: r.error }),
       rawValue: e
     };
   } catch (r) {
     return {
       success: !1,
-      error: ue.wrap({ value: e, cause: r }),
+      error: he.wrap({ value: e, cause: r }),
       rawValue: e
     };
   }
 }
-async function Co({
+async function $o({
   text: e,
   schema: t
 }) {
   try {
-    const n = Ke(e);
-    return t == null ? n : Eo({ value: n, schema: t });
+    const n = Xe(e);
+    return t == null ? n : Ao({ value: n, schema: t });
   } catch (n) {
-    throw Ce.isInstance(n) || ue.isInstance(n) ? n : new Ce({ text: e, cause: n });
+    throw Ie.isInstance(n) || he.isInstance(n) ? n : new Ie({ text: e, cause: n });
   }
 }
 async function vn({
@@ -2146,28 +2214,28 @@ async function vn({
   schema: t
 }) {
   try {
-    const n = Ke(e);
+    const n = Xe(e);
     return t == null ? { success: !0, value: n, rawValue: n } : await _n({ value: n, schema: t });
   } catch (n) {
     return {
       success: !1,
-      error: Ce.isInstance(n) ? n : new Ce({ text: e, cause: n }),
+      error: Ie.isInstance(n) ? n : new Ie({ text: e, cause: n }),
       rawValue: void 0
     };
   }
 }
-function Me(e) {
+function je(e) {
   try {
-    return Ke(e), !0;
+    return Xe(e), !0;
   } catch {
     return !1;
   }
 }
-function xo({
+function Uo({
   stream: e,
   schema: t
 }) {
-  return e.pipeThrough(new TextDecoderStream()).pipeThrough(new po()).pipeThrough(
+  return e.pipeThrough(new TextDecoderStream()).pipeThrough(new vo()).pipeThrough(
     new TransformStream({
       async transform({ data: n }, r) {
         n !== "[DONE]" && r.enqueue(await vn({ text: n, schema: t }));
@@ -2175,17 +2243,17 @@ function xo({
     })
   );
 }
-var Io = () => globalThis.fetch, pe = async ({
+var Mo = () => globalThis.fetch, fe = async ({
   url: e,
   headers: t,
   body: n,
   failedResponseHandler: r,
   successfulResponseHandler: o,
   abortSignal: a,
-  fetch: l
-}) => Po({
+  fetch: i
+}) => No({
   url: e,
-  headers: O({
+  headers: P({
     "Content-Type": "application/json"
   }, t),
   body: {
@@ -2195,23 +2263,23 @@ var Io = () => globalThis.fetch, pe = async ({
   failedResponseHandler: r,
   successfulResponseHandler: o,
   abortSignal: a,
-  fetch: l
-}), Po = async ({
+  fetch: i
+}), No = async ({
   url: e,
   headers: t = {},
   body: n,
   successfulResponseHandler: r,
   failedResponseHandler: o,
   abortSignal: a,
-  fetch: l = Io()
+  fetch: i = Mo()
 }) => {
   try {
-    const c = await l(e, {
+    const c = await i(e, {
       method: "POST",
-      headers: fo(t),
+      headers: ko(t),
       body: n.content,
       signal: a
-    }), i = Oe(c);
+    }), l = $e(c);
     if (!c.ok) {
       let u;
       try {
@@ -2221,12 +2289,12 @@ var Io = () => globalThis.fetch, pe = async ({
           requestBodyValues: n.values
         });
       } catch (h) {
-        throw qe(h) || K.isInstance(h) ? h : new K({
+        throw qe(h) || F.isInstance(h) ? h : new F({
           message: "Failed to process error response",
           cause: h,
           statusCode: c.status,
           url: e,
-          responseHeaders: i,
+          responseHeaders: l,
           requestBodyValues: n.values
         });
       }
@@ -2239,212 +2307,212 @@ var Io = () => globalThis.fetch, pe = async ({
         requestBodyValues: n.values
       });
     } catch (u) {
-      throw u instanceof Error && (qe(u) || K.isInstance(u)) ? u : new K({
+      throw u instanceof Error && (qe(u) || F.isInstance(u)) ? u : new F({
         message: "Failed to process successful response",
         cause: u,
         statusCode: c.status,
         url: e,
-        responseHeaders: i,
+        responseHeaders: l,
         requestBodyValues: n.values
       });
     }
   } catch (c) {
-    throw go({ error: c, url: e, requestBodyValues: n.values });
+    throw bo({ error: c, url: e, requestBodyValues: n.values });
   }
-}, Oo = ({
+}, jo = ({
   errorSchema: e,
   errorToMessage: t,
   isRetryable: n
 }) => async ({ response: r, url: o, requestBodyValues: a }) => {
-  const l = await r.text(), c = Oe(r);
-  if (l.trim() === "")
+  const i = await r.text(), c = $e(r);
+  if (i.trim() === "")
     return {
       responseHeaders: c,
-      value: new K({
+      value: new F({
         message: r.statusText,
         url: o,
         requestBodyValues: a,
         statusCode: r.status,
         responseHeaders: c,
-        responseBody: l,
+        responseBody: i,
         isRetryable: n?.(r)
       })
     };
   try {
-    const i = await Co({
-      text: l,
+    const l = await $o({
+      text: i,
       schema: e
     });
     return {
       responseHeaders: c,
-      value: new K({
-        message: t(i),
+      value: new F({
+        message: t(l),
         url: o,
         requestBodyValues: a,
         statusCode: r.status,
         responseHeaders: c,
-        responseBody: l,
-        data: i,
-        isRetryable: n?.(r, i)
+        responseBody: i,
+        data: l,
+        isRetryable: n?.(r, l)
       })
     };
   } catch {
     return {
       responseHeaders: c,
-      value: new K({
+      value: new F({
         message: r.statusText,
         url: o,
         requestBodyValues: a,
         statusCode: r.status,
         responseHeaders: c,
-        responseBody: l,
+        responseBody: i,
         isRetryable: n?.(r)
       })
     };
   }
 }, yn = (e) => async ({ response: t }) => {
-  const n = Oe(t);
+  const n = $e(t);
   if (t.body == null)
-    throw new Yr({});
+    throw new oo({});
   return {
     responseHeaders: n,
-    value: xo({
+    value: Uo({
       stream: t.body,
       schema: e
     })
   };
-}, Ze = (e) => async ({ response: t, url: n, requestBodyValues: r }) => {
+}, Ye = (e) => async ({ response: t, url: n, requestBodyValues: r }) => {
   const o = await t.text(), a = await vn({
     text: o,
     schema: e
-  }), l = Oe(t);
+  }), i = $e(t);
   if (!a.success)
-    throw new K({
+    throw new F({
       message: "Invalid JSON response",
       cause: a.error,
       statusCode: t.status,
-      responseHeaders: l,
+      responseHeaders: i,
       responseBody: o,
       url: n,
       requestBodyValues: r
     });
   return {
-    responseHeaders: l,
+    responseHeaders: i,
     value: a.value,
     rawValue: a.rawValue
   };
-}, { btoa: Ao } = globalThis;
-function Uo(e) {
+}, { btoa: Do } = globalThis;
+function Ho(e) {
   let t = "";
   for (let n = 0; n < e.length; n++)
     t += String.fromCodePoint(e[n]);
-  return Ao(t);
+  return Do(t);
 }
-function $o(e) {
+function Lo(e) {
   return e?.replace(/\/$/, "");
 }
-function Ne(e) {
+function De(e) {
   return e != null;
 }
-var wn = /* @__PURE__ */ ((e) => (e.Unknown = "unknown", e.OpenAIResponsesV1 = "openai-responses-v1", e.XAIResponsesV1 = "xai-responses-v1", e.AnthropicClaudeV1 = "anthropic-claude-v1", e.GoogleGeminiV1 = "google-gemini-v1", e))(wn || {}), Xe = d({
+var wn = /* @__PURE__ */ ((e) => (e.Unknown = "unknown", e.OpenAIResponsesV1 = "openai-responses-v1", e.XAIResponsesV1 = "xai-responses-v1", e.AnthropicClaudeV1 = "anthropic-claude-v1", e.GoogleGeminiV1 = "google-gemini-v1", e))(wn || {}), Qe = d({
   id: s().nullish(),
-  format: Je(wn).nullish(),
+  format: Ge(wn).nullish(),
   index: k().optional()
-}).loose(), Mo = d({
-  type: E(
+}).loose(), qo = d({
+  type: x(
     "reasoning.summary"
     /* Summary */
   ),
   summary: s()
-}).extend(Xe.shape), No = d({
-  type: E(
+}).extend(Qe.shape), Vo = d({
+  type: x(
     "reasoning.encrypted"
     /* Encrypted */
   ),
   data: s()
-}).extend(Xe.shape), Do = d({
-  type: E(
+}).extend(Qe.shape), Bo = d({
+  type: x(
     "reasoning.text"
     /* Text */
   ),
   text: s().nullish(),
   signature: s().nullish()
-}).extend(Xe.shape), Ye = D([
-  Mo,
-  No,
-  Do
-]), ve = D([
-  Ye,
-  ne().transform(() => null)
-]), Qe = v(ve).transform((e) => e.filter((t) => !!t));
-D([
+}).extend(Qe.shape), et = j([
+  qo,
+  Vo,
+  Bo
+]), we = j([
+  et,
+  oe().transform(() => null)
+]), tt = y(we).transform((e) => e.filter((t) => !!t));
+j([
   d({
     delta: d({
-      reasoning_details: v(ve)
+      reasoning_details: y(we)
     })
   }).transform(
-    (e) => e.delta.reasoning_details.filter(Ne)
+    (e) => e.delta.reasoning_details.filter(De)
   ),
   d({
     message: d({
-      reasoning_details: v(ve)
+      reasoning_details: y(we)
     })
   }).transform(
-    (e) => e.message.reasoning_details.filter(Ne)
+    (e) => e.message.reasoning_details.filter(De)
   ),
   d({
     text: s(),
-    reasoning_details: v(ve)
-  }).transform((e) => e.reasoning_details.filter(Ne))
+    reasoning_details: y(we)
+  }).transform((e) => e.reasoning_details.filter(De))
 ]);
-var Ae = d({
+var Ue = d({
   error: d({
-    code: D([s(), k()]).nullable().optional().default(null),
+    code: j([s(), k()]).nullable().optional().default(null),
     message: s(),
     type: s().nullable().optional().default(null),
-    param: vt().nullable().optional().default(null)
+    param: K().nullable().optional().default(null)
   }).passthrough()
-}).passthrough(), he = Oo({
-  errorSchema: Ae,
+}).passthrough(), ge = jo({
+  errorSchema: Ue,
   errorToMessage: (e) => e.error.message
 }), bn = d({
-  type: E("file"),
+  type: x("file"),
   file: d({
     hash: s(),
     name: s(),
-    content: v(
+    content: y(
       d({
         type: s(),
         text: s().optional()
-      }).passthrough()
+      }).catchall(K())
     ).optional()
-  }).passthrough()
-}), jo = d({
+  }).catchall(K())
+}).catchall(K()), Jo = d({
   provider: s(),
-  reasoning_details: v(Ye).optional(),
-  annotations: v(bn).optional(),
+  reasoning_details: y(et).optional(),
+  annotations: y(bn).optional(),
   usage: d({
     promptTokens: k(),
     promptTokensDetails: d({
       cachedTokens: k()
-    }).passthrough().optional(),
+    }).catchall(K()).optional(),
     completionTokens: k(),
     completionTokensDetails: d({
       reasoningTokens: k()
-    }).passthrough().optional(),
+    }).catchall(K()).optional(),
     totalTokens: k(),
     cost: k().optional(),
     costDetails: d({
       upstreamInferenceCost: k()
-    }).passthrough().optional()
-  }).passthrough()
-}).passthrough(), ut = d({
+    }).catchall(K()).optional()
+  }).catchall(K())
+}).catchall(K()), pt = d({
   openrouter: d({
-    reasoning_details: v(Ye).optional(),
-    annotations: v(bn).optional()
+    reasoning_details: y(et).optional(),
+    annotations: y(bn).optional()
   }).optional()
 }).optional();
-function xe(e) {
+function Oe(e) {
   switch (e) {
     case "stop":
       return "stop";
@@ -2459,7 +2527,18 @@ function xe(e) {
       return "unknown";
   }
 }
-function et({
+var zo = [
+  "wav",
+  "mp3",
+  "aiff",
+  "aac",
+  "ogg",
+  "flac",
+  "m4a",
+  "pcm16",
+  "pcm24"
+];
+function nt({
   url: e,
   protocols: t
 }) {
@@ -2470,36 +2549,64 @@ function et({
     return !1;
   }
 }
-function Le({
+function Be({
   part: e,
   defaultMediaType: t
 }) {
   var n, r;
   if (e.data instanceof Uint8Array) {
-    const a = Uo(e.data);
+    const a = Ho(e.data);
     return `data:${(n = e.mediaType) != null ? n : t};base64,${a}`;
   }
   const o = e.data.toString();
-  return et({
+  return nt({
     url: o,
     protocols: /* @__PURE__ */ new Set(["http:", "https:"])
   }) || o.startsWith("data:") ? o : `data:${(r = e.mediaType) != null ? r : t};base64,${o}`;
 }
-function dt(e, t) {
+function ht(e, t) {
   var n;
   const r = e.match(/^data:([^;]+)/);
   return r && (n = r[1]) != null ? n : t;
 }
-function Ve(e) {
+function Je(e) {
   const t = e.match(/^data:[^;]*;base64,(.+)$/);
   return t ? t[1] : e;
 }
-function qo(e) {
-  const t = Le({
+var Go = {
+  // MP3 variants
+  mpeg: "mp3",
+  mp3: "mp3",
+  // WAV variants
+  "x-wav": "wav",
+  wave: "wav",
+  wav: "wav",
+  // OGG variants
+  ogg: "ogg",
+  vorbis: "ogg",
+  // AAC variants
+  aac: "aac",
+  "x-aac": "aac",
+  // M4A variants
+  m4a: "m4a",
+  "x-m4a": "m4a",
+  mp4: "m4a",
+  // AIFF variants
+  aiff: "aiff",
+  "x-aiff": "aiff",
+  // FLAC
+  flac: "flac",
+  "x-flac": "flac",
+  // PCM variants
+  pcm16: "pcm16",
+  pcm24: "pcm24"
+};
+function Wo(e) {
+  const t = Be({
     part: e,
     defaultMediaType: "audio/mpeg"
   });
-  if (et({
+  if (nt({
     url: t,
     protocols: /* @__PURE__ */ new Set(["http:", "https:"])
   }))
@@ -2515,197 +2622,196 @@ The AI SDK will automatically handle base64 encoding.
 
 Learn more: https://openrouter.ai/docs/features/multimodal/audio`
     );
-  const n = Ve(t), r = e.mediaType || "audio/mpeg";
-  let o = r.replace("audio/", "");
-  if (o === "mpeg" || o === "mp3" ? o = "mp3" : (o === "x-wav" || o === "wave" || o === "wav") && (o = "wav"), o !== "mp3" && o !== "wav")
+  const n = Je(t), r = e.mediaType || "audio/mpeg", o = r.replace("audio/", ""), a = Go[o];
+  if (a === void 0) {
+    const i = zo.join(", ");
     throw new Error(
       `Unsupported audio format: "${r}"
 
-OpenRouter only supports MP3 and WAV audio formats.
-• For MP3: use "audio/mpeg" or "audio/mp3"
-• For WAV: use "audio/wav" or "audio/x-wav"
+OpenRouter supports the following audio formats: ${i}
 
 Learn more: https://openrouter.ai/docs/features/multimodal/audio`
     );
-  return { data: n, format: o };
+  }
+  return { data: n, format: a };
 }
-function Q(e) {
+function ee(e) {
   var t, n, r;
   const o = e?.anthropic, a = e?.openrouter;
   return (r = (n = (t = a?.cacheControl) != null ? t : a?.cache_control) != null ? n : o?.cacheControl) != null ? r : o?.cache_control;
 }
-function Ho(e) {
-  var t, n, r, o, a, l, c, i, u, h;
-  const f = [];
-  for (const { role: m, content: _, providerOptions: g } of e)
-    switch (m) {
+function Fo(e) {
+  var t, n, r, o, a, i, c, l, u, h;
+  const g = [];
+  for (const { role: f, content: v, providerOptions: m } of e)
+    switch (f) {
       case "system": {
-        f.push({
+        g.push({
           role: "system",
-          content: _,
-          cache_control: Q(g)
+          content: v,
+          cache_control: ee(m)
         });
         break;
       }
       case "user": {
-        if (_.length === 1 && ((t = _[0]) == null ? void 0 : t.type) === "text") {
-          const y = (n = Q(g)) != null ? n : Q(_[0].providerOptions), T = y ? [
+        if (v.length === 1 && ((t = v[0]) == null ? void 0 : t.type) === "text") {
+          const b = (n = ee(m)) != null ? n : ee(v[0].providerOptions), R = b ? [
             {
               type: "text",
-              text: _[0].text,
-              cache_control: y
+              text: v[0].text,
+              cache_control: b
             }
-          ] : _[0].text;
-          f.push({
+          ] : v[0].text;
+          g.push({
             role: "user",
-            content: T
+            content: R
           });
           break;
         }
-        const p = Q(g), b = _.map(
-          (y) => {
-            var T, w, A, x, $, M, H;
-            const W = (T = Q(y.providerOptions)) != null ? T : p;
-            switch (y.type) {
+        const p = ee(m), w = v.map(
+          (b) => {
+            var R, T, S, M, $, A, I;
+            const z = (R = ee(b.providerOptions)) != null ? R : p;
+            switch (b.type) {
               case "text":
                 return {
                   type: "text",
-                  text: y.text,
+                  text: b.text,
                   // For text parts, only use part-specific cache control
-                  cache_control: W
+                  cache_control: z
                 };
               case "file": {
-                if ((w = y.mediaType) != null && w.startsWith("image/"))
+                if ((T = b.mediaType) != null && T.startsWith("image/"))
                   return {
                     type: "image_url",
                     image_url: {
-                      url: Le({
-                        part: y,
+                      url: Be({
+                        part: b,
                         defaultMediaType: "image/jpeg"
                       })
                     },
                     // For image parts, use part-specific or message-level cache control
-                    cache_control: W
+                    cache_control: z
                   };
-                if ((A = y.mediaType) != null && A.startsWith("audio/"))
+                if ((S = b.mediaType) != null && S.startsWith("audio/"))
                   return {
                     type: "input_audio",
-                    input_audio: qo(y),
-                    cache_control: W
+                    input_audio: Wo(b),
+                    cache_control: z
                   };
-                const z = String(
-                  (H = (M = ($ = (x = y.providerOptions) == null ? void 0 : x.openrouter) == null ? void 0 : $.filename) != null ? M : y.filename) != null ? H : ""
-                ), G = Le({
-                  part: y,
+                const J = String(
+                  (I = (A = ($ = (M = b.providerOptions) == null ? void 0 : M.openrouter) == null ? void 0 : $.filename) != null ? A : b.filename) != null ? I : ""
+                ), G = Be({
+                  part: b,
                   defaultMediaType: "application/pdf"
                 });
-                return et({
+                return nt({
                   url: G,
                   protocols: /* @__PURE__ */ new Set(["http:", "https:"])
                 }) ? {
                   type: "file",
                   file: {
-                    filename: z,
+                    filename: J,
                     file_data: G
                   }
                 } : {
                   type: "file",
                   file: {
-                    filename: z,
+                    filename: J,
                     file_data: G
                   },
-                  cache_control: W
+                  cache_control: z
                 };
               }
               default:
                 return {
                   type: "text",
                   text: "",
-                  cache_control: W
+                  cache_control: z
                 };
             }
           }
         );
-        f.push({
+        g.push({
           role: "user",
-          content: b
+          content: w
         });
         break;
       }
       case "assistant": {
-        let p = "", b = "";
-        const y = [], T = [];
-        for (const M of _)
-          switch (M.type) {
+        let p = "", w = "";
+        const b = [], R = [];
+        for (const A of v)
+          switch (A.type) {
             case "text": {
-              p += M.text;
+              p += A.text;
               break;
             }
             case "tool-call": {
-              const H = (r = M.providerOptions) == null ? void 0 : r.openrouter;
-              H?.reasoning_details && Array.isArray(H.reasoning_details) && T.push(
-                ...H.reasoning_details
-              ), y.push({
-                id: M.toolCallId,
+              const I = (r = A.providerOptions) == null ? void 0 : r.openrouter;
+              I?.reasoning_details && Array.isArray(I.reasoning_details) && R.push(
+                ...I.reasoning_details
+              ), b.push({
+                id: A.toolCallId,
                 type: "function",
                 function: {
-                  name: M.toolName,
-                  arguments: JSON.stringify(M.input)
+                  name: A.toolName,
+                  arguments: JSON.stringify(A.input)
                 }
               });
               break;
             }
             case "reasoning": {
-              b += M.text;
-              const H = ut.safeParse(M.providerOptions);
-              H.success && ((a = (o = H.data) == null ? void 0 : o.openrouter) != null && a.reasoning_details) && T.push(
-                ...H.data.openrouter.reasoning_details
+              w += A.text;
+              const I = pt.safeParse(A.providerOptions);
+              I.success && ((a = (o = I.data) == null ? void 0 : o.openrouter) != null && a.reasoning_details) && R.push(
+                ...I.data.openrouter.reasoning_details
               );
               break;
             }
           }
-        const w = ut.safeParse(g), A = w.success ? (c = (l = w.data) == null ? void 0 : l.openrouter) == null ? void 0 : c.reasoning_details : void 0, x = w.success ? (u = (i = w.data) == null ? void 0 : i.openrouter) == null ? void 0 : u.annotations : void 0, $ = A && Array.isArray(A) && A.length > 0 ? A : T.length > 0 ? T : void 0;
-        f.push({
+        const T = pt.safeParse(m), S = T.success ? (c = (i = T.data) == null ? void 0 : i.openrouter) == null ? void 0 : c.reasoning_details : void 0, M = T.success ? (u = (l = T.data) == null ? void 0 : l.openrouter) == null ? void 0 : u.annotations : void 0, $ = S && Array.isArray(S) && S.length > 0 ? S : R.length > 0 ? R : void 0;
+        g.push({
           role: "assistant",
           content: p,
-          tool_calls: y.length > 0 ? y : void 0,
-          reasoning: b || void 0,
+          tool_calls: b.length > 0 ? b : void 0,
+          reasoning: w || void 0,
           reasoning_details: $,
-          annotations: x,
-          cache_control: Q(g)
+          annotations: M,
+          cache_control: ee(m)
         });
         break;
       }
       case "tool": {
-        for (const p of _) {
-          const b = Lo(p);
-          f.push({
+        for (const p of v) {
+          const w = Ko(p);
+          g.push({
             role: "tool",
             tool_call_id: p.toolCallId,
-            content: b,
-            cache_control: (h = Q(g)) != null ? h : Q(p.providerOptions)
+            content: w,
+            cache_control: (h = ee(m)) != null ? h : ee(p.providerOptions)
           });
         }
         break;
       }
     }
-  return f;
+  return g;
 }
-function Lo(e) {
+function Ko(e) {
   return e.output.type === "text" ? e.output.value : JSON.stringify(e.output.value);
 }
-D([
-  E("auto"),
-  E("none"),
-  E("required"),
+j([
+  x("auto"),
+  x("none"),
+  x("required"),
   d({
-    type: E("function"),
+    type: x("function"),
     function: d({
       name: s()
     })
   })
 ]);
-function Vo(e) {
+function Zo(e) {
   switch (e.type) {
     case "auto":
     case "none":
@@ -2717,21 +2823,21 @@ function Vo(e) {
         function: { name: e.toolName }
       };
     default:
-      throw new Gt({
+      throw new Wt({
         argument: "toolChoice",
         message: `Invalid tool choice type: ${JSON.stringify(e)}`
       });
   }
 }
-var Bo = d({
-  type: E("image_url"),
+var Xo = d({
+  type: x("image_url"),
   image_url: d({
     url: s()
   }).passthrough()
-}).passthrough(), Jo = D([
-  Bo,
-  ne().transform(() => null)
-]), kn = v(Jo).transform((e) => e.filter((t) => !!t)), Tn = d({
+}).passthrough(), Yo = j([
+  Xo,
+  oe().transform(() => null)
+]), kn = y(Yo).transform((e) => e.filter((t) => !!t)), Tn = d({
   id: s().optional(),
   model: s().optional(),
   provider: s().optional(),
@@ -2750,32 +2856,32 @@ var Bo = d({
       upstream_inference_cost: k().nullish()
     }).passthrough().nullish()
   }).passthrough().nullish()
-}).passthrough(), zo = D([
+}).passthrough(), Qo = j([
   // Success response with choices
   Tn.extend({
-    choices: v(
+    choices: y(
       d({
         message: d({
-          role: E("assistant"),
+          role: x("assistant"),
           content: s().nullable().optional(),
           reasoning: s().nullable().optional(),
-          reasoning_details: Qe.nullish(),
+          reasoning_details: tt.nullish(),
           images: kn.nullish(),
-          tool_calls: v(
+          tool_calls: y(
             d({
               id: s().optional().nullable(),
-              type: E("function"),
+              type: x("function"),
               function: d({
                 name: s(),
                 arguments: s()
               }).passthrough()
             }).passthrough()
           ).optional(),
-          annotations: v(
-            D([
+          annotations: y(
+            j([
               // URL citation from web search
               d({
-                type: E("url_citation"),
+                type: x("url_citation"),
                 url_citation: d({
                   end_index: k(),
                   start_index: k(),
@@ -2786,7 +2892,7 @@ var Bo = d({
               }).passthrough(),
               // File annotation from FileParserPlugin (old format)
               d({
-                type: E("file_annotation"),
+                type: x("file_annotation"),
                 file_annotation: d({
                   file_id: s(),
                   quote: s().optional()
@@ -2794,11 +2900,11 @@ var Bo = d({
               }).passthrough(),
               // File annotation from FileParserPlugin (new format)
               d({
-                type: E("file"),
+                type: x("file"),
                 file: d({
                   hash: s(),
                   name: s(),
-                  content: v(
+                  content: y(
                     d({
                       type: s(),
                       text: s().optional()
@@ -2811,11 +2917,11 @@ var Bo = d({
         }).passthrough(),
         index: k().nullish(),
         logprobs: d({
-          content: v(
+          content: y(
             d({
               token: s(),
               logprob: k(),
-              top_logprobs: v(
+              top_logprobs: y(
                 d({
                   token: s(),
                   logprob: k()
@@ -2829,35 +2935,35 @@ var Bo = d({
     )
   }),
   // Error response (HTTP 200 with error payload)
-  Ae.extend({
+  Ue.extend({
     user_id: s().optional()
   })
-]), Wo = D([
+]), es = j([
   Tn.extend({
-    choices: v(
+    choices: y(
       d({
         delta: d({
-          role: Je(["assistant"]).optional(),
+          role: Ge(["assistant"]).optional(),
           content: s().nullish(),
           reasoning: s().nullish().optional(),
-          reasoning_details: Qe.nullish(),
+          reasoning_details: tt.nullish(),
           images: kn.nullish(),
-          tool_calls: v(
+          tool_calls: y(
             d({
               index: k().nullish(),
               id: s().nullish(),
-              type: E("function").optional(),
+              type: x("function").optional(),
               function: d({
                 name: s().nullish(),
                 arguments: s().nullish()
               }).passthrough()
             }).passthrough()
           ).nullish(),
-          annotations: v(
-            D([
+          annotations: y(
+            j([
               // URL citation from web search
               d({
-                type: E("url_citation"),
+                type: x("url_citation"),
                 url_citation: d({
                   end_index: k(),
                   start_index: k(),
@@ -2868,7 +2974,7 @@ var Bo = d({
               }).passthrough(),
               // File annotation from FileParserPlugin (old format)
               d({
-                type: E("file_annotation"),
+                type: x("file_annotation"),
                 file_annotation: d({
                   file_id: s(),
                   quote: s().optional()
@@ -2876,11 +2982,11 @@ var Bo = d({
               }).passthrough(),
               // File annotation from FileParserPlugin (new format)
               d({
-                type: E("file"),
+                type: x("file"),
                 file: d({
                   hash: s(),
                   name: s(),
-                  content: v(
+                  content: y(
                     d({
                       type: s(),
                       text: s().optional()
@@ -2892,11 +2998,11 @@ var Bo = d({
           ).nullish()
         }).passthrough().nullish(),
         logprobs: d({
-          content: v(
+          content: y(
             d({
               token: s(),
               logprob: k(),
-              top_logprobs: v(
+              top_logprobs: y(
                 d({
                   token: s(),
                   logprob: k()
@@ -2910,8 +3016,8 @@ var Bo = d({
       }).passthrough()
     )
   }),
-  Ae
-]), Go = class {
+  Ue
+]), ts = class {
   constructor(e, t, n) {
     this.specificationVersion = "v2", this.provider = "openrouter", this.defaultObjectGenerationMode = "tool", this.supportsImageUrls = !0, this.supportedUrls = {
       "image/*": [
@@ -2929,15 +3035,15 @@ var Bo = d({
     topP: r,
     frequencyPenalty: o,
     presencePenalty: a,
-    seed: l,
+    seed: i,
     stopSequences: c,
-    responseFormat: i,
+    responseFormat: l,
     topK: u,
     tools: h,
-    toolChoice: f
+    toolChoice: g
   }) {
-    var m;
-    const _ = O(O({
+    var f;
+    const v = P(P({
       // model id:
       model: this.modelId,
       models: this.settings.models,
@@ -2953,21 +3059,21 @@ var Bo = d({
       top_p: r,
       frequency_penalty: o,
       presence_penalty: a,
-      seed: l,
+      seed: i,
       stop: c,
-      response_format: i?.type === "json" ? i.schema != null ? {
+      response_format: l?.type === "json" ? l.schema != null ? {
         type: "json_schema",
-        json_schema: O({
-          schema: i.schema,
+        json_schema: P({
+          schema: l.schema,
           strict: !0,
-          name: (m = i.name) != null ? m : "response"
-        }, i.description && {
-          description: i.description
+          name: (f = l.name) != null ? f : "response"
+        }, l.description && {
+          description: l.description
         })
       } : { type: "json_object" } : void 0,
       top_k: u,
       // messages:
-      messages: Ho(e),
+      messages: Fo(e),
       // OpenRouter specific settings:
       include_reasoning: this.settings.includeReasoning,
       reasoning: this.settings.reasoning,
@@ -2981,7 +3087,7 @@ var Bo = d({
       debug: this.settings.debug
     }, this.config.extraBody), this.settings.extraBody);
     if (h && h.length > 0) {
-      const g = h.filter(
+      const m = h.filter(
         (p) => p.type === "function"
       ).map((p) => ({
         type: "function",
@@ -2991,96 +3097,96 @@ var Bo = d({
           parameters: p.inputSchema
         }
       }));
-      return Ee(O({}, _), {
-        tools: g,
-        tool_choice: f ? Vo(f) : void 0
+      return xe(P({}, v), {
+        tools: m,
+        tool_choice: g ? Zo(g) : void 0
       });
     }
-    return _;
+    return v;
   }
   async doGenerate(e) {
-    var t, n, r, o, a, l, c, i, u, h, f, m, _, g, p, b, y, T, w, A, x, $, M;
-    const W = (e.providerOptions || {}).openrouter || {}, z = O(O({}, this.getArgs(e)), W), { value: G, responseHeaders: re } = await pe({
+    var t, n, r, o, a, i, c, l, u, h, g, f, v, m, p, w, b, R, T, S, M, $, A;
+    const z = (e.providerOptions || {}).openrouter || {}, J = P(P({}, this.getArgs(e)), z), { value: G, responseHeaders: se } = await fe({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
-      headers: de(this.config.headers(), e.headers),
-      body: z,
-      failedResponseHandler: he,
-      successfulResponseHandler: Ze(
-        zo
+      headers: me(this.config.headers(), e.headers),
+      body: J,
+      failedResponseHandler: ge,
+      successfulResponseHandler: Ye(
+        Qo
       ),
       abortSignal: e.abortSignal,
       fetch: this.config.fetch
     });
     if ("error" in G) {
-      const R = G.error;
-      throw new K({
-        message: R.message,
+      const _ = G.error;
+      throw new F({
+        message: _.message,
         url: this.config.url({
           path: "/chat/completions",
           modelId: this.modelId
         }),
-        requestBodyValues: z,
+        requestBodyValues: J,
         statusCode: 200,
-        responseHeaders: re,
-        data: R
+        responseHeaders: se,
+        data: _
       });
     }
-    const j = G, L = j.choices[0];
-    if (!L)
+    const D = G, H = D.choices[0];
+    if (!H)
       throw new un({
         message: "No choice in response"
       });
-    const te = j.usage ? {
-      inputTokens: (t = j.usage.prompt_tokens) != null ? t : 0,
-      outputTokens: (n = j.usage.completion_tokens) != null ? n : 0,
-      totalTokens: ((r = j.usage.prompt_tokens) != null ? r : 0) + ((o = j.usage.completion_tokens) != null ? o : 0),
-      reasoningTokens: (l = (a = j.usage.completion_tokens_details) == null ? void 0 : a.reasoning_tokens) != null ? l : 0,
-      cachedInputTokens: (i = (c = j.usage.prompt_tokens_details) == null ? void 0 : c.cached_tokens) != null ? i : 0
+    const ne = D.usage ? {
+      inputTokens: (t = D.usage.prompt_tokens) != null ? t : 0,
+      outputTokens: (n = D.usage.completion_tokens) != null ? n : 0,
+      totalTokens: ((r = D.usage.prompt_tokens) != null ? r : 0) + ((o = D.usage.completion_tokens) != null ? o : 0),
+      reasoningTokens: (i = (a = D.usage.completion_tokens_details) == null ? void 0 : a.reasoning_tokens) != null ? i : 0,
+      cachedInputTokens: (l = (c = D.usage.prompt_tokens_details) == null ? void 0 : c.cached_tokens) != null ? l : 0
     } : {
       inputTokens: 0,
       outputTokens: 0,
       totalTokens: 0,
       reasoningTokens: 0,
       cachedInputTokens: 0
-    }, oe = (u = L.message.reasoning_details) != null ? u : [], ge = oe.length > 0 ? oe.map((R) => {
-      switch (R.type) {
+    }, re = (u = H.message.reasoning_details) != null ? u : [], ve = re.length > 0 ? re.map((_) => {
+      switch (_.type) {
         case "reasoning.text": {
-          if (R.text)
+          if (_.text)
             return {
               type: "reasoning",
-              text: R.text,
+              text: _.text,
               providerMetadata: {
                 openrouter: {
-                  reasoning_details: [R]
+                  reasoning_details: [_]
                 }
               }
             };
           break;
         }
         case "reasoning.summary": {
-          if (R.summary)
+          if (_.summary)
             return {
               type: "reasoning",
-              text: R.summary,
+              text: _.summary,
               providerMetadata: {
                 openrouter: {
-                  reasoning_details: [R]
+                  reasoning_details: [_]
                 }
               }
             };
           break;
         }
         case "reasoning.encrypted": {
-          if (R.data)
+          if (_.data)
             return {
               type: "reasoning",
               text: "[REDACTED]",
               providerMetadata: {
                 openrouter: {
-                  reasoning_details: [R]
+                  reasoning_details: [_]
                 }
               }
             };
@@ -3088,353 +3194,366 @@ var Bo = d({
         }
       }
       return null;
-    }).filter((R) => R !== null) : L.message.reasoning ? [
+    }).filter((_) => _ !== null) : H.message.reasoning ? [
       {
         type: "reasoning",
-        text: L.message.reasoning
+        text: H.message.reasoning
       }
     ] : [], Z = [];
-    if (Z.push(...ge), L.message.content && Z.push({
+    if (Z.push(...ve), H.message.content && Z.push({
       type: "text",
-      text: L.message.content
-    }), L.message.tool_calls)
-      for (const R of L.message.tool_calls)
+      text: H.message.content
+    }), H.message.tool_calls)
+      for (const _ of H.message.tool_calls)
         Z.push({
           type: "tool-call",
-          toolCallId: (h = R.id) != null ? h : F(),
-          toolName: R.function.name,
-          input: R.function.arguments,
+          toolCallId: (h = _.id) != null ? h : W(),
+          toolName: _.function.name,
+          input: _.function.arguments,
           providerMetadata: {
             openrouter: {
-              reasoning_details: oe
+              reasoning_details: re
             }
           }
         });
-    if (L.message.images)
-      for (const R of L.message.images)
+    if (H.message.images)
+      for (const _ of H.message.images)
         Z.push({
           type: "file",
-          mediaType: dt(R.image_url.url, "image/jpeg"),
-          data: Ve(R.image_url.url)
+          mediaType: ht(_.image_url.url, "image/jpeg"),
+          data: Je(_.image_url.url)
         });
-    if (L.message.annotations)
-      for (const R of L.message.annotations)
-        R.type === "url_citation" && Z.push({
+    if (H.message.annotations)
+      for (const _ of H.message.annotations)
+        _.type === "url_citation" && Z.push({
           type: "source",
           sourceType: "url",
-          id: R.url_citation.url,
-          url: R.url_citation.url,
-          title: R.url_citation.title,
+          id: _.url_citation.url,
+          url: _.url_citation.url,
+          title: _.url_citation.title,
           providerMetadata: {
             openrouter: {
-              content: R.url_citation.content || ""
+              content: _.url_citation.content || ""
             }
           }
         });
-    const U = (f = L.message.annotations) == null ? void 0 : f.filter(
-      (R) => R.type === "file"
-    );
+    const ae = (g = H.message.annotations) == null ? void 0 : g.filter(
+      (_) => _.type === "file"
+    ), U = H.message.tool_calls && H.message.tool_calls.length > 0, Q = re.some(
+      (_) => _.type === "reasoning.encrypted" && _.data
+    ), ie = U && Q && H.finish_reason === "stop" ? "tool-calls" : Oe(H.finish_reason);
     return {
       content: Z,
-      finishReason: xe(L.finish_reason),
-      usage: te,
+      finishReason: ie,
+      usage: ne,
       warnings: [],
       providerMetadata: {
-        openrouter: jo.parse({
-          provider: (m = j.provider) != null ? m : "",
-          reasoning_details: (_ = L.message.reasoning_details) != null ? _ : [],
-          annotations: U && U.length > 0 ? U : void 0,
-          usage: O(O(O({
-            promptTokens: (g = te.inputTokens) != null ? g : 0,
-            completionTokens: (p = te.outputTokens) != null ? p : 0,
-            totalTokens: (b = te.totalTokens) != null ? b : 0,
-            cost: (y = j.usage) == null ? void 0 : y.cost
-          }, ((w = (T = j.usage) == null ? void 0 : T.prompt_tokens_details) == null ? void 0 : w.cached_tokens) != null ? {
+        openrouter: Jo.parse({
+          provider: (f = D.provider) != null ? f : "",
+          reasoning_details: (v = H.message.reasoning_details) != null ? v : [],
+          annotations: ae && ae.length > 0 ? ae : void 0,
+          usage: P(P(P({
+            promptTokens: (m = ne.inputTokens) != null ? m : 0,
+            completionTokens: (p = ne.outputTokens) != null ? p : 0,
+            totalTokens: (w = ne.totalTokens) != null ? w : 0,
+            cost: (b = D.usage) == null ? void 0 : b.cost
+          }, ((T = (R = D.usage) == null ? void 0 : R.prompt_tokens_details) == null ? void 0 : T.cached_tokens) != null ? {
             promptTokensDetails: {
-              cachedTokens: j.usage.prompt_tokens_details.cached_tokens
+              cachedTokens: D.usage.prompt_tokens_details.cached_tokens
             }
-          } : {}), ((x = (A = j.usage) == null ? void 0 : A.completion_tokens_details) == null ? void 0 : x.reasoning_tokens) != null ? {
+          } : {}), ((M = (S = D.usage) == null ? void 0 : S.completion_tokens_details) == null ? void 0 : M.reasoning_tokens) != null ? {
             completionTokensDetails: {
-              reasoningTokens: j.usage.completion_tokens_details.reasoning_tokens
+              reasoningTokens: D.usage.completion_tokens_details.reasoning_tokens
             }
-          } : {}), ((M = ($ = j.usage) == null ? void 0 : $.cost_details) == null ? void 0 : M.upstream_inference_cost) != null ? {
+          } : {}), ((A = ($ = D.usage) == null ? void 0 : $.cost_details) == null ? void 0 : A.upstream_inference_cost) != null ? {
             costDetails: {
-              upstreamInferenceCost: j.usage.cost_details.upstream_inference_cost
+              upstreamInferenceCost: D.usage.cost_details.upstream_inference_cost
             }
           } : {})
         })
       },
-      request: { body: z },
+      request: { body: J },
       response: {
-        id: j.id,
-        modelId: j.model,
-        headers: re
+        id: D.id,
+        modelId: D.model,
+        headers: se
       }
     };
   }
   async doStream(e) {
     var t;
-    const r = (e.providerOptions || {}).openrouter || {}, o = O(O({}, this.getArgs(e)), r), { value: a, responseHeaders: l } = await pe({
+    const r = (e.providerOptions || {}).openrouter || {}, o = P(P({}, this.getArgs(e)), r), { value: a, responseHeaders: i } = await fe({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
-      headers: de(this.config.headers(), e.headers),
-      body: Ee(O({}, o), {
+      headers: me(this.config.headers(), e.headers),
+      body: xe(P({}, o), {
         stream: !0,
         // only include stream_options when in strict compatibility mode:
-        stream_options: this.config.compatibility === "strict" ? O({
+        stream_options: this.config.compatibility === "strict" ? P({
           include_usage: !0
         }, (t = this.settings.usage) != null && t.include ? { include_usage: !0 } : {}) : void 0
       }),
-      failedResponseHandler: he,
+      failedResponseHandler: ge,
       successfulResponseHandler: yn(
-        Wo
+        es
       ),
       abortSignal: e.abortSignal,
       fetch: this.config.fetch
     }), c = [];
-    let i = "other";
+    let l = "other";
     const u = {
       inputTokens: Number.NaN,
       outputTokens: Number.NaN,
       totalTokens: Number.NaN,
       reasoningTokens: Number.NaN,
       cachedInputTokens: Number.NaN
-    }, h = {}, f = [];
-    let m = !1, _ = !1, g, p, b, y;
+    }, h = {}, g = [], f = [];
+    let v = !1, m = !1, p, w, b, R;
     return {
       stream: a.pipeThrough(
         new TransformStream({
-          transform(T, w) {
-            var A, x, $, M, H, W, z, G, re, j, L, te, oe, ge, Z;
+          transform(T, S) {
+            var M, $, A, I, z, J, G, se, D, H, ne, re, ve, Z, ae;
             if (!T.success) {
-              i = "error", w.enqueue({ type: "error", error: T.error });
+              l = "error", S.enqueue({ type: "error", error: T.error });
               return;
             }
             const U = T.value;
             if ("error" in U) {
-              i = "error", w.enqueue({ type: "error", error: U.error });
+              l = "error", S.enqueue({ type: "error", error: U.error });
               return;
             }
-            if (U.provider && (y = U.provider), U.id && (b = U.id, w.enqueue({
+            if (U.provider && (R = U.provider), U.id && (b = U.id, S.enqueue({
               type: "response-metadata",
               id: U.id
-            })), U.model && w.enqueue({
+            })), U.model && S.enqueue({
               type: "response-metadata",
               modelId: U.model
             }), U.usage != null) {
               if (u.inputTokens = U.usage.prompt_tokens, u.outputTokens = U.usage.completion_tokens, u.totalTokens = U.usage.prompt_tokens + U.usage.completion_tokens, h.promptTokens = U.usage.prompt_tokens, U.usage.prompt_tokens_details) {
-                const I = (A = U.usage.prompt_tokens_details.cached_tokens) != null ? A : 0;
-                u.cachedInputTokens = I, h.promptTokensDetails = {
-                  cachedTokens: I
+                const C = (M = U.usage.prompt_tokens_details.cached_tokens) != null ? M : 0;
+                u.cachedInputTokens = C, h.promptTokensDetails = {
+                  cachedTokens: C
                 };
               }
               if (h.completionTokens = U.usage.completion_tokens, U.usage.completion_tokens_details) {
-                const I = (x = U.usage.completion_tokens_details.reasoning_tokens) != null ? x : 0;
-                u.reasoningTokens = I, h.completionTokensDetails = {
-                  reasoningTokens: I
+                const C = ($ = U.usage.completion_tokens_details.reasoning_tokens) != null ? $ : 0;
+                u.reasoningTokens = C, h.completionTokensDetails = {
+                  reasoningTokens: C
                 };
               }
               h.cost = U.usage.cost, h.totalTokens = U.usage.total_tokens;
-              const C = ($ = U.usage.cost_details) == null ? void 0 : $.upstream_inference_cost;
-              C != null && (h.costDetails = {
-                upstreamInferenceCost: C
+              const _ = (A = U.usage.cost_details) == null ? void 0 : A.upstream_inference_cost;
+              _ != null && (h.costDetails = {
+                upstreamInferenceCost: _
               });
             }
-            const R = U.choices[0];
-            if (R?.finish_reason != null && (i = xe(R.finish_reason)), R?.delta == null)
+            const Q = U.choices[0];
+            if (Q?.finish_reason != null && (l = Oe(Q.finish_reason)), Q?.delta == null)
               return;
-            const V = R.delta, fe = (C, I) => {
-              _ || (p = b || F(), w.enqueue({
-                providerMetadata: I,
+            const q = Q.delta, ie = (_, C) => {
+              m || (w = b || W(), S.enqueue({
+                providerMetadata: C,
                 type: "reasoning-start",
-                id: p
-              }), _ = !0), w.enqueue({
-                providerMetadata: I,
+                id: w
+              }), m = !0), S.enqueue({
+                providerMetadata: C,
                 type: "reasoning-delta",
-                delta: C,
-                id: p || F()
+                delta: _,
+                id: w || W()
               });
             };
-            if (V.reasoning_details && V.reasoning_details.length > 0) {
-              for (const I of V.reasoning_details)
-                if (I.type === "reasoning.text") {
-                  const N = f[f.length - 1];
-                  N?.type === "reasoning.text" ? (N.text = (N.text || "") + (I.text || ""), N.signature = N.signature || I.signature, N.format = N.format || I.format) : f.push(O({}, I));
+            if (q.reasoning_details && q.reasoning_details.length > 0) {
+              for (const C of q.reasoning_details)
+                if (C.type === "reasoning.text") {
+                  const N = g[g.length - 1];
+                  N?.type === "reasoning.text" ? (N.text = (N.text || "") + (C.text || ""), N.signature = N.signature || C.signature, N.format = N.format || C.format) : g.push(P({}, C));
                 } else
-                  f.push(I);
-              const C = {
+                  g.push(C);
+              const _ = {
                 openrouter: {
-                  reasoning_details: V.reasoning_details
+                  reasoning_details: q.reasoning_details
                 }
               };
-              for (const I of V.reasoning_details)
-                switch (I.type) {
+              for (const C of q.reasoning_details)
+                switch (C.type) {
                   case "reasoning.text": {
-                    I.text && fe(I.text, C);
+                    C.text && ie(C.text, _);
                     break;
                   }
                   case "reasoning.encrypted": {
-                    I.data && fe("[REDACTED]", C);
+                    C.data && ie("[REDACTED]", _);
                     break;
                   }
                   case "reasoning.summary": {
-                    I.summary && fe(I.summary, C);
+                    C.summary && ie(C.summary, _);
                     break;
                   }
                 }
-            } else V.reasoning && fe(V.reasoning);
-            if (V.content && (_ && !m && (w.enqueue({
+            } else q.reasoning && ie(q.reasoning);
+            if (q.content && (m && !v && (S.enqueue({
               type: "reasoning-end",
-              id: p || F()
-            }), _ = !1), m || (g = b || F(), w.enqueue({
+              id: w || W()
+            }), m = !1), v || (p = b || W(), S.enqueue({
               type: "text-start",
-              id: g
-            }), m = !0), w.enqueue({
+              id: p
+            }), v = !0), S.enqueue({
               type: "text-delta",
-              delta: V.content,
-              id: g || F()
-            })), V.annotations)
-              for (const C of V.annotations)
-                C.type === "url_citation" && w.enqueue({
-                  type: "source",
-                  sourceType: "url",
-                  id: C.url_citation.url,
-                  url: C.url_citation.url,
-                  title: C.url_citation.title,
-                  providerMetadata: {
-                    openrouter: {
-                      content: C.url_citation.content || ""
+              delta: q.content,
+              id: p || W()
+            })), q.annotations) {
+              for (const _ of q.annotations)
+                if (_.type === "url_citation")
+                  S.enqueue({
+                    type: "source",
+                    sourceType: "url",
+                    id: _.url_citation.url,
+                    url: _.url_citation.url,
+                    title: _.url_citation.title,
+                    providerMetadata: {
+                      openrouter: {
+                        content: _.url_citation.content || ""
+                      }
                     }
-                  }
-                });
-            if (V.tool_calls != null)
-              for (const C of V.tool_calls) {
-                const I = (M = C.index) != null ? M : c.length - 1;
-                if (c[I] == null) {
-                  if (C.type !== "function")
-                    throw new le({
-                      data: C,
+                  });
+                else if (_.type === "file") {
+                  const C = _.file;
+                  C && typeof C == "object" && "hash" in C && "name" in C && f.push(
+                    _
+                  );
+                }
+            }
+            if (q.tool_calls != null)
+              for (const _ of q.tool_calls) {
+                const C = (I = _.index) != null ? I : c.length - 1;
+                if (c[C] == null) {
+                  if (_.type !== "function")
+                    throw new de({
+                      data: _,
                       message: "Expected 'function' type."
                     });
-                  if (C.id == null)
-                    throw new le({
-                      data: C,
+                  if (_.id == null)
+                    throw new de({
+                      data: _,
                       message: "Expected 'id' to be a string."
                     });
-                  if (((H = C.function) == null ? void 0 : H.name) == null)
-                    throw new le({
-                      data: C,
+                  if (((z = _.function) == null ? void 0 : z.name) == null)
+                    throw new de({
+                      data: _,
                       message: "Expected 'function.name' to be a string."
                     });
-                  c[I] = {
-                    id: C.id,
+                  c[C] = {
+                    id: _.id,
                     type: "function",
                     function: {
-                      name: C.function.name,
-                      arguments: (W = C.function.arguments) != null ? W : ""
+                      name: _.function.name,
+                      arguments: (J = _.function.arguments) != null ? J : ""
                     },
                     inputStarted: !1,
                     sent: !1
                   };
-                  const B = c[I];
-                  if (B == null)
-                    throw new le({
-                      data: { index: I, toolCallsLength: c.length },
-                      message: `Tool call at index ${I} is missing after creation.`
+                  const V = c[C];
+                  if (V == null)
+                    throw new de({
+                      data: { index: C, toolCallsLength: c.length },
+                      message: `Tool call at index ${C} is missing after creation.`
                     });
-                  ((z = B.function) == null ? void 0 : z.name) != null && ((G = B.function) == null ? void 0 : G.arguments) != null && Me(B.function.arguments) && (B.inputStarted = !0, w.enqueue({
+                  ((G = V.function) == null ? void 0 : G.name) != null && ((se = V.function) == null ? void 0 : se.arguments) != null && je(V.function.arguments) && (V.inputStarted = !0, S.enqueue({
                     type: "tool-input-start",
-                    id: B.id,
-                    toolName: B.function.name
-                  }), w.enqueue({
+                    id: V.id,
+                    toolName: V.function.name
+                  }), S.enqueue({
                     type: "tool-input-delta",
-                    id: B.id,
-                    delta: B.function.arguments
-                  }), w.enqueue({
+                    id: V.id,
+                    delta: V.function.arguments
+                  }), S.enqueue({
                     type: "tool-input-end",
-                    id: B.id
-                  }), w.enqueue({
+                    id: V.id
+                  }), S.enqueue({
                     type: "tool-call",
-                    toolCallId: B.id,
-                    toolName: B.function.name,
-                    input: B.function.arguments,
+                    toolCallId: V.id,
+                    toolName: V.function.name,
+                    input: V.function.arguments,
                     providerMetadata: {
                       openrouter: {
-                        reasoning_details: f
+                        reasoning_details: g
                       }
                     }
-                  }), B.sent = !0);
+                  }), V.sent = !0);
                   continue;
                 }
-                const N = c[I];
+                const N = c[C];
                 if (N == null)
-                  throw new le({
+                  throw new de({
                     data: {
-                      index: I,
+                      index: C,
                       toolCallsLength: c.length,
-                      toolCallDelta: C
+                      toolCallDelta: _
                     },
-                    message: `Tool call at index ${I} is missing during merge.`
+                    message: `Tool call at index ${C} is missing during merge.`
                   });
-                N.inputStarted || (N.inputStarted = !0, w.enqueue({
+                N.inputStarted || (N.inputStarted = !0, S.enqueue({
                   type: "tool-input-start",
                   id: N.id,
                   toolName: N.function.name
-                })), ((re = C.function) == null ? void 0 : re.arguments) != null && (N.function.arguments += (L = (j = C.function) == null ? void 0 : j.arguments) != null ? L : ""), w.enqueue({
+                })), ((D = _.function) == null ? void 0 : D.arguments) != null && (N.function.arguments += (ne = (H = _.function) == null ? void 0 : H.arguments) != null ? ne : ""), S.enqueue({
                   type: "tool-input-delta",
                   id: N.id,
-                  delta: (te = C.function.arguments) != null ? te : ""
-                }), ((oe = N.function) == null ? void 0 : oe.name) != null && ((ge = N.function) == null ? void 0 : ge.arguments) != null && Me(N.function.arguments) && (w.enqueue({
+                  delta: (re = _.function.arguments) != null ? re : ""
+                }), ((ve = N.function) == null ? void 0 : ve.name) != null && ((Z = N.function) == null ? void 0 : Z.arguments) != null && je(N.function.arguments) && (S.enqueue({
                   type: "tool-call",
-                  toolCallId: (Z = N.id) != null ? Z : F(),
+                  toolCallId: (ae = N.id) != null ? ae : W(),
                   toolName: N.function.name,
                   input: N.function.arguments,
                   providerMetadata: {
                     openrouter: {
-                      reasoning_details: f
+                      reasoning_details: g
                     }
                   }
                 }), N.sent = !0);
               }
-            if (V.images != null)
-              for (const C of V.images)
-                w.enqueue({
+            if (q.images != null)
+              for (const _ of q.images)
+                S.enqueue({
                   type: "file",
-                  mediaType: dt(C.image_url.url, "image/jpeg"),
-                  data: Ve(C.image_url.url)
+                  mediaType: ht(_.image_url.url, "image/jpeg"),
+                  data: Je(_.image_url.url)
                 });
           },
           flush(T) {
-            var w;
-            if (i === "tool-calls")
-              for (const x of c)
-                x && !x.sent && (T.enqueue({
+            var S;
+            const M = c.length > 0, $ = g.some(
+              (I) => I.type === "reasoning.encrypted" && I.data
+            );
+            if (M && $ && l === "stop" && (l = "tool-calls"), l === "tool-calls")
+              for (const I of c)
+                I && !I.sent && (T.enqueue({
                   type: "tool-call",
-                  toolCallId: (w = x.id) != null ? w : F(),
-                  toolName: x.function.name,
+                  toolCallId: (S = I.id) != null ? S : W(),
+                  toolName: I.function.name,
                   // Coerce invalid arguments to an empty JSON object
-                  input: Me(x.function.arguments) ? x.function.arguments : "{}",
+                  input: je(I.function.arguments) ? I.function.arguments : "{}",
                   providerMetadata: {
                     openrouter: {
-                      reasoning_details: f
+                      reasoning_details: g
                     }
                   }
-                }), x.sent = !0);
-            _ && T.enqueue({
+                }), I.sent = !0);
+            m && T.enqueue({
               type: "reasoning-end",
-              id: p || F()
-            }), m && T.enqueue({
+              id: w || W()
+            }), v && T.enqueue({
               type: "text-end",
-              id: g || F()
+              id: p || W()
             });
             const A = {
               usage: h
             };
-            y !== void 0 && (A.provider = y), f.length > 0 && (A.reasoning_details = f), T.enqueue({
+            R !== void 0 && (A.provider = R), g.length > 0 && (A.reasoning_details = g), f.length > 0 && (A.annotations = f), T.enqueue({
               type: "finish",
-              finishReason: i,
+              finishReason: l,
               usage: u,
               providerMetadata: {
                 openrouter: A
@@ -3445,11 +3564,11 @@ var Bo = d({
       ),
       warnings: [],
       request: { body: o },
-      response: { headers: l }
+      response: { headers: i }
     };
   }
 };
-function Fo({
+function ns({
   prompt: e,
   inputFormat: t,
   user: n = "user",
@@ -3461,20 +3580,20 @@ function Fo({
   e[0] && e[0].role === "system" && (o += `${e[0].content}
 
 `, e = e.slice(1));
-  for (const { role: a, content: l } of e)
+  for (const { role: a, content: i } of e)
     switch (a) {
       case "system":
-        throw new to({
-          message: `Unexpected system message in prompt: ${l}`,
+        throw new io({
+          message: `Unexpected system message in prompt: ${i}`,
           prompt: e
         });
       case "user": {
-        const c = l.map((i) => {
-          switch (i.type) {
+        const c = i.map((l) => {
+          switch (l.type) {
             case "text":
-              return i.text;
+              return l.text;
             case "file":
-              throw new ee({
+              throw new te({
                 functionality: "file attachments"
               });
             default:
@@ -3488,25 +3607,25 @@ ${c}
         break;
       }
       case "assistant": {
-        const c = l.map(
-          (i) => {
-            switch (i.type) {
+        const c = i.map(
+          (l) => {
+            switch (l.type) {
               case "text":
-                return i.text;
+                return l.text;
               case "tool-call":
-                throw new ee({
+                throw new te({
                   functionality: "tool-call messages"
                 });
               case "tool-result":
-                throw new ee({
+                throw new te({
                   functionality: "tool-result messages"
                 });
               case "reasoning":
-                throw new ee({
+                throw new te({
                   functionality: "reasoning messages"
                 });
               case "file":
-                throw new ee({
+                throw new te({
                   functionality: "file attachments"
                 });
               default:
@@ -3521,7 +3640,7 @@ ${c}
         break;
       }
       case "tool":
-        throw new ee({
+        throw new te({
           functionality: "tool messages"
         });
     }
@@ -3530,21 +3649,21 @@ ${c}
     prompt: o
   };
 }
-var pt = D([
+var mt = j([
   d({
     id: s().optional(),
     model: s().optional(),
-    choices: v(
+    choices: y(
       d({
         text: s(),
         reasoning: s().nullish().optional(),
-        reasoning_details: Qe.nullish(),
+        reasoning_details: tt.nullish(),
         finish_reason: s().nullish(),
         index: k().nullish(),
         logprobs: d({
-          tokens: v(s()),
-          token_logprobs: v(k()),
-          top_logprobs: v(Be(s(), k())).nullable()
+          tokens: y(s()),
+          token_logprobs: y(k()),
+          top_logprobs: y(ze(s(), k())).nullable()
         }).passthrough().nullable().optional()
       }).passthrough()
     ),
@@ -3564,8 +3683,8 @@ var pt = D([
       }).passthrough().nullish()
     }).passthrough().nullish()
   }).passthrough(),
-  Ae
-]), Ko = class {
+  Ue
+]), rs = class {
   constructor(e, t, n) {
     this.specificationVersion = "v2", this.provider = "openrouter", this.supportsImageUrls = !0, this.supportedUrls = {
       "image/*": [
@@ -3583,26 +3702,26 @@ var pt = D([
     topP: r,
     frequencyPenalty: o,
     presencePenalty: a,
-    seed: l,
+    seed: i,
     responseFormat: c,
-    topK: i,
+    topK: l,
     stopSequences: u,
     tools: h,
-    toolChoice: f
+    toolChoice: g
   }) {
-    const { prompt: m } = Fo({
+    const { prompt: f } = ns({
       prompt: e,
       inputFormat: "prompt"
     });
     if (h?.length)
-      throw new ee({
+      throw new te({
         functionality: "tools"
       });
-    if (f)
-      throw new ee({
+    if (g)
+      throw new te({
         functionality: "toolChoice"
       });
-    return O(O({
+    return P(P({
       // model id:
       model: this.modelId,
       models: this.settings.models,
@@ -3617,49 +3736,49 @@ var pt = D([
       top_p: r,
       frequency_penalty: o,
       presence_penalty: a,
-      seed: l,
+      seed: i,
       stop: u,
       response_format: c,
-      top_k: i,
+      top_k: l,
       // prompt:
-      prompt: m,
+      prompt: f,
       // OpenRouter specific settings:
       include_reasoning: this.settings.includeReasoning,
       reasoning: this.settings.reasoning
     }, this.config.extraBody), this.settings.extraBody);
   }
   async doGenerate(e) {
-    var t, n, r, o, a, l, c, i, u, h, f, m, _, g, p;
-    const y = (e.providerOptions || {}).openrouter || {}, T = O(O({}, this.getArgs(e)), y), { value: w, responseHeaders: A } = await pe({
+    var t, n, r, o, a, i, c, l, u, h, g, f, v, m, p;
+    const b = (e.providerOptions || {}).openrouter || {}, R = P(P({}, this.getArgs(e)), b), { value: T, responseHeaders: S } = await fe({
       url: this.config.url({
         path: "/completions",
         modelId: this.modelId
       }),
-      headers: de(this.config.headers(), e.headers),
-      body: T,
-      failedResponseHandler: he,
-      successfulResponseHandler: Ze(
-        pt
+      headers: me(this.config.headers(), e.headers),
+      body: R,
+      failedResponseHandler: ge,
+      successfulResponseHandler: Ye(
+        mt
       ),
       abortSignal: e.abortSignal,
       fetch: this.config.fetch
     });
-    if ("error" in w) {
-      const $ = w.error;
-      throw new K({
+    if ("error" in T) {
+      const $ = T.error;
+      throw new F({
         message: $.message,
         url: this.config.url({
           path: "/completions",
           modelId: this.modelId
         }),
-        requestBodyValues: T,
+        requestBodyValues: R,
         statusCode: 200,
-        responseHeaders: A,
+        responseHeaders: S,
         data: $
       });
     }
-    const x = w.choices[0];
-    if (!x)
+    const M = T.choices[0];
+    if (!M)
       throw new un({
         message: "No choice in OpenRouter completion response"
       });
@@ -3667,98 +3786,98 @@ var pt = D([
       content: [
         {
           type: "text",
-          text: (t = x.text) != null ? t : ""
+          text: (t = M.text) != null ? t : ""
         }
       ],
-      finishReason: xe(x.finish_reason),
+      finishReason: Oe(M.finish_reason),
       usage: {
-        inputTokens: (r = (n = w.usage) == null ? void 0 : n.prompt_tokens) != null ? r : 0,
-        outputTokens: (a = (o = w.usage) == null ? void 0 : o.completion_tokens) != null ? a : 0,
-        totalTokens: ((c = (l = w.usage) == null ? void 0 : l.prompt_tokens) != null ? c : 0) + ((u = (i = w.usage) == null ? void 0 : i.completion_tokens) != null ? u : 0),
-        reasoningTokens: (m = (f = (h = w.usage) == null ? void 0 : h.completion_tokens_details) == null ? void 0 : f.reasoning_tokens) != null ? m : 0,
-        cachedInputTokens: (p = (g = (_ = w.usage) == null ? void 0 : _.prompt_tokens_details) == null ? void 0 : g.cached_tokens) != null ? p : 0
+        inputTokens: (r = (n = T.usage) == null ? void 0 : n.prompt_tokens) != null ? r : 0,
+        outputTokens: (a = (o = T.usage) == null ? void 0 : o.completion_tokens) != null ? a : 0,
+        totalTokens: ((c = (i = T.usage) == null ? void 0 : i.prompt_tokens) != null ? c : 0) + ((u = (l = T.usage) == null ? void 0 : l.completion_tokens) != null ? u : 0),
+        reasoningTokens: (f = (g = (h = T.usage) == null ? void 0 : h.completion_tokens_details) == null ? void 0 : g.reasoning_tokens) != null ? f : 0,
+        cachedInputTokens: (p = (m = (v = T.usage) == null ? void 0 : v.prompt_tokens_details) == null ? void 0 : m.cached_tokens) != null ? p : 0
       },
       warnings: [],
       response: {
-        headers: A
+        headers: S
       }
     };
   }
   async doStream(e) {
-    const n = (e.providerOptions || {}).openrouter || {}, r = O(O({}, this.getArgs(e)), n), { value: o, responseHeaders: a } = await pe({
+    const n = (e.providerOptions || {}).openrouter || {}, r = P(P({}, this.getArgs(e)), n), { value: o, responseHeaders: a } = await fe({
       url: this.config.url({
         path: "/completions",
         modelId: this.modelId
       }),
-      headers: de(this.config.headers(), e.headers),
-      body: Ee(O({}, r), {
+      headers: me(this.config.headers(), e.headers),
+      body: xe(P({}, r), {
         stream: !0,
         // only include stream_options when in strict compatibility mode:
         stream_options: this.config.compatibility === "strict" ? { include_usage: !0 } : void 0
       }),
-      failedResponseHandler: he,
+      failedResponseHandler: ge,
       successfulResponseHandler: yn(
-        pt
+        mt
       ),
       abortSignal: e.abortSignal,
       fetch: this.config.fetch
     });
-    let l = "other";
+    let i = "other";
     const c = {
       inputTokens: Number.NaN,
       outputTokens: Number.NaN,
       totalTokens: Number.NaN,
       reasoningTokens: Number.NaN,
       cachedInputTokens: Number.NaN
-    }, i = {};
+    }, l = {};
     return {
       stream: o.pipeThrough(
         new TransformStream({
           transform(u, h) {
-            var f, m, _;
+            var g, f, v;
             if (!u.success) {
-              l = "error", h.enqueue({ type: "error", error: u.error });
+              i = "error", h.enqueue({ type: "error", error: u.error });
               return;
             }
-            const g = u.value;
-            if ("error" in g) {
-              l = "error", h.enqueue({ type: "error", error: g.error });
+            const m = u.value;
+            if ("error" in m) {
+              i = "error", h.enqueue({ type: "error", error: m.error });
               return;
             }
-            if (g.usage != null) {
-              if (c.inputTokens = g.usage.prompt_tokens, c.outputTokens = g.usage.completion_tokens, c.totalTokens = g.usage.prompt_tokens + g.usage.completion_tokens, i.promptTokens = g.usage.prompt_tokens, g.usage.prompt_tokens_details) {
-                const y = (f = g.usage.prompt_tokens_details.cached_tokens) != null ? f : 0;
-                c.cachedInputTokens = y, i.promptTokensDetails = {
-                  cachedTokens: y
+            if (m.usage != null) {
+              if (c.inputTokens = m.usage.prompt_tokens, c.outputTokens = m.usage.completion_tokens, c.totalTokens = m.usage.prompt_tokens + m.usage.completion_tokens, l.promptTokens = m.usage.prompt_tokens, m.usage.prompt_tokens_details) {
+                const b = (g = m.usage.prompt_tokens_details.cached_tokens) != null ? g : 0;
+                c.cachedInputTokens = b, l.promptTokensDetails = {
+                  cachedTokens: b
                 };
               }
-              if (i.completionTokens = g.usage.completion_tokens, g.usage.completion_tokens_details) {
-                const y = (m = g.usage.completion_tokens_details.reasoning_tokens) != null ? m : 0;
-                c.reasoningTokens = y, i.completionTokensDetails = {
-                  reasoningTokens: y
+              if (l.completionTokens = m.usage.completion_tokens, m.usage.completion_tokens_details) {
+                const b = (f = m.usage.completion_tokens_details.reasoning_tokens) != null ? f : 0;
+                c.reasoningTokens = b, l.completionTokensDetails = {
+                  reasoningTokens: b
                 };
               }
-              i.cost = g.usage.cost, i.totalTokens = g.usage.total_tokens;
-              const b = (_ = g.usage.cost_details) == null ? void 0 : _.upstream_inference_cost;
-              b != null && (i.costDetails = {
-                upstreamInferenceCost: b
+              l.cost = m.usage.cost, l.totalTokens = m.usage.total_tokens;
+              const w = (v = m.usage.cost_details) == null ? void 0 : v.upstream_inference_cost;
+              w != null && (l.costDetails = {
+                upstreamInferenceCost: w
               });
             }
-            const p = g.choices[0];
-            p?.finish_reason != null && (l = xe(p.finish_reason)), p?.text != null && h.enqueue({
+            const p = m.choices[0];
+            p?.finish_reason != null && (i = Oe(p.finish_reason)), p?.text != null && h.enqueue({
               type: "text-delta",
               delta: p.text,
-              id: F()
+              id: W()
             });
           },
           flush(u) {
             u.enqueue({
               type: "finish",
-              finishReason: l,
+              finishReason: i,
               usage: c,
               providerMetadata: {
                 openrouter: {
-                  usage: i
+                  usage: l
                 }
               }
             });
@@ -3770,81 +3889,81 @@ var pt = D([
       }
     };
   }
-}, Zo = d({
+}, os = d({
   prompt_tokens: k(),
   total_tokens: k(),
   cost: k().optional()
-}), Xo = d({
-  object: E("embedding"),
-  embedding: v(k()),
+}), ss = d({
+  object: x("embedding"),
+  embedding: y(k()),
   index: k().optional()
-}), Yo = d({
+}), as = d({
   id: s().optional(),
-  object: E("list"),
-  data: v(Xo),
+  object: x("list"),
+  data: y(ss),
   model: s(),
-  usage: Zo.optional()
-}), Qo = class {
+  usage: os.optional()
+}), is = class {
   constructor(e, t, n) {
     this.specificationVersion = "v2", this.provider = "openrouter", this.maxEmbeddingsPerCall = void 0, this.supportsParallelCalls = !0, this.modelId = e, this.settings = t, this.config = n;
   }
   async doEmbed(e) {
     var t;
-    const { values: n, abortSignal: r, headers: o } = e, a = O(O({
+    const { values: n, abortSignal: r, headers: o } = e, a = P(P({
       model: this.modelId,
       input: n,
       user: this.settings.user,
       provider: this.settings.provider
-    }, this.config.extraBody), this.settings.extraBody), { value: l, responseHeaders: c } = await pe({
+    }, this.config.extraBody), this.settings.extraBody), { value: i, responseHeaders: c } = await fe({
       url: this.config.url({
         path: "/embeddings",
         modelId: this.modelId
       }),
-      headers: de(this.config.headers(), o),
+      headers: me(this.config.headers(), o),
       body: a,
-      failedResponseHandler: he,
-      successfulResponseHandler: Ze(
-        Yo
+      failedResponseHandler: ge,
+      successfulResponseHandler: Ye(
+        as
       ),
       abortSignal: r,
       fetch: this.config.fetch
     });
     return {
-      embeddings: l.data.map((i) => i.embedding),
-      usage: l.usage ? { tokens: l.usage.prompt_tokens } : void 0,
-      providerMetadata: (t = l.usage) != null && t.cost ? {
+      embeddings: i.data.map((l) => l.embedding),
+      usage: i.usage ? { tokens: i.usage.prompt_tokens } : void 0,
+      providerMetadata: (t = i.usage) != null && t.cost ? {
         openrouter: {
           usage: {
-            cost: l.usage.cost
+            cost: i.usage.cost
           }
         }
       } : void 0,
       response: {
         headers: c,
-        body: l
+        body: i
       }
     };
   }
 };
-function es(e) {
+function ls(e) {
   return Object.fromEntries(
     Object.entries(e).filter(([, t]) => t !== null)
   );
 }
-function ts(e, ...t) {
-  const n = es(
+function cs(e, ...t) {
+  const n = ls(
     e ?? {}
   ), o = [n["user-agent"] || "", ...t].filter(Boolean).join(" ");
-  return Ee(O({}, n), {
+  return xe(P({}, n), {
     "user-agent": o
   });
 }
-var ns = "1.4.1";
+var us = "1.5.4";
 function Sn(e = {}) {
   var t, n, r;
-  const o = (n = $o((t = e.baseURL) != null ? t : e.baseUrl)) != null ? n : "https://openrouter.ai/api/v1", a = (r = e.compatibility) != null ? r : "compatible", l = () => ts(
-    O(O({
-      Authorization: `Bearer ${_o({
+  const o = (n = Lo((t = e.baseURL) != null ? t : e.baseUrl)) != null ? n : "https://openrouter.ai/api/v1", a = (r = e.compatibility) != null ? r : "compatible", i = () => cs(
+    P(P({
+      Authorization: `Bearer ${To({
         apiKey: e.apiKey,
         environmentVariableName: "OPENROUTER_API_KEY",
         description: "OpenRouter"
@@ -3852,87 +3971,87 @@ function Sn(e = {}) {
     }, e.headers), e.api_keys && Object.keys(e.api_keys).length > 0 && {
       "X-Provider-API-Keys": JSON.stringify(e.api_keys)
     }),
-    `ai-sdk/openrouter/${ns}`
-  ), c = (m, _ = {}) => new Go(m, _, {
+    `ai-sdk/openrouter/${us}`
+  ), c = (f, v = {}) => new ts(f, v, {
     provider: "openrouter.chat",
-    url: ({ path: g }) => `${o}${g}`,
-    headers: l,
+    url: ({ path: m }) => `${o}${m}`,
+    headers: i,
     compatibility: a,
     fetch: e.fetch,
     extraBody: e.extraBody
-  }), i = (m, _ = {}) => new Ko(m, _, {
+  }), l = (f, v = {}) => new rs(f, v, {
     provider: "openrouter.completion",
-    url: ({ path: g }) => `${o}${g}`,
-    headers: l,
+    url: ({ path: m }) => `${o}${m}`,
+    headers: i,
     compatibility: a,
     fetch: e.fetch,
     extraBody: e.extraBody
-  }), u = (m, _ = {}) => new Qo(m, _, {
+  }), u = (f, v = {}) => new is(f, v, {
     provider: "openrouter.embedding",
-    url: ({ path: g }) => `${o}${g}`,
-    headers: l,
+    url: ({ path: m }) => `${o}${m}`,
+    headers: i,
     fetch: e.fetch,
     extraBody: e.extraBody
-  }), h = (m, _) => {
+  }), h = (f, v) => {
     if (new.target)
       throw new Error(
         "The OpenRouter model function cannot be called with the new keyword."
       );
-    return m === "openai/gpt-3.5-turbo-instruct" ? i(
-      m,
-      _
-    ) : c(m, _);
-  }, f = (m, _) => h(m, _);
-  return f.languageModel = h, f.chat = c, f.completion = i, f.textEmbeddingModel = u, f.embedding = u, f;
+    return f === "openai/gpt-3.5-turbo-instruct" ? l(
+      f,
+      v
+    ) : c(f, v);
+  }, g = (f, v) => h(f, v);
+  return g.languageModel = h, g.chat = c, g.completion = l, g.textEmbeddingModel = u, g.embedding = u, g;
 }
 Sn({
   compatibility: "strict"
   // strict for OpenRouter API
 });
-const rs = "https://app.getgram.ai", ls = () => ({
-  chat: ss
-}), os = d({
+const ds = "https://app.getgram.ai", gs = () => ({
+  chat: hs
+}), ps = d({
   // currently only supports serverURL, however we will support other config shapes for this via a union type in the future
-  mcp: D([s()]),
-  environment: Be(s(), ne()).optional(),
+  mcp: j([s()]),
+  environment: ze(s(), oe()).optional(),
   projectSlug: s(),
-  model: Je(An)
-}), ss = async (e, t) => {
+  model: Ge(An)
+}), hs = async (e, t) => {
   if (e.method === "POST")
     try {
       const n = [];
-      for await (const _ of e)
-        n.push(_);
-      const r = Buffer.concat(n).toString(), { messages: o, config: a, system: l, tools: c } = JSON.parse(r), i = os.parse(a), h = await (await Lr({
+      for await (const v of e)
+        n.push(v);
+      const r = Buffer.concat(n).toString(), { messages: o, config: a, system: i, tools: c } = JSON.parse(r), l = ps.parse(a), h = await (await Wr({
         transport: {
           type: "http",
-          url: i.mcp,
+          url: l.mcp,
           headers: {
-            ...as(i.environment ?? {}),
+            ...ms(l.environment ?? {}),
             // Always send the Gram-Key header last so that it isn't clobbered by the environment variables.
             Authorization: `Bearer ${process.env.GRAM_API_KEY ?? ""}`
           }
         }
-      })).tools(), f = Sn({
-        baseURL: rs,
+      })).tools(), g = Sn({
+        baseURL: ds,
         // We do not use the apiKey field as the requests are proxied through the Gram API.
         // Instead we use the Gram-Key header to authenticate the request.
         apiKey: "must be set",
         headers: {
-          "Gram-Project": i.projectSlug,
+          "Gram-Project": l.projectSlug,
           "Gram-Key": process.env.GRAM_API_KEY ?? ""
         }
-      }), m = In({
-        system: l,
-        model: f.chat(i.model),
-        messages: On(o),
+      }), f = In({
+        system: i,
+        model: g.chat(l.model),
+        messages: Pn(o),
         tools: {
           ...h,
-          ...Un(c)
+          ...$n(c)
         },
-        stopWhen: Pn(10)
+        stopWhen: On(10)
       });
-      t.setHeader("Content-Type", "text/event-stream"), t.setHeader("Cache-Control", "no-cache"), t.setHeader("Connection", "keep-alive"), t.setHeader("Transfer-Encoding", "chunked"), t.statusCode = 200, m.pipeUIMessageStreamToResponse(t, {
+      t.setHeader("Content-Type", "text/event-stream"), t.setHeader("Cache-Control", "no-cache"), t.setHeader("Connection", "keep-alive"), t.setHeader("Transfer-Encoding", "chunked"), t.statusCode = 200, f.pipeUIMessageStreamToResponse(t, {
         sendReasoning: !0,
         sendSources: !0
       });
@@ -3943,16 +4062,16 @@ const rs = "https://app.getgram.ai", ls = () => ({
         })
       );
     }
-}, ht = "MCP-";
-function as(e) {
+}, ft = "MCP-";
+function ms(e) {
   return typeof e != "object" || e === null ? {} : Object.entries(e).reduce(
     (t, [n, r]) => {
-      const o = n.replace(/_/g, "-"), a = o.startsWith(ht) ? o : `${ht}${o}`;
+      const o = n.replace(/_/g, "-"), a = o.startsWith(ft) ? o : `${ft}${o}`;
       return t[a] = r, t;
     },
     {}
   );
 }
 export {
-  ls as createElementsServerHandlers
+  gs as createElementsServerHandlers
 };