@polka-codes/cli-shared 0.9.17 → 0.9.19

package/dist/index.js

@@ -7160,8 +7160,8 @@ var require_directives = __commonJS((exports) => {
       if (prefix) {
         try {
           return prefix + decodeURIComponent(suffix);
-        } catch (error81) {
-          onError(String(error81));
+        } catch (error82) {
+          onError(String(error82));
           return null;
         }
       }
@@ -7253,9 +7253,9 @@ var require_anchors = __commonJS((exports) => {
           if (typeof ref === "object" && ref.anchor && (identity.isScalar(ref.node) || identity.isCollection(ref.node))) {
             ref.node.anchor = ref.anchor;
           } else {
-            const error81 = new Error("Failed to resolve repeated object (this should not happen)");
-            error81.source = source;
-            throw error81;
+            const error82 = new Error("Failed to resolve repeated object (this should not happen)");
+            error82.source = source;
+            throw error82;
           }
         }
       },
@@ -10244,12 +10244,12 @@ var require_errors = __commonJS((exports) => {
       super("YAMLWarning", pos, code, message);
     }
   }
-  var prettifyError3 = (src, lc) => (error81) => {
-    if (error81.pos[0] === -1)
+  var prettifyError3 = (src, lc) => (error82) => {
+    if (error82.pos[0] === -1)
       return;
-    error81.linePos = error81.pos.map((pos) => lc.linePos(pos));
-    const { line, col } = error81.linePos[0];
-    error81.message += ` at line ${line}, column ${col}`;
+    error82.linePos = error82.pos.map((pos) => lc.linePos(pos));
+    const { line, col } = error82.linePos[0];
+    error82.message += ` at line ${line}, column ${col}`;
     let ci = col - 1;
     let lineStr = src.substring(lc.lineStarts[line - 1], lc.lineStarts[line]).replace(/[\n\r]+$/, "");
     if (ci >= 60 && lineStr.length > 80) {
@@ -10268,12 +10268,12 @@ var require_errors = __commonJS((exports) => {
     }
     if (/[^ ]/.test(lineStr)) {
       let count = 1;
-      const end = error81.linePos[1];
+      const end = error82.linePos[1];
       if (end && end.line === line && end.col > col) {
         count = Math.max(1, Math.min(end.col - col, 80 - ci));
       }
       const pointer = " ".repeat(ci) + "^".repeat(count);
-      error81.message += `:
+      error82.message += `:
 
 ${lineStr}
 ${pointer}
@@ -11065,7 +11065,7 @@ var require_resolve_block_scalar = __commonJS((exports) => {
     const mode = source[0];
     let indent = 0;
     let chomp = "";
-    let error81 = -1;
+    let error82 = -1;
     for (let i = 1;i < source.length; ++i) {
       const ch = source[i];
       if (!chomp && (ch === "-" || ch === "+"))
@@ -11074,12 +11074,12 @@ var require_resolve_block_scalar = __commonJS((exports) => {
         const n = Number(ch);
         if (!indent && n)
           indent = n;
-        else if (error81 === -1)
-          error81 = offset + i;
+        else if (error82 === -1)
+          error82 = offset + i;
       }
     }
-    if (error81 !== -1)
-      onError(error81, "UNEXPECTED_TOKEN", `Block scalar header includes extra characters: ${source}`);
+    if (error82 !== -1)
+      onError(error82, "UNEXPECTED_TOKEN", `Block scalar header includes extra characters: ${source}`);
     let hasSpace = false;
     let comment = "";
     let length = source.length;
@@ -11365,8 +11365,8 @@ var require_compose_scalar = __commonJS((exports) => {
     try {
       const res = tag.resolve(value, (msg) => onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg), ctx.options);
       scalar = identity.isScalar(res) ? res : new Scalar.Scalar(res);
-    } catch (error81) {
-      const msg = error81 instanceof Error ? error81.message : String(error81);
+    } catch (error82) {
+      const msg = error82 instanceof Error ? error82.message : String(error82);
       onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg);
       scalar = new Scalar.Scalar(value);
     }
@@ -11729,11 +11729,11 @@ ${cb}` : comment;
           break;
         case "error": {
           const msg = token.source ? `${token.message}: ${JSON.stringify(token.source)}` : token.message;
-          const error81 = new errors5.YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", msg);
+          const error82 = new errors5.YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", msg);
           if (this.atDirectives || !this.doc)
-            this.errors.push(error81);
+            this.errors.push(error82);
           else
-            this.doc.errors.push(error81);
+            this.doc.errors.push(error82);
           break;
         }
         case "doc-end": {
@@ -13006,8 +13006,8 @@ var require_parser = __commonJS((exports) => {
     peek(n) {
       return this.stack[this.stack.length - n];
     }
-    *pop(error81) {
-      const token = error81 ?? this.stack.pop();
+    *pop(error82) {
+      const token = error82 ?? this.stack.pop();
       if (!token) {
         const message = "Tried to pop an empty stack";
         yield { type: "error", offset: this.offset, source: "", message };
@@ -28371,6 +28371,7 @@ __export(exports_external2, {
   int: () => int2,
   instanceof: () => _instanceof2,
   includes: () => _includes2,
+  hostname: () => hostname3,
   guid: () => guid4,
   gte: () => _gte2,
   gt: () => _gt2,
@@ -28533,6 +28534,7 @@ __export(exports_core4, {
   _toLowerCase: () => _toLowerCase2,
   _templateLiteral: () => _templateLiteral2,
   _symbol: () => _symbol2,
+  _superRefine: () => _superRefine,
   _success: () => _success2,
   _stringbool: () => _stringbool2,
   _stringFormat: () => _stringFormat2,
@@ -28618,6 +28620,7 @@ __export(exports_core4, {
   _coercedBigint: () => _coercedBigint2,
   _cidrv6: () => _cidrv62,
   _cidrv4: () => _cidrv42,
+  _check: () => _check,
   _catch: () => _catch3,
   _boolean: () => _boolean2,
   _bigint: () => _bigint2,
@@ -28795,6 +28798,7 @@ var exports_util2 = {};
 __export(exports_util2, {
   unwrapMessage: () => unwrapMessage2,
   stringifyPrimitive: () => stringifyPrimitive2,
+  shallowClone: () => shallowClone,
   required: () => required2,
   randomString: () => randomString2,
   propertyKeyTypes: () => propertyKeyTypes2,
@@ -28805,6 +28809,7 @@ __export(exports_util2, {
   partial: () => partial2,
   optionalKeys: () => optionalKeys2,
   omit: () => omit2,
+  objectClone: () => objectClone,
   numKeys: () => numKeys2,
   nullish: () => nullish3,
   normalizeParams: () => normalizeParams2,
@@ -28892,22 +28897,32 @@ function cleanRegex2(source) {
 }
 function floatSafeRemainder2(val, step) {
   const valDecCount = (val.toString().split(".")[1] || "").length;
-  const stepDecCount = (step.toString().split(".")[1] || "").length;
+  const stepString = step.toString();
+  let stepDecCount = (stepString.split(".")[1] || "").length;
+  if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
+    const match = stepString.match(/\d?e-(\d?)/);
+    if (match?.[1]) {
+      stepDecCount = Number.parseInt(match[1]);
+    }
+  }
   const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
   const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
   const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
   return valInt % stepInt / 10 ** decCount;
 }
+var EVALUATING = Symbol("evaluating");
 function defineLazy2(object2, key, getter) {
-  const set2 = false;
+  let value = undefined;
   Object.defineProperty(object2, key, {
     get() {
-      if (!set2) {
-        const value = getter();
-        object2[key] = value;
-        return value;
+      if (value === EVALUATING) {
+        return;
       }
-      throw new Error("cached value already set");
+      if (value === undefined) {
+        value = EVALUATING;
+        value = getter();
+      }
+      return value;
     },
     set(v) {
       Object.defineProperty(object2, key, {
@@ -28917,6 +28932,9 @@ function defineLazy2(object2, key, getter) {
     configurable: true
   });
 }
+function objectClone(obj) {
+  return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
+}
 function assignProp2(target, prop, value) {
   Object.defineProperty(target, prop, {
     value,
@@ -28993,6 +29011,11 @@ function isPlainObject2(o) {
   }
   return true;
 }
+function shallowClone(o) {
+  if (isPlainObject2(o))
+    return { ...o };
+  return o;
+}
 function numKeys2(data) {
   let keyCount = 0;
   for (const key in data) {
@@ -29548,6 +29571,7 @@ __export(exports_regexes2, {
   ipv6: () => ipv63,
   ipv4: () => ipv43,
   integer: () => integer2,
+  idnEmail: () => idnEmail,
   html5Email: () => html5Email2,
   hostname: () => hostname2,
   guid: () => guid3,
@@ -29590,6 +29614,7 @@ var email3 = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][
 var html5Email2 = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
 var rfc5322Email2 = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
 var unicodeEmail2 = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
+var idnEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
 var browserEmail2 = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
 var _emoji3 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
 function emoji3() {
@@ -29601,7 +29626,7 @@ var cidrv43 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5
 var cidrv63 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
 var base643 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
 var base64url3 = /^[A-Za-z0-9_-]*$/;
-var hostname2 = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
+var hostname2 = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
 var domain2 = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
 var e1643 = /^\+(?:[0-9]){6,14}[0-9]$/;
 var dateSource2 = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
@@ -29620,7 +29645,7 @@ function datetime3(args) {
   if (args.local)
     opts.push("");
   if (args.offset)
-    opts.push(`([+-]\\d{2}:\\d{2})`);
+    opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
   const timeRegex = `${time4}(?:${opts.join("|")})`;
   return new RegExp(`^${dateSource2}T(?:${timeRegex})$`);
 }
@@ -29749,6 +29774,7 @@ var $ZodCheckNumberFormat2 = /* @__PURE__ */ $constructor2("$ZodCheckNumberForma
           expected: origin,
           format: def.format,
           code: "invalid_type",
+          continue: false,
           input,
           inst
         });
@@ -30163,7 +30189,8 @@ var $ZodCheckMimeType2 = /* @__PURE__ */ $constructor2("$ZodCheckMimeType", (ins
       code: "invalid_value",
       values: def.mime,
       input: payload.value.type,
-      inst
+      inst,
+      continue: !def.abort
     });
   };
 });
@@ -30216,7 +30243,7 @@ class Doc2 {
 var version2 = {
   major: 4,
   minor: 0,
-  patch: 8
+  patch: 17
 };
 
 // ../../node_modules/zod/v4/core/schemas.js
@@ -30850,7 +30877,7 @@ var $ZodObject2 = /* @__PURE__ */ $constructor2("$ZodObject", (inst, def) => {
   const _normalized = cached2(() => {
     const keys = Object.keys(def.shape);
     for (const k of keys) {
-      if (!(def.shape[k] instanceof $ZodType2)) {
+      if (!def.shape[k]._zod.traits.has("$ZodType")) {
         throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
       }
     }
@@ -30997,7 +31024,7 @@ function handleUnionResults2(results, final, inst, ctx) {
     }
   }
   const nonaborted = results.filter((r) => !aborted2(r));
-  if (nonaborted.length > 0) {
+  if (nonaborted.length === 1) {
     final.value = nonaborted[0].value;
     return nonaborted[0];
   }
@@ -31026,7 +31053,12 @@ var $ZodUnion2 = /* @__PURE__ */ $constructor2("$ZodUnion", (inst, def) => {
     }
     return;
   });
+  const single = def.options.length === 1;
+  const first = def.options[0]._zod.run;
   inst._zod.parse = (payload, ctx) => {
+    if (single) {
+      return first(payload, ctx);
+    }
     let async = false;
     const results = [];
     for (const option of def.options) {
@@ -31107,6 +31139,7 @@ var $ZodDiscriminatedUnion2 = /* @__PURE__ */ $constructor2("$ZodDiscriminatedUn
       code: "invalid_union",
       errors: [],
       note: "No matching discriminator",
+      discriminator: def.discriminator,
       input,
       path: [def.discriminator],
       inst
@@ -31211,10 +31244,10 @@ var $ZodTuple2 = /* @__PURE__ */ $constructor2("$ZodTuple", (inst, def) => {
       const tooSmall = input.length < optStart - 1;
       if (tooBig || tooSmall) {
         payload.issues.push({
+          ...tooBig ? { code: "too_big", maximum: items.length } : { code: "too_small", minimum: items.length },
           input,
           inst,
-          origin: "array",
-          ...tooBig ? { code: "too_big", maximum: items.length } : { code: "too_small", minimum: items.length }
+          origin: "array"
         });
         return payload;
       }
@@ -31323,8 +31356,8 @@ var $ZodRecord2 = /* @__PURE__ */ $constructor2("$ZodRecord", (inst, def) => {
         }
         if (keyResult.issues.length) {
           payload.issues.push({
-            origin: "record",
             code: "invalid_key",
+            origin: "record",
             issues: keyResult.issues.map((iss) => finalizeIssue2(iss, ctx, config2())),
             input: key,
             path: [key],
@@ -31392,8 +31425,8 @@ function handleMapResult2(keyResult, valueResult, final, key, input, inst, ctx)
       final.issues.push(...prefixIssues2(key, keyResult.issues));
     } else {
       final.issues.push({
-        origin: "map",
         code: "invalid_key",
+        origin: "map",
         input,
         inst,
         issues: keyResult.issues.map((iss) => finalizeIssue2(iss, ctx, config2()))
@@ -31471,6 +31504,9 @@ var $ZodEnum2 = /* @__PURE__ */ $constructor2("$ZodEnum", (inst, def) => {
 });
 var $ZodLiteral2 = /* @__PURE__ */ $constructor2("$ZodLiteral", (inst, def) => {
   $ZodType2.init(inst, def);
+  if (def.values.length === 0) {
+    throw new Error("Cannot create literal schema with no valid values");
+  }
   inst._zod.values = new Set(def.values);
   inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex2(o) : o ? escapeRegex2(o.toString()) : String(o)).join("|")})$`);
   inst._zod.parse = (payload, _ctx) => {
@@ -31520,6 +31556,12 @@ var $ZodTransform2 = /* @__PURE__ */ $constructor2("$ZodTransform", (inst, def)
     return payload;
   };
 });
+function handleOptionalResult(result, input) {
+  if (result.issues.length && input === undefined) {
+    return { issues: [], value: undefined };
+  }
+  return result;
+}
 var $ZodOptional2 = /* @__PURE__ */ $constructor2("$ZodOptional", (inst, def) => {
   $ZodType2.init(inst, def);
   inst._zod.optin = "optional";
@@ -31533,7 +31575,10 @@ var $ZodOptional2 = /* @__PURE__ */ $constructor2("$ZodOptional", (inst, def) =>
   });
   inst._zod.parse = (payload, ctx) => {
     if (def.innerType._zod.optin === "optional") {
-      return def.innerType._zod.run(payload, ctx);
+      const result = def.innerType._zod.run(payload, ctx);
+      if (result instanceof Promise)
+        return result.then((r) => handleOptionalResult(r, payload.value));
+      return handleOptionalResult(result, payload.value);
     }
     if (payload.value === undefined) {
       return payload;
@@ -31724,7 +31769,7 @@ var $ZodTemplateLiteral2 = /* @__PURE__ */ $constructor2("$ZodTemplateLiteral",
   $ZodType2.init(inst, def);
   const regexParts = [];
   for (const part of def.parts) {
-    if (part instanceof $ZodType2) {
+    if (typeof part === "object" && part !== null) {
       if (!part._zod.pattern) {
         throw new Error(`Invalid template literal part, no pattern found: ${[...part._zod.traits].shift()}`);
       }
@@ -31776,8 +31821,8 @@ var $ZodLazy2 = /* @__PURE__ */ $constructor2("$ZodLazy", (inst, def) => {
   defineLazy2(inst._zod, "innerType", () => def.getter());
   defineLazy2(inst._zod, "pattern", () => inst._zod.innerType._zod.pattern);
   defineLazy2(inst._zod, "propValues", () => inst._zod.innerType._zod.propValues);
-  defineLazy2(inst._zod, "optin", () => inst._zod.innerType._zod.optin);
-  defineLazy2(inst._zod, "optout", () => inst._zod.innerType._zod.optout);
+  defineLazy2(inst._zod, "optin", () => inst._zod.innerType._zod.optin ?? undefined);
+  defineLazy2(inst._zod, "optout", () => inst._zod.innerType._zod.optout ?? undefined);
   inst._zod.parse = (payload, ctx) => {
     const inner = inst._zod.innerType;
     return inner._zod.run(payload, ctx);
@@ -31818,6 +31863,7 @@ var exports_locales2 = {};
 __export(exports_locales2, {
   zhTW: () => zh_TW_default2,
   zhCN: () => zh_CN_default2,
+  yo: () => yo_default,
   vi: () => vi_default2,
   ur: () => ur_default2,
   ua: () => ua_default2,
@@ -36780,6 +36826,121 @@ function zh_TW_default2() {
     localeError: error80()
   };
 }
+// ../../node_modules/zod/v4/locales/yo.js
+var error81 = () => {
+  const Sizable = {
+    string: { unit: "àmi", verb: "ní" },
+    file: { unit: "bytes", verb: "ní" },
+    array: { unit: "nkan", verb: "ní" },
+    set: { unit: "nkan", verb: "ní" }
+  };
+  function getSizing(origin) {
+    return Sizable[origin] ?? null;
+  }
+  const parsedType8 = (data) => {
+    const t = typeof data;
+    switch (t) {
+      case "number": {
+        return Number.isNaN(data) ? "NaN" : "nọ́mbà";
+      }
+      case "object": {
+        if (Array.isArray(data)) {
+          return "akopọ";
+        }
+        if (data === null) {
+          return "null";
+        }
+        if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
+          return data.constructor.name;
+        }
+      }
+    }
+    return t;
+  };
+  const Nouns = {
+    regex: "ẹ̀rọ ìbáwọlé",
+    email: "àdírẹ́sì ìmẹ́lì",
+    url: "URL",
+    emoji: "emoji",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "àkókò ISO",
+    date: "ọjọ́ ISO",
+    time: "àkókò ISO",
+    duration: "àkókò tó pé ISO",
+    ipv4: "àdírẹ́sì IPv4",
+    ipv6: "àdírẹ́sì IPv6",
+    cidrv4: "àgbègbè IPv4",
+    cidrv6: "àgbègbè IPv6",
+    base64: "ọ̀rọ̀ tí a kọ́ ní base64",
+    base64url: "ọ̀rọ̀ base64url",
+    json_string: "ọ̀rọ̀ JSON",
+    e164: "nọ́mbà E.164",
+    jwt: "JWT",
+    template_literal: "ẹ̀rọ ìbáwọlé"
+  };
+  return (issue3) => {
+    switch (issue3.code) {
+      case "invalid_type":
+        return `Ìbáwọlé aṣìṣe: a ní láti fi ${issue3.expected}, àmọ̀ a rí ${parsedType8(issue3.input)}`;
+      case "invalid_value":
+        if (issue3.values.length === 1)
+          return `Ìbáwọlé aṣìṣe: a ní láti fi ${stringifyPrimitive2(issue3.values[0])}`;
+        return `Àṣàyàn aṣìṣe: yan ọ̀kan lára ${joinValues2(issue3.values, "|")}`;
+      case "too_big": {
+        const adj = issue3.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue3.origin);
+        if (sizing)
+          return `Tó pọ̀ jù: a ní láti jẹ́ pé ${issue3.origin ?? "iye"} ${sizing.verb} ${adj}${issue3.maximum} ${sizing.unit}`;
+        return `Tó pọ̀ jù: a ní láti jẹ́ ${adj}${issue3.maximum}`;
+      }
+      case "too_small": {
+        const adj = issue3.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue3.origin);
+        if (sizing)
+          return `Kéré ju: a ní láti jẹ́ pé ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum} ${sizing.unit}`;
+        return `Kéré ju: a ní láti jẹ́ ${adj}${issue3.minimum}`;
+      }
+      case "invalid_format": {
+        const _issue = issue3;
+        if (_issue.format === "starts_with")
+          return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ bẹ̀rẹ̀ pẹ̀lú "${_issue.prefix}"`;
+        if (_issue.format === "ends_with")
+          return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ parí pẹ̀lú "${_issue.suffix}"`;
+        if (_issue.format === "includes")
+          return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ ní "${_issue.includes}"`;
+        if (_issue.format === "regex")
+          return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ bá àpẹẹrẹ mu ${_issue.pattern}`;
+        return `Aṣìṣe: ${Nouns[_issue.format] ?? issue3.format}`;
+      }
+      case "not_multiple_of":
+        return `Nọ́mbà aṣìṣe: gbọ́dọ̀ jẹ́ èyà pípín ti ${issue3.divisor}`;
+      case "unrecognized_keys":
+        return `Bọtìnì àìmọ̀: ${joinValues2(issue3.keys, ", ")}`;
+      case "invalid_key":
+        return `Bọtìnì aṣìṣe nínú ${issue3.origin}`;
+      case "invalid_union":
+        return "Ìbáwọlé aṣìṣe";
+      case "invalid_element":
+        return `Iye aṣìṣe nínú ${issue3.origin}`;
+      default:
+        return "Ìbáwọlé aṣìṣe";
+    }
+  };
+};
+function yo_default() {
+  return {
+    localeError: error81()
+  };
+}
 // ../../node_modules/zod/v4/core/registries.js
 var $output2 = Symbol("ZodOutput");
 var $input2 = Symbol("ZodInput");
@@ -37539,7 +37700,7 @@ function _default3(Class3, innerType, defaultValue) {
     type: "default",
     innerType,
     get defaultValue() {
-      return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+      return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue);
     }
   });
 }
@@ -37615,6 +37776,34 @@ function _refine2(Class3, fn, _params) {
   });
   return schema;
 }
+function _superRefine(fn) {
+  const ch = _check((payload) => {
+    payload.addIssue = (issue3) => {
+      if (typeof issue3 === "string") {
+        payload.issues.push(issue2(issue3, payload.value, ch._zod.def));
+      } else {
+        const _issue = issue3;
+        if (_issue.fatal)
+          _issue.continue = false;
+        _issue.code ?? (_issue.code = "custom");
+        _issue.input ?? (_issue.input = payload.value);
+        _issue.inst ?? (_issue.inst = ch);
+        _issue.continue ?? (_issue.continue = !ch._zod.def.abort);
+        payload.issues.push(issue2(_issue));
+      }
+    };
+    return fn(payload.value, payload);
+  });
+  return ch;
+}
+function _check(fn, params) {
+  const ch = new $ZodCheck2({
+    check: "custom",
+    ...normalizeParams2(params)
+  });
+  ch._zod.check = fn;
+  return ch;
+}
 function _stringbool2(Classes, _params) {
   const params = normalizeParams2(_params);
   let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
@@ -37645,7 +37834,8 @@ function _stringbool2(Classes, _params) {
           expected: "stringbool",
           values: [...truthySet, ...falsySet],
           input: payload.value,
-          inst: tx
+          inst: tx,
+          continue: false
         });
         return {};
       }
@@ -37826,7 +38016,7 @@ class JSONSchemaGenerator2 {
               else if (regexes.length > 1) {
                 result.schema.allOf = [
                   ...regexes.map((regex) => ({
-                    ...this.target === "draft-7" ? { type: "string" } : {},
+                    ...this.target === "draft-7" || this.target === "draft-4" ? { type: "string" } : {},
                     pattern: regex.source
                   }))
                 ];
@@ -37841,22 +38031,34 @@ class JSONSchemaGenerator2 {
               json2.type = "integer";
             else
               json2.type = "number";
-            if (typeof exclusiveMinimum === "number")
-              json2.exclusiveMinimum = exclusiveMinimum;
+            if (typeof exclusiveMinimum === "number") {
+              if (this.target === "draft-4") {
+                json2.minimum = exclusiveMinimum;
+                json2.exclusiveMinimum = true;
+              } else {
+                json2.exclusiveMinimum = exclusiveMinimum;
+              }
+            }
             if (typeof minimum === "number") {
               json2.minimum = minimum;
-              if (typeof exclusiveMinimum === "number") {
+              if (typeof exclusiveMinimum === "number" && this.target !== "draft-4") {
                 if (exclusiveMinimum >= minimum)
                   delete json2.minimum;
                 else
                   delete json2.exclusiveMinimum;
               }
             }
-            if (typeof exclusiveMaximum === "number")
-              json2.exclusiveMaximum = exclusiveMaximum;
+            if (typeof exclusiveMaximum === "number") {
+              if (this.target === "draft-4") {
+                json2.maximum = exclusiveMaximum;
+                json2.exclusiveMaximum = true;
+              } else {
+                json2.exclusiveMaximum = exclusiveMaximum;
+              }
+            }
             if (typeof maximum === "number") {
               json2.maximum = maximum;
-              if (typeof exclusiveMaximum === "number") {
+              if (typeof exclusiveMaximum === "number" && this.target !== "draft-4") {
                 if (exclusiveMaximum <= maximum)
                   delete json2.maximum;
                 else
@@ -38025,7 +38227,12 @@ class JSONSchemaGenerator2 {
           case "record": {
             const json2 = _json;
             json2.type = "object";
-            json2.propertyNames = this.process(def.keyType, { ...params, path: [...params.path, "propertyNames"] });
+            if (this.target !== "draft-4") {
+              json2.propertyNames = this.process(def.keyType, {
+                ...params,
+                path: [...params.path, "propertyNames"]
+              });
+            }
             json2.additionalProperties = this.process(def.valueType, {
               ...params,
               path: [...params.path, "additionalProperties"]
@@ -38075,7 +38282,11 @@ class JSONSchemaGenerator2 {
             if (vals.length === 0) {} else if (vals.length === 1) {
               const val = vals[0];
               json2.type = val === null ? "null" : typeof val;
-              json2.const = val;
+              if (this.target === "draft-4") {
+                json2.enum = [val];
+              } else {
+                json2.const = val;
+              }
             } else {
               if (vals.every((v) => typeof v === "number"))
                 json2.type = "number";
@@ -38321,7 +38532,7 @@ class JSONSchemaGenerator2 {
       if (ref) {
         flattenRef(ref, params2);
         const refSchema = this.seen.get(ref).schema;
-        if (refSchema.$ref && params2.target === "draft-7") {
+        if (refSchema.$ref && (params2.target === "draft-7" || params2.target === "draft-4")) {
           schema2.allOf = schema2.allOf ?? [];
           schema2.allOf.push(refSchema);
         } else {
@@ -38344,6 +38555,8 @@ class JSONSchemaGenerator2 {
       result.$schema = "https://json-schema.org/draft/2020-12/schema";
     } else if (this.target === "draft-7") {
       result.$schema = "http://json-schema.org/draft-07/schema#";
+    } else if (this.target === "draft-4") {
+      result.$schema = "http://json-schema.org/draft-04/schema#";
     } else {
       console.warn(`Invalid target: ${this.target}`);
     }
@@ -38864,6 +39077,9 @@ var ZodCustomStringFormat2 = /* @__PURE__ */ $constructor2("ZodCustomStringForma
 function stringFormat2(format, fnOrRegex, _params = {}) {
   return _stringFormat2(ZodCustomStringFormat2, format, fnOrRegex, _params);
 }
+function hostname3(_params) {
+  return _stringFormat2(ZodCustomStringFormat2, "hostname", exports_regexes2.hostname, _params);
+}
 var ZodNumber2 = /* @__PURE__ */ $constructor2("ZodNumber", (inst, def) => {
   $ZodNumber2.init(inst, def);
   ZodType2.init(inst, def);
@@ -39028,7 +39244,7 @@ function array2(element, params) {
 }
 function keyof2(schema) {
   const shape = schema._zod.def.shape;
-  return literal2(Object.keys(shape));
+  return _enum4(Object.keys(shape));
 }
 var ZodObject2 = /* @__PURE__ */ $constructor2("ZodObject", (inst, def) => {
   $ZodObject2.init(inst, def);
@@ -39053,7 +39269,7 @@ function object2(shape, params) {
   const def = {
     type: "object",
     get shape() {
-      exports_util2.assignProp(this, "shape", { ...shape });
+      exports_util2.assignProp(this, "shape", shape ? exports_util2.objectClone(shape) : {});
       return this.shape;
     },
     ...exports_util2.normalizeParams(params)
@@ -39064,7 +39280,7 @@ function strictObject2(shape, params) {
   return new ZodObject2({
     type: "object",
     get shape() {
-      exports_util2.assignProp(this, "shape", { ...shape });
+      exports_util2.assignProp(this, "shape", exports_util2.objectClone(shape));
       return this.shape;
     },
     catchall: never2(),
@@ -39075,7 +39291,7 @@ function looseObject2(shape, params) {
   return new ZodObject2({
     type: "object",
     get shape() {
-      exports_util2.assignProp(this, "shape", { ...shape });
+      exports_util2.assignProp(this, "shape", exports_util2.objectClone(shape));
       return this.shape;
     },
     catchall: unknown2(),
@@ -39341,7 +39557,7 @@ function _default4(innerType, defaultValue) {
     type: "default",
     innerType,
     get defaultValue() {
-      return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+      return typeof defaultValue === "function" ? defaultValue() : exports_util2.shallowClone(defaultValue);
     }
   });
 }
@@ -39355,7 +39571,7 @@ function prefault2(innerType, defaultValue) {
     type: "prefault",
     innerType,
     get defaultValue() {
-      return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+      return typeof defaultValue === "function" ? defaultValue() : exports_util2.shallowClone(defaultValue);
     }
   });
 }
@@ -39477,24 +39693,7 @@ function refine2(fn, _params = {}) {
   return _refine2(ZodCustom2, fn, _params);
 }
 function superRefine2(fn) {
-  const ch = check2((payload) => {
-    payload.addIssue = (issue3) => {
-      if (typeof issue3 === "string") {
-        payload.issues.push(exports_util2.issue(issue3, payload.value, ch._zod.def));
-      } else {
-        const _issue = issue3;
-        if (_issue.fatal)
-          _issue.continue = false;
-        _issue.code ?? (_issue.code = "custom");
-        _issue.input ?? (_issue.input = payload.value);
-        _issue.inst ?? (_issue.inst = ch);
-        _issue.continue ?? (_issue.continue = !ch._zod.def.abort);
-        payload.issues.push(exports_util2.issue(_issue));
-      }
-    };
-    return fn(payload.value, payload);
-  });
-  return ch;
+  return _superRefine(fn);
 }
 function _instanceof2(cls, params = {
   error: `Input not instance of ${cls.name}`
@@ -39828,8 +40027,8 @@ class ZodError3 extends Error {
       return issue3.message;
     };
     const fieldErrors = { _errors: [] };
-    const processError = (error81) => {
-      for (const issue3 of error81.issues) {
+    const processError = (error82) => {
+      for (const issue3 of error82.issues) {
         if (issue3.code === "invalid_union") {
           issue3.unionErrors.map(processError);
         } else if (issue3.code === "invalid_return_type") {
@@ -39892,8 +40091,8 @@ class ZodError3 extends Error {
   }
 }
 ZodError3.create = (issues) => {
-  const error81 = new ZodError3(issues);
-  return error81;
+  const error82 = new ZodError3(issues);
+  return error82;
 };
 
 // ../../node_modules/zod-to-json-schema/node_modules/zod/v3/locales/en.js
@@ -40150,8 +40349,8 @@ var handleResult = (ctx, result) => {
       get error() {
         if (this._error)
           return this._error;
-        const error81 = new ZodError3(ctx.common.issues);
-        this._error = error81;
+        const error82 = new ZodError3(ctx.common.issues);
+        this._error = error82;
         return this._error;
       }
     };
@@ -42733,25 +42932,25 @@ class ZodFunction extends ZodType3 {
       });
       return INVALID;
     }
-    function makeArgsIssue(args, error81) {
+    function makeArgsIssue(args, error82) {
       return makeIssue({
         data: args,
         path: ctx.path,
         errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap3(), en_default3].filter((x) => !!x),
         issueData: {
           code: ZodIssueCode3.invalid_arguments,
-          argumentsError: error81
+          argumentsError: error82
         }
       });
     }
-    function makeReturnsIssue(returns, error81) {
+    function makeReturnsIssue(returns, error82) {
       return makeIssue({
         data: returns,
         path: ctx.path,
         errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap3(), en_default3].filter((x) => !!x),
         issueData: {
           code: ZodIssueCode3.invalid_return_type,
-          returnTypeError: error81
+          returnTypeError: error82
         }
       });
     }
@@ -42760,15 +42959,15 @@ class ZodFunction extends ZodType3 {
     if (this._def.returns instanceof ZodPromise3) {
       const me = this;
       return OK(async function(...args) {
-        const error81 = new ZodError3([]);
+        const error82 = new ZodError3([]);
         const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
-          error81.addIssue(makeArgsIssue(args, e));
-          throw error81;
+          error82.addIssue(makeArgsIssue(args, e));
+          throw error82;
         });
         const result = await Reflect.apply(fn, this, parsedArgs);
         const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
-          error81.addIssue(makeReturnsIssue(result, e));
-          throw error81;
+          error82.addIssue(makeReturnsIssue(result, e));
+          throw error82;
         });
         return parsedReturns;
       });
@@ -44631,8 +44830,33 @@ function combineHeaders(...headers) {
     ...currentHeaders != null ? currentHeaders : {}
   }), {});
 }
-async function delay(delayInMs) {
-  return delayInMs == null ? Promise.resolve() : new Promise((resolve2) => setTimeout(resolve2, delayInMs));
+async function delay(delayInMs, options) {
+  if (delayInMs == null) {
+    return Promise.resolve();
+  }
+  const signal = options == null ? undefined : options.abortSignal;
+  return new Promise((resolve2, reject) => {
+    if (signal == null ? undefined : signal.aborted) {
+      reject(createAbortError());
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      cleanup();
+      resolve2();
+    }, delayInMs);
+    const cleanup = () => {
+      clearTimeout(timeoutId);
+      signal == null || signal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(createAbortError());
+    };
+    signal == null || signal.addEventListener("abort", onAbort);
+  });
+}
+function createAbortError() {
+  return new DOMException("Delay was aborted", "AbortError");
 }
 function extractResponseHeaders(response) {
   return Object.fromEntries([...response.headers]);
@@ -44663,32 +44887,32 @@ var createIdGenerator = ({
   return () => `${prefix}${separator}${generator()}`;
 };
 var generateId = createIdGenerator();
-function getErrorMessage2(error81) {
-  if (error81 == null) {
+function getErrorMessage2(error82) {
+  if (error82 == null) {
     return "unknown error";
   }
-  if (typeof error81 === "string") {
-    return error81;
+  if (typeof error82 === "string") {
+    return error82;
   }
-  if (error81 instanceof Error) {
-    return error81.message;
+  if (error82 instanceof Error) {
+    return error82.message;
   }
-  return JSON.stringify(error81);
+  return JSON.stringify(error82);
 }
-function isAbortError(error81) {
-  return error81 instanceof Error && (error81.name === "AbortError" || error81.name === "ResponseAborted" || error81.name === "TimeoutError");
+function isAbortError(error82) {
+  return (error82 instanceof Error || error82 instanceof DOMException) && (error82.name === "AbortError" || error82.name === "ResponseAborted" || error82.name === "TimeoutError");
 }
 var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
 function handleFetchError({
-  error: error81,
+  error: error82,
   url: url3,
   requestBodyValues
 }) {
-  if (isAbortError(error81)) {
-    return error81;
+  if (isAbortError(error82)) {
+    return error82;
   }
-  if (error81 instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error81.message.toLowerCase())) {
-    const cause = error81.cause;
+  if (error82 instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error82.message.toLowerCase())) {
+    const cause = error82.cause;
     if (cause != null) {
       return new APICallError({
         message: `Cannot connect to API: ${cause.message}`,
@@ -44699,7 +44923,7 @@ function handleFetchError({
       });
     }
   }
-  return error81;
+  return error82;
 }
 function removeUndefinedEntries(record4) {
   return Object.fromEntries(Object.entries(record4).filter(([_key, value]) => value != null));
@@ -44728,13 +44952,13 @@ var getFromApi = async ({
           url: url3,
           requestBodyValues: {}
         });
-      } catch (error81) {
-        if (isAbortError(error81) || APICallError.isInstance(error81)) {
-          throw error81;
+      } catch (error82) {
+        if (isAbortError(error82) || APICallError.isInstance(error82)) {
+          throw error82;
         }
         throw new APICallError({
           message: "Failed to process error response",
-          cause: error81,
+          cause: error82,
           statusCode: response.status,
           url: url3,
           responseHeaders,
@@ -44749,23 +44973,23 @@ var getFromApi = async ({
         url: url3,
         requestBodyValues: {}
       });
-    } catch (error81) {
-      if (error81 instanceof Error) {
-        if (isAbortError(error81) || APICallError.isInstance(error81)) {
-          throw error81;
+    } catch (error82) {
+      if (error82 instanceof Error) {
+        if (isAbortError(error82) || APICallError.isInstance(error82)) {
+          throw error82;
         }
       }
       throw new APICallError({
         message: "Failed to process successful response",
-        cause: error81,
+        cause: error82,
         statusCode: response.status,
         url: url3,
         responseHeaders,
         requestBodyValues: {}
       });
     }
-  } catch (error81) {
-    throw handleFetchError({ error: error81, url: url3, requestBodyValues: {} });
+  } catch (error82) {
+    throw handleFetchError({ error: error82, url: url3, requestBodyValues: {} });
   }
 };
 function isUrlSupported({
@@ -44889,10 +45113,10 @@ async function safeValidateTypes({
       error: TypeValidationError.wrap({ value, cause: result.error }),
       rawValue: value
     };
-  } catch (error81) {
+  } catch (error82) {
     return {
       success: false,
-      error: TypeValidationError.wrap({ value, cause: error81 }),
+      error: TypeValidationError.wrap({ value, cause: error82 }),
       rawValue: value
     };
   }
@@ -44907,11 +45131,11 @@ async function parseJSON({
       return value;
     }
     return validateTypes({ value, schema });
-  } catch (error81) {
-    if (JSONParseError.isInstance(error81) || TypeValidationError.isInstance(error81)) {
-      throw error81;
+  } catch (error82) {
+    if (JSONParseError.isInstance(error82) || TypeValidationError.isInstance(error82)) {
+      throw error82;
     }
-    throw new JSONParseError({ text, cause: error81 });
+    throw new JSONParseError({ text, cause: error82 });
   }
 }
 async function safeParseJSON({
@@ -44924,10 +45148,10 @@ async function safeParseJSON({
       return { success: true, value, rawValue: value };
     }
     return await safeValidateTypes({ value, schema });
-  } catch (error81) {
+  } catch (error82) {
     return {
       success: false,
-      error: JSONParseError.isInstance(error81) ? error81 : new JSONParseError({ text, cause: error81 }),
+      error: JSONParseError.isInstance(error82) ? error82 : new JSONParseError({ text, cause: error82 }),
       rawValue: undefined
     };
   }
@@ -44994,13 +45218,13 @@ var postToApi = async ({
           url: url3,
           requestBodyValues: body.values
         });
-      } catch (error81) {
-        if (isAbortError(error81) || APICallError.isInstance(error81)) {
-          throw error81;
+      } catch (error82) {
+        if (isAbortError(error82) || APICallError.isInstance(error82)) {
+          throw error82;
         }
         throw new APICallError({
           message: "Failed to process error response",
-          cause: error81,
+          cause: error82,
           statusCode: response.status,
           url: url3,
           responseHeaders,
@@ -45015,23 +45239,23 @@ var postToApi = async ({
         url: url3,
         requestBodyValues: body.values
       });
-    } catch (error81) {
-      if (error81 instanceof Error) {
-        if (isAbortError(error81) || APICallError.isInstance(error81)) {
-          throw error81;
+    } catch (error82) {
+      if (error82 instanceof Error) {
+        if (isAbortError(error82) || APICallError.isInstance(error82)) {
+          throw error82;
         }
       }
       throw new APICallError({
         message: "Failed to process successful response",
-        cause: error81,
+        cause: error82,
         statusCode: response.status,
         url: url3,
         responseHeaders,
         requestBodyValues: body.values
       });
     }
-  } catch (error81) {
-    throw handleFetchError({ error: error81, url: url3, requestBodyValues: body.values });
+  } catch (error82) {
+    throw handleFetchError({ error: error82, url: url3, requestBodyValues: body.values });
   }
 };
 async function resolve(value) {
@@ -45223,11 +45447,11 @@ var GatewayError = class _GatewayError extends (_b = Error, _a15 = symbol17, _b)
     this.statusCode = statusCode;
     this.cause = cause;
   }
-  static isInstance(error81) {
-    return _GatewayError.hasMarker(error81);
+  static isInstance(error82) {
+    return _GatewayError.hasMarker(error82);
   }
-  static hasMarker(error81) {
-    return typeof error81 === "object" && error81 !== null && symbol17 in error81 && error81[symbol17] === true;
+  static hasMarker(error82) {
+    return typeof error82 === "object" && error82 !== null && symbol17 in error82 && error82[symbol17] === true;
   }
 };
 var name14 = "GatewayAuthenticationError";
@@ -45246,8 +45470,8 @@ var GatewayAuthenticationError = class _GatewayAuthenticationError extends (_b2
     this.name = name14;
     this.type = "authentication_error";
   }
-  static isInstance(error81) {
-    return GatewayError.hasMarker(error81) && symbol23 in error81;
+  static isInstance(error82) {
+    return GatewayError.hasMarker(error82) && symbol23 in error82;
   }
   static createContextualError({
     apiKeyProvided,
@@ -45311,8 +45535,8 @@ var GatewayInvalidRequestError = class extends (_b3 = GatewayError, _a32 = symbo
     this.name = name22;
     this.type = "invalid_request_error";
   }
-  static isInstance(error81) {
-    return GatewayError.hasMarker(error81) && symbol32 in error81;
+  static isInstance(error82) {
+    return GatewayError.hasMarker(error82) && symbol32 in error82;
   }
 };
 var name32 = "GatewayRateLimitError";
@@ -45331,8 +45555,8 @@ var GatewayRateLimitError = class extends (_b4 = GatewayError, _a42 = symbol42,
     this.name = name32;
     this.type = "rate_limit_exceeded";
   }
-  static isInstance(error81) {
-    return GatewayError.hasMarker(error81) && symbol42 in error81;
+  static isInstance(error82) {
+    return GatewayError.hasMarker(error82) && symbol42 in error82;
   }
 };
 var name42 = "GatewayModelNotFoundError";
@@ -45356,8 +45580,8 @@ var GatewayModelNotFoundError = class extends (_b5 = GatewayError, _a52 = symbol
     this.type = "model_not_found";
     this.modelId = modelId;
   }
-  static isInstance(error81) {
-    return GatewayError.hasMarker(error81) && symbol52 in error81;
+  static isInstance(error82) {
+    return GatewayError.hasMarker(error82) && symbol52 in error82;
   }
 };
 var name52 = "GatewayInternalServerError";
@@ -45376,8 +45600,8 @@ var GatewayInternalServerError = class extends (_b6 = GatewayError, _a62 = symbo
     this.name = name52;
     this.type = "internal_server_error";
   }
-  static isInstance(error81) {
-    return GatewayError.hasMarker(error81) && symbol62 in error81;
+  static isInstance(error82) {
+    return GatewayError.hasMarker(error82) && symbol62 in error82;
   }
 };
 var name62 = "GatewayResponseError";
@@ -45400,8 +45624,8 @@ var GatewayResponseError = class extends (_b7 = GatewayError, _a72 = symbol72, _
     this.response = response;
     this.validationError = validationError;
   }
-  static isInstance(error81) {
-    return GatewayError.hasMarker(error81) && symbol72 in error81;
+  static isInstance(error82) {
+    return GatewayError.hasMarker(error82) && symbol72 in error82;
   }
 };
 function createGatewayErrorFromResponse({
@@ -45459,42 +45683,42 @@ var gatewayErrorResponseSchema = exports_external2.object({
     code: exports_external2.union([exports_external2.string(), exports_external2.number()]).nullish()
   })
 });
-function asGatewayError(error81, authMethod) {
+function asGatewayError(error82, authMethod) {
   var _a82;
-  if (GatewayError.isInstance(error81)) {
-    return error81;
+  if (GatewayError.isInstance(error82)) {
+    return error82;
   }
-  if (APICallError.isInstance(error81)) {
+  if (APICallError.isInstance(error82)) {
     return createGatewayErrorFromResponse({
-      response: extractApiCallResponse(error81),
-      statusCode: (_a82 = error81.statusCode) != null ? _a82 : 500,
+      response: extractApiCallResponse(error82),
+      statusCode: (_a82 = error82.statusCode) != null ? _a82 : 500,
       defaultMessage: "Gateway request failed",
-      cause: error81,
+      cause: error82,
       authMethod
     });
   }
   return createGatewayErrorFromResponse({
     response: {},
     statusCode: 500,
-    defaultMessage: error81 instanceof Error ? `Gateway request failed: ${error81.message}` : "Unknown Gateway error",
-    cause: error81,
+    defaultMessage: error82 instanceof Error ? `Gateway request failed: ${error82.message}` : "Unknown Gateway error",
+    cause: error82,
     authMethod
   });
 }
-function extractApiCallResponse(error81) {
-  if (error81.data !== undefined) {
-    return error81.data;
+function extractApiCallResponse(error82) {
+  if (error82.data !== undefined) {
+    return error82.data;
   }
-  if (error81.responseBody != null) {
+  if (error82.responseBody != null) {
     try {
-      return JSON.parse(error81.responseBody);
+      return JSON.parse(error82.responseBody);
     } catch (e) {
-      return error81.responseBody;
+      return error82.responseBody;
     }
   }
   return {};
 }
-var GATEWAY_AUTH_METHOD_HEADER = "x-ai-gateway-auth-method";
+var GATEWAY_AUTH_METHOD_HEADER = "ai-gateway-auth-method";
 function parseAuthMethod(headers) {
   const result = gatewayAuthMethodSchema.safeParse(headers[GATEWAY_AUTH_METHOD_HEADER]);
   return result.success ? result.data : undefined;
@@ -45520,8 +45744,8 @@ var GatewayFetchMetadata = class {
         fetch: this.config.fetch
       });
       return value;
-    } catch (error81) {
-      throw asGatewayError(error81);
+    } catch (error82) {
+      throw asGatewayError(error82);
     }
   }
 };
@@ -45554,8 +45778,16 @@ var GatewayLanguageModel = class {
   get provider() {
     return this.config.provider;
   }
+  async getArgs(options) {
+    const { abortSignal: _abortSignal, ...optionsWithoutSignal } = options;
+    return {
+      args: this.maybeEncodeFileParts(optionsWithoutSignal),
+      warnings: []
+    };
+  }
   async doGenerate(options) {
-    const { abortSignal, ...body } = options;
+    const { args, warnings } = await this.getArgs(options);
+    const { abortSignal } = options;
     const resolvedHeaders = await resolve(this.config.headers());
     try {
       const {
@@ -45565,7 +45797,7 @@ var GatewayLanguageModel = class {
       } = await postJsonToApi({
         url: this.getUrl(),
         headers: combineHeaders(resolvedHeaders, options.headers, this.getModelConfigHeaders(this.modelId, false), await resolve(this.config.o11yHeaders)),
-        body: this.maybeEncodeFileParts(body),
+        body: args,
         successfulResponseHandler: createJsonResponseHandler(exports_external2.any()),
         failedResponseHandler: createJsonErrorResponseHandler({
           errorSchema: exports_external2.any(),
@@ -45576,22 +45808,23 @@ var GatewayLanguageModel = class {
       });
       return {
         ...responseBody,
-        request: { body },
+        request: { body: args },
         response: { headers: responseHeaders, body: rawResponse },
-        warnings: []
+        warnings
       };
-    } catch (error81) {
-      throw asGatewayError(error81, parseAuthMethod(resolvedHeaders));
+    } catch (error82) {
+      throw asGatewayError(error82, parseAuthMethod(resolvedHeaders));
     }
   }
   async doStream(options) {
-    const { abortSignal, ...body } = options;
+    const { args, warnings } = await this.getArgs(options);
+    const { abortSignal } = options;
     const resolvedHeaders = await resolve(this.config.headers());
     try {
       const { value: response, responseHeaders } = await postJsonToApi({
         url: this.getUrl(),
         headers: combineHeaders(resolvedHeaders, options.headers, this.getModelConfigHeaders(this.modelId, true), await resolve(this.config.o11yHeaders)),
-        body: this.maybeEncodeFileParts(body),
+        body: args,
         successfulResponseHandler: createEventSourceResponseHandler(exports_external2.any()),
         failedResponseHandler: createJsonErrorResponseHandler({
           errorSchema: exports_external2.any(),
@@ -45602,6 +45835,11 @@ var GatewayLanguageModel = class {
       });
       return {
         stream: response.pipeThrough(new TransformStream({
+          start(controller) {
+            if (warnings.length > 0) {
+              controller.enqueue({ type: "stream-start", warnings });
+            }
+          },
           transform(chunk, controller) {
             if (chunk.success) {
               const streamPart = chunk.value;
@@ -45617,11 +45855,11 @@ var GatewayLanguageModel = class {
             }
           }
         })),
-        request: { body },
+        request: { body: args },
         response: { headers: responseHeaders }
       };
-    } catch (error81) {
-      throw asGatewayError(error81, parseAuthMethod(resolvedHeaders));
+    } catch (error82) {
+      throw asGatewayError(error82, parseAuthMethod(resolvedHeaders));
     }
   }
   isFilePart(part) {
@@ -45653,6 +45891,70 @@ var GatewayLanguageModel = class {
     };
   }
 };
+var GatewayEmbeddingModel = class {
+  constructor(modelId, config3) {
+    this.modelId = modelId;
+    this.config = config3;
+    this.specificationVersion = "v2";
+    this.maxEmbeddingsPerCall = 2048;
+    this.supportsParallelCalls = true;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doEmbed({
+    values,
+    headers,
+    abortSignal,
+    providerOptions
+  }) {
+    var _a82;
+    const resolvedHeaders = await resolve(this.config.headers());
+    try {
+      const {
+        responseHeaders,
+        value: responseBody,
+        rawValue
+      } = await postJsonToApi({
+        url: this.getUrl(),
+        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve(this.config.o11yHeaders)),
+        body: {
+          input: values.length === 1 ? values[0] : values,
+          ...providerOptions != null ? providerOptions : {}
+        },
+        successfulResponseHandler: createJsonResponseHandler(gatewayEmbeddingResponseSchema),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: exports_external2.any(),
+          errorToMessage: (data) => data
+        }),
+        ...abortSignal && { abortSignal },
+        fetch: this.config.fetch
+      });
+      return {
+        embeddings: responseBody.embeddings,
+        usage: (_a82 = responseBody.usage) != null ? _a82 : undefined,
+        providerMetadata: responseBody.providerMetadata,
+        response: { headers: responseHeaders, body: rawValue }
+      };
+    } catch (error82) {
+      throw asGatewayError(error82, parseAuthMethod(resolvedHeaders));
+    }
+  }
+  getUrl() {
+    return `${this.config.baseURL}/embedding-model`;
+  }
+  getModelConfigHeaders() {
+    return {
+      "ai-embedding-model-specification-version": "2",
+      "ai-model-id": this.modelId
+    };
+  }
+};
+var gatewayEmbeddingResponseSchema = exports_external2.object({
+  embeddings: exports_external2.array(exports_external2.array(exports_external2.number())),
+  usage: exports_external2.object({ tokens: exports_external2.number() }).nullish(),
+  providerMetadata: exports_external2.record(exports_external2.string(), exports_external2.record(exports_external2.string(), exports_external2.unknown())).optional()
+});
 async function getVercelOidcToken() {
   var _a82, _b8;
   const token = (_b8 = (_a82 = getContext().headers) == null ? undefined : _a82["x-vercel-oidc-token"]) != null ? _b8 : process.env.VERCEL_OIDC_TOKEN;
@@ -45698,7 +46000,7 @@ function createGatewayProvider(options = {}) {
       statusCode: 401
     });
   };
-  const createLanguageModel = (modelId) => {
+  const createO11yHeaders = () => {
     const deploymentId = loadOptionalSetting({
       settingValue: undefined,
       environmentVariableName: "VERCEL_DEPLOYMENT_ID"
@@ -45711,20 +46013,23 @@ function createGatewayProvider(options = {}) {
       settingValue: undefined,
       environmentVariableName: "VERCEL_REGION"
     });
+    return async () => {
+      const requestId = await getVercelRequestId();
+      return {
+        ...deploymentId && { "ai-o11y-deployment-id": deploymentId },
+        ...environment && { "ai-o11y-environment": environment },
+        ...region && { "ai-o11y-region": region },
+        ...requestId && { "ai-o11y-request-id": requestId }
+      };
+    };
+  };
+  const createLanguageModel = (modelId) => {
     return new GatewayLanguageModel(modelId, {
       provider: "gateway",
       baseURL,
       headers: getHeaders,
       fetch: options.fetch,
-      o11yHeaders: async () => {
-        const requestId = await getVercelRequestId();
-        return {
-          ...deploymentId && { "ai-o11y-deployment-id": deploymentId },
-          ...environment && { "ai-o11y-environment": environment },
-          ...region && { "ai-o11y-region": region },
-          ...requestId && { "ai-o11y-request-id": requestId }
-        };
-      }
+      o11yHeaders: createO11yHeaders()
     });
   };
   const getAvailableModels = async () => {
@@ -45739,8 +46044,8 @@ function createGatewayProvider(options = {}) {
       }).getAvailableModels().then((metadata) => {
         metadataCache = metadata;
         return metadata;
-      }).catch(async (error81) => {
-        throw asGatewayError(error81, parseAuthMethod(await getHeaders()));
+      }).catch(async (error82) => {
+        throw asGatewayError(error82, parseAuthMethod(await getHeaders()));
       });
     }
     return metadataCache ? Promise.resolve(metadataCache) : pendingMetadata;
@@ -45757,7 +46062,13 @@ function createGatewayProvider(options = {}) {
   };
   provider2.languageModel = createLanguageModel;
   provider2.textEmbeddingModel = (modelId) => {
-    throw new NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
+    return new GatewayEmbeddingModel(modelId, {
+      provider: "gateway",
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      o11yHeaders: createO11yHeaders()
+    });
   };
   return provider2;
 }
@@ -45779,7 +46090,7 @@ async function getGatewayAuthToken(options) {
       token: oidcToken,
       authMethod: "oidc"
     };
-  } catch (error81) {
+  } catch (e) {
     return null;
   }
 }
@@ -45801,14 +46112,11 @@ var NoOutputSpecifiedError = class extends AISDKError {
     super({ name: name16, message });
     this[_a17] = true;
   }
-  static isInstance(error81) {
-    return AISDKError.hasMarker(error81, marker17);
+  static isInstance(error82) {
+    return AISDKError.hasMarker(error82, marker17);
   }
 };
 _a17 = symbol18;
-function asArray(value) {
-  return value === undefined ? [] : Array.isArray(value) ? value : [value];
-}
 var name23 = "AI_InvalidArgumentError";
 var marker23 = `vercel.ai.error.${name23}`;
 var symbol24 = Symbol.for(marker23);
@@ -45827,132 +46135,210 @@ var InvalidArgumentError2 = class extends AISDKError {
     this.parameter = parameter;
     this.value = value;
   }
-  static isInstance(error81) {
-    return AISDKError.hasMarker(error81, marker23);
+  static isInstance(error82) {
+    return AISDKError.hasMarker(error82, marker23);
   }
 };
 _a23 = symbol24;
-var name33 = "AI_RetryError";
+var name33 = "AI_InvalidStreamPartError";
 var marker33 = `vercel.ai.error.${name33}`;
 var symbol33 = Symbol.for(marker33);
 var _a33;
+_a33 = symbol33;
+var name43 = "AI_InvalidToolInputError";
+var marker43 = `vercel.ai.error.${name43}`;
+var symbol43 = Symbol.for(marker43);
+var _a43;
+var InvalidToolInputError = class extends AISDKError {
+  constructor({
+    toolInput,
+    toolName,
+    cause,
+    message = `Invalid input for tool ${toolName}: ${getErrorMessage(cause)}`
+  }) {
+    super({ name: name43, message, cause });
+    this[_a43] = true;
+    this.toolInput = toolInput;
+    this.toolName = toolName;
+  }
+  static isInstance(error82) {
+    return AISDKError.hasMarker(error82, marker43);
+  }
+};
+_a43 = symbol43;
+var name53 = "AI_MCPClientError";
+var marker53 = `vercel.ai.error.${name53}`;
+var symbol53 = Symbol.for(marker53);
+var _a53;
+_a53 = symbol53;
+var name63 = "AI_NoImageGeneratedError";
+var marker63 = `vercel.ai.error.${name63}`;
+var symbol63 = Symbol.for(marker63);
+var _a63;
+_a63 = symbol63;
+var name72 = "AI_NoObjectGeneratedError";
+var marker73 = `vercel.ai.error.${name72}`;
+var symbol73 = Symbol.for(marker73);
+var _a73;
+var NoObjectGeneratedError = class extends AISDKError {
+  constructor({
+    message = "No object generated.",
+    cause,
+    text: text2,
+    response,
+    usage,
+    finishReason
+  }) {
+    super({ name: name72, message, cause });
+    this[_a73] = true;
+    this.text = text2;
+    this.response = response;
+    this.usage = usage;
+    this.finishReason = finishReason;
+  }
+  static isInstance(error82) {
+    return AISDKError.hasMarker(error82, marker73);
+  }
+};
+_a73 = symbol73;
+var name82 = "AI_NoSuchToolError";
+var marker82 = `vercel.ai.error.${name82}`;
+var symbol82 = Symbol.for(marker82);
+var _a82;
+var NoSuchToolError = class extends AISDKError {
+  constructor({
+    toolName,
+    availableTools = undefined,
+    message = `Model tried to call unavailable tool '${toolName}'. ${availableTools === undefined ? "No tools are available." : `Available tools: ${availableTools.join(", ")}.`}`
+  }) {
+    super({ name: name82, message });
+    this[_a82] = true;
+    this.toolName = toolName;
+    this.availableTools = availableTools;
+  }
+  static isInstance(error82) {
+    return AISDKError.hasMarker(error82, marker82);
+  }
+};
+_a82 = symbol82;
+var name92 = "AI_ToolCallRepairError";
+var marker92 = `vercel.ai.error.${name92}`;
+var symbol92 = Symbol.for(marker92);
+var _a92;
+var ToolCallRepairError = class extends AISDKError {
+  constructor({
+    cause,
+    originalError,
+    message = `Error repairing tool call: ${getErrorMessage(cause)}`
+  }) {
+    super({ name: name92, message, cause });
+    this[_a92] = true;
+    this.originalError = originalError;
+  }
+  static isInstance(error82) {
+    return AISDKError.hasMarker(error82, marker92);
+  }
+};
+_a92 = symbol92;
+var UnsupportedModelVersionError = class extends AISDKError {
+  constructor(options) {
+    super({
+      name: "AI_UnsupportedModelVersionError",
+      message: `Unsupported model version ${options.version} for provider "${options.provider}" and model "${options.modelId}". AI SDK 5 only supports models that implement specification version "v2".`
+    });
+    this.version = options.version;
+    this.provider = options.provider;
+    this.modelId = options.modelId;
+  }
+};
+var name102 = "AI_InvalidDataContentError";
+var marker102 = `vercel.ai.error.${name102}`;
+var symbol102 = Symbol.for(marker102);
+var _a102;
+_a102 = symbol102;
+var name112 = "AI_InvalidMessageRoleError";
+var marker112 = `vercel.ai.error.${name112}`;
+var symbol112 = Symbol.for(marker112);
+var _a112;
+var InvalidMessageRoleError = class extends AISDKError {
+  constructor({
+    role,
+    message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
+  }) {
+    super({ name: name112, message });
+    this[_a112] = true;
+    this.role = role;
+  }
+  static isInstance(error82) {
+    return AISDKError.hasMarker(error82, marker112);
+  }
+};
+_a112 = symbol112;
+var name122 = "AI_MessageConversionError";
+var marker122 = `vercel.ai.error.${name122}`;
+var symbol122 = Symbol.for(marker122);
+var _a122;
+_a122 = symbol122;
+var name132 = "AI_DownloadError";
+var marker132 = `vercel.ai.error.${name132}`;
+var symbol132 = Symbol.for(marker132);
+var _a132;
+var DownloadError = class extends AISDKError {
+  constructor({
+    url: url3,
+    statusCode,
+    statusText,
+    cause,
+    message = cause == null ? `Failed to download ${url3}: ${statusCode} ${statusText}` : `Failed to download ${url3}: ${cause}`
+  }) {
+    super({ name: name132, message, cause });
+    this[_a132] = true;
+    this.url = url3;
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+  }
+  static isInstance(error82) {
+    return AISDKError.hasMarker(error82, marker132);
+  }
+};
+_a132 = symbol132;
+var name142 = "AI_RetryError";
+var marker142 = `vercel.ai.error.${name142}`;
+var symbol142 = Symbol.for(marker142);
+var _a142;
 var RetryError = class extends AISDKError {
   constructor({
     message,
     reason,
     errors: errors5
   }) {
-    super({ name: name33, message });
-    this[_a33] = true;
+    super({ name: name142, message });
+    this[_a142] = true;
     this.reason = reason;
     this.errors = errors5;
     this.lastError = errors5[errors5.length - 1];
   }
-  static isInstance(error81) {
-    return AISDKError.hasMarker(error81, marker33);
+  static isInstance(error82) {
+    return AISDKError.hasMarker(error82, marker142);
   }
 };
-_a33 = symbol33;
-function getRetryDelay(error81, exponentialBackoffDelay) {
-  const headers = error81.responseHeaders;
-  if (!headers)
-    return exponentialBackoffDelay;
-  let timeoutMillis;
-  const retryAfterMs = headers["retry-after-ms"];
-  if (retryAfterMs) {
-    const timeoutMs = parseFloat(retryAfterMs);
-    if (!Number.isNaN(timeoutMs)) {
-      timeoutMillis = timeoutMs;
-    }
-  }
-  const retryAfter = headers["retry-after"];
-  if (retryAfter && timeoutMillis === undefined) {
-    const timeoutSeconds = parseFloat(retryAfter);
-    if (!Number.isNaN(timeoutSeconds)) {
-      timeoutMillis = timeoutSeconds * 1000;
-    } else {
-      timeoutMillis = Date.parse(retryAfter) - Date.now();
-    }
-  }
-  if (timeoutMillis !== undefined && 0 <= timeoutMillis && timeoutMillis < 60 * 1000) {
-    return timeoutMillis;
-  }
-  return exponentialBackoffDelay;
-}
-var retryWithExponentialBackoffRespectingRetryHeaders = ({
-  maxRetries = 2,
-  initialDelayInMs = 2000,
-  backoffFactor = 2
-} = {}) => async (f) => _retryWithExponentialBackoff(f, {
-  maxRetries,
-  delayInMs: initialDelayInMs,
-  backoffFactor
-});
-async function _retryWithExponentialBackoff(f, {
-  maxRetries,
-  delayInMs,
-  backoffFactor
-}, errors5 = []) {
-  try {
-    return await f();
-  } catch (error81) {
-    if (isAbortError(error81)) {
-      throw error81;
-    }
-    if (maxRetries === 0) {
-      throw error81;
-    }
-    const errorMessage = getErrorMessage2(error81);
-    const newErrors = [...errors5, error81];
-    const tryNumber = newErrors.length;
-    if (tryNumber > maxRetries) {
-      throw new RetryError({
-        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
-        reason: "maxRetriesExceeded",
-        errors: newErrors
+_a142 = symbol142;
+function resolveLanguageModel(model) {
+  if (typeof model !== "string") {
+    if (model.specificationVersion !== "v2") {
+      throw new UnsupportedModelVersionError({
+        version: model.specificationVersion,
+        provider: model.provider,
+        modelId: model.modelId
       });
     }
-    if (error81 instanceof Error && APICallError.isInstance(error81) && error81.isRetryable === true && tryNumber <= maxRetries) {
-      const actualDelay = getRetryDelay(error81, delayInMs);
-      await delay(actualDelay);
-      return _retryWithExponentialBackoff(f, { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor }, newErrors);
-    }
-    if (tryNumber === 1) {
-      throw error81;
-    }
-    throw new RetryError({
-      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
-      reason: "errorNotRetryable",
-      errors: newErrors
-    });
+    return model;
   }
+  return getGlobalProvider().languageModel(model);
 }
-function prepareRetries({
-  maxRetries
-}) {
-  if (maxRetries != null) {
-    if (!Number.isInteger(maxRetries)) {
-      throw new InvalidArgumentError2({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be an integer"
-      });
-    }
-    if (maxRetries < 0) {
-      throw new InvalidArgumentError2({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be >= 0"
-      });
-    }
-  }
-  const maxRetriesResult = maxRetries != null ? maxRetries : 2;
-  return {
-    maxRetries: maxRetriesResult,
-    retry: retryWithExponentialBackoffRespectingRetryHeaders({
-      maxRetries: maxRetriesResult
-    })
-  };
+function getGlobalProvider() {
+  var _a16;
+  return (_a16 = globalThis.AI_SDK_DEFAULT_PROVIDER) != null ? _a16 : gateway;
 }
 var imageMediaTypeSignatures = [
   {
@@ -46048,29 +46434,6 @@ function detectMediaType({
   }
   return;
 }
-var name43 = "AI_DownloadError";
-var marker43 = `vercel.ai.error.${name43}`;
-var symbol43 = Symbol.for(marker43);
-var _a43;
-var DownloadError = class extends AISDKError {
-  constructor({
-    url: url3,
-    statusCode,
-    statusText,
-    cause,
-    message = cause == null ? `Failed to download ${url3}: ${statusCode} ${statusText}` : `Failed to download ${url3}: ${cause}`
-  }) {
-    super({ name: name43, message, cause });
-    this[_a43] = true;
-    this.url = url3;
-    this.statusCode = statusCode;
-    this.statusText = statusText;
-  }
-  static isInstance(error81) {
-    return AISDKError.hasMarker(error81, marker43);
-  }
-};
-_a43 = symbol43;
 async function download({ url: url3 }) {
   var _a16;
   const urlText = url3.toString();
@@ -46087,18 +46450,13 @@ async function download({ url: url3 }) {
       data: new Uint8Array(await response.arrayBuffer()),
       mediaType: (_a16 = response.headers.get("content-type")) != null ? _a16 : undefined
     };
-  } catch (error81) {
-    if (DownloadError.isInstance(error81)) {
-      throw error81;
+  } catch (error82) {
+    if (DownloadError.isInstance(error82)) {
+      throw error82;
     }
-    throw new DownloadError({ url: urlText, cause: error81 });
+    throw new DownloadError({ url: urlText, cause: error82 });
   }
 }
-var name53 = "AI_InvalidDataContentError";
-var marker53 = `vercel.ai.error.${name53}`;
-var symbol53 = Symbol.for(marker53);
-var _a53;
-_a53 = symbol53;
 function splitDataUrl(dataUrl) {
   try {
     const [header, base64Content] = dataUrl.split(",");
@@ -46106,7 +46464,7 @@ function splitDataUrl(dataUrl) {
       mediaType: header.split(";")[0].split(":")[1],
       base64Content
     };
-  } catch (error81) {
+  } catch (error82) {
     return {
       mediaType: undefined,
       base64Content: undefined
@@ -46132,7 +46490,7 @@ function convertToLanguageModelV2DataContent(content) {
   if (typeof content === "string") {
     try {
       content = new URL(content);
-    } catch (error81) {}
+    } catch (error82) {}
   }
   if (content instanceof URL && content.protocol === "data:") {
     const { mediaType: dataUrlMediaType, base64Content } = splitDataUrl(content.toString());
@@ -46155,24 +46513,6 @@ function convertDataContentToBase64String(content) {
   }
   return convertUint8ArrayToBase64(content);
 }
-var name63 = "AI_InvalidMessageRoleError";
-var marker63 = `vercel.ai.error.${name63}`;
-var symbol63 = Symbol.for(marker63);
-var _a63;
-var InvalidMessageRoleError = class extends AISDKError {
-  constructor({
-    role,
-    message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
-  }) {
-    super({ name: name63, message });
-    this[_a63] = true;
-    this.role = role;
-  }
-  static isInstance(error81) {
-    return AISDKError.hasMarker(error81, marker63);
-  }
-};
-_a63 = symbol63;
 async function convertToLanguageModelPrompt({
   prompt,
   supportedUrls,
@@ -46482,12 +46822,14 @@ function prepareToolsAndToolChoice({
       const toolType = tool3.type;
       switch (toolType) {
         case undefined:
+        case "dynamic":
         case "function":
           return {
             type: "function",
             name: name162,
             description: tool3.description,
-            inputSchema: asSchema(tool3.inputSchema).jsonSchema
+            inputSchema: asSchema(tool3.inputSchema).jsonSchema,
+            providerOptions: tool3.providerOptions
           };
         case "provider-defined":
           return {
@@ -46505,136 +46847,6 @@ function prepareToolsAndToolChoice({
     toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
   };
 }
-var name72 = "AI_InvalidStreamPartError";
-var marker73 = `vercel.ai.error.${name72}`;
-var symbol73 = Symbol.for(marker73);
-var _a73;
-_a73 = symbol73;
-var name82 = "AI_InvalidToolInputError";
-var marker82 = `vercel.ai.error.${name82}`;
-var symbol82 = Symbol.for(marker82);
-var _a82;
-var InvalidToolInputError = class extends AISDKError {
-  constructor({
-    toolInput,
-    toolName,
-    cause,
-    message = `Invalid input for tool ${toolName}: ${getErrorMessage(cause)}`
-  }) {
-    super({ name: name82, message, cause });
-    this[_a82] = true;
-    this.toolInput = toolInput;
-    this.toolName = toolName;
-  }
-  static isInstance(error81) {
-    return AISDKError.hasMarker(error81, marker82);
-  }
-};
-_a82 = symbol82;
-var name92 = "AI_MCPClientError";
-var marker92 = `vercel.ai.error.${name92}`;
-var symbol92 = Symbol.for(marker92);
-var _a92;
-_a92 = symbol92;
-var name102 = "AI_NoImageGeneratedError";
-var marker102 = `vercel.ai.error.${name102}`;
-var symbol102 = Symbol.for(marker102);
-var _a102;
-_a102 = symbol102;
-var name112 = "AI_NoObjectGeneratedError";
-var marker112 = `vercel.ai.error.${name112}`;
-var symbol112 = Symbol.for(marker112);
-var _a112;
-var NoObjectGeneratedError = class extends AISDKError {
-  constructor({
-    message = "No object generated.",
-    cause,
-    text: text2,
-    response,
-    usage,
-    finishReason
-  }) {
-    super({ name: name112, message, cause });
-    this[_a112] = true;
-    this.text = text2;
-    this.response = response;
-    this.usage = usage;
-    this.finishReason = finishReason;
-  }
-  static isInstance(error81) {
-    return AISDKError.hasMarker(error81, marker112);
-  }
-};
-_a112 = symbol112;
-var name122 = "AI_NoSuchToolError";
-var marker122 = `vercel.ai.error.${name122}`;
-var symbol122 = Symbol.for(marker122);
-var _a122;
-var NoSuchToolError = class extends AISDKError {
-  constructor({
-    toolName,
-    availableTools = undefined,
-    message = `Model tried to call unavailable tool '${toolName}'. ${availableTools === undefined ? "No tools are available." : `Available tools: ${availableTools.join(", ")}.`}`
-  }) {
-    super({ name: name122, message });
-    this[_a122] = true;
-    this.toolName = toolName;
-    this.availableTools = availableTools;
-  }
-  static isInstance(error81) {
-    return AISDKError.hasMarker(error81, marker122);
-  }
-};
-_a122 = symbol122;
-var name132 = "AI_ToolCallRepairError";
-var marker132 = `vercel.ai.error.${name132}`;
-var symbol132 = Symbol.for(marker132);
-var _a132;
-var ToolCallRepairError = class extends AISDKError {
-  constructor({
-    cause,
-    originalError,
-    message = `Error repairing tool call: ${getErrorMessage(cause)}`
-  }) {
-    super({ name: name132, message, cause });
-    this[_a132] = true;
-    this.originalError = originalError;
-  }
-  static isInstance(error81) {
-    return AISDKError.hasMarker(error81, marker132);
-  }
-};
-_a132 = symbol132;
-var UnsupportedModelVersionError = class extends AISDKError {
-  constructor(options) {
-    super({
-      name: "AI_UnsupportedModelVersionError",
-      message: `Unsupported model version ${options.version} for provider "${options.provider}" and model "${options.modelId}". AI SDK 5 only supports models that implement specification version "v2".`
-    });
-    this.version = options.version;
-    this.provider = options.provider;
-    this.modelId = options.modelId;
-  }
-};
-var name142 = "AI_MessageConversionError";
-var marker142 = `vercel.ai.error.${name142}`;
-var symbol142 = Symbol.for(marker142);
-var _a142;
-_a142 = symbol142;
-function resolveLanguageModel(model) {
-  if (typeof model !== "string") {
-    if (model.specificationVersion !== "v2") {
-      throw new UnsupportedModelVersionError({
-        version: model.specificationVersion,
-        provider: model.provider,
-        modelId: model.modelId
-      });
-    }
-    return model;
-  }
-  const globalProvider = globalThis.AI_SDK_DEFAULT_PROVIDER;
-  return (globalProvider != null ? globalProvider : gateway).languageModel(model);
-}
 var jsonValueSchema = exports_external2.lazy(() => exports_external2.union([
   exports_external2.null(),
   exports_external2.string(),
@@ -46806,15 +47018,15 @@ async function standardizePrompt(prompt) {
     system: prompt.system
   };
 }
-function wrapGatewayError(error81) {
-  if (GatewayAuthenticationError.isInstance(error81) || GatewayModelNotFoundError.isInstance(error81)) {
+function wrapGatewayError(error82) {
+  if (GatewayAuthenticationError.isInstance(error82) || GatewayModelNotFoundError.isInstance(error82)) {
     return new AISDKError({
       name: "GatewayError",
       message: "Vercel AI Gateway access failed. If you want to use AI SDK providers directly, use the providers, e.g. @ai-sdk/openai, or register a different global default provider.",
-      cause: error81
+      cause: error82
     });
   }
-  return error81;
+  return error82;
 }
 function assembleOperationName({
   operationId,
@@ -46935,26 +47147,26 @@ function recordSpan({
         span.end();
       }
       return result;
-    } catch (error81) {
+    } catch (error82) {
       try {
-        recordErrorOnSpan(span, error81);
+        recordErrorOnSpan(span, error82);
       } finally {
         span.end();
       }
-      throw error81;
+      throw error82;
     }
   });
 }
-function recordErrorOnSpan(span, error81) {
-  if (error81 instanceof Error) {
+function recordErrorOnSpan(span, error82) {
+  if (error82 instanceof Error) {
     span.recordException({
-      name: error81.name,
-      message: error81.message,
-      stack: error81.stack
+      name: error82.name,
+      message: error82.message,
+      stack: error82.stack
     });
     span.setStatus({
       code: import_api4.SpanStatusCode.ERROR,
-      message: error81.message
+      message: error82.message
     });
   } else {
     span.setStatus({ code: import_api4.SpanStatusCode.ERROR });
@@ -47009,6 +47221,125 @@ function addLanguageModelUsage(usage1, usage2) {
 function addTokenCounts(tokenCount1, tokenCount2) {
   return tokenCount1 == null && tokenCount2 == null ? undefined : (tokenCount1 != null ? tokenCount1 : 0) + (tokenCount2 != null ? tokenCount2 : 0);
 }
+function asArray(value) {
+  return value === undefined ? [] : Array.isArray(value) ? value : [value];
+}
+function getRetryDelayInMs({
+  error: error82,
+  exponentialBackoffDelay
+}) {
+  const headers = error82.responseHeaders;
+  if (!headers)
+    return exponentialBackoffDelay;
+  let ms;
+  const retryAfterMs = headers["retry-after-ms"];
+  if (retryAfterMs) {
+    const timeoutMs = parseFloat(retryAfterMs);
+    if (!Number.isNaN(timeoutMs)) {
+      ms = timeoutMs;
+    }
+  }
+  const retryAfter = headers["retry-after"];
+  if (retryAfter && ms === undefined) {
+    const timeoutSeconds = parseFloat(retryAfter);
+    if (!Number.isNaN(timeoutSeconds)) {
+      ms = timeoutSeconds * 1000;
+    } else {
+      ms = Date.parse(retryAfter) - Date.now();
+    }
+  }
+  if (ms != null && !Number.isNaN(ms) && 0 <= ms && (ms < 60 * 1000 || ms < exponentialBackoffDelay)) {
+    return ms;
+  }
+  return exponentialBackoffDelay;
+}
+var retryWithExponentialBackoffRespectingRetryHeaders = ({
+  maxRetries = 2,
+  initialDelayInMs = 2000,
+  backoffFactor = 2,
+  abortSignal
+} = {}) => async (f) => _retryWithExponentialBackoff(f, {
+  maxRetries,
+  delayInMs: initialDelayInMs,
+  backoffFactor,
+  abortSignal
+});
+async function _retryWithExponentialBackoff(f, {
+  maxRetries,
+  delayInMs,
+  backoffFactor,
+  abortSignal
+}, errors5 = []) {
+  try {
+    return await f();
+  } catch (error82) {
+    if (isAbortError(error82)) {
+      throw error82;
+    }
+    if (maxRetries === 0) {
+      throw error82;
+    }
+    const errorMessage = getErrorMessage2(error82);
+    const newErrors = [...errors5, error82];
+    const tryNumber = newErrors.length;
+    if (tryNumber > maxRetries) {
+      throw new RetryError({
+        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
+        reason: "maxRetriesExceeded",
+        errors: newErrors
+      });
+    }
+    if (error82 instanceof Error && APICallError.isInstance(error82) && error82.isRetryable === true && tryNumber <= maxRetries) {
+      await delay(getRetryDelayInMs({
+        error: error82,
+        exponentialBackoffDelay: delayInMs
+      }), { abortSignal });
+      return _retryWithExponentialBackoff(f, {
+        maxRetries,
+        delayInMs: backoffFactor * delayInMs,
+        backoffFactor,
+        abortSignal
+      }, newErrors);
+    }
+    if (tryNumber === 1) {
+      throw error82;
+    }
+    throw new RetryError({
+      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
+      reason: "errorNotRetryable",
+      errors: newErrors
+    });
+  }
+}
+function prepareRetries({
+  maxRetries,
+  abortSignal
+}) {
+  if (maxRetries != null) {
+    if (!Number.isInteger(maxRetries)) {
+      throw new InvalidArgumentError2({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be an integer"
+      });
+    }
+    if (maxRetries < 0) {
+      throw new InvalidArgumentError2({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be >= 0"
+      });
+    }
+  }
+  const maxRetriesResult = maxRetries != null ? maxRetries : 2;
+  return {
+    maxRetries: maxRetriesResult,
+    retry: retryWithExponentialBackoffRespectingRetryHeaders({
+      maxRetries: maxRetriesResult,
+      abortSignal
+    })
+  };
+}
 function extractContentText(content) {
   const parts = content.filter((content2) => content2.type === "text");
   if (parts.length === 0) {
@@ -47052,38 +47383,50 @@ async function parseToolCall({
   system,
   messages
 }) {
-  if (tools == null) {
-    throw new NoSuchToolError({ toolName: toolCall.toolName });
-  }
   try {
-    return await doParseToolCall({ toolCall, tools });
-  } catch (error81) {
-    if (repairToolCall == null || !(NoSuchToolError.isInstance(error81) || InvalidToolInputError.isInstance(error81))) {
-      throw error81;
+    if (tools == null) {
+      throw new NoSuchToolError({ toolName: toolCall.toolName });
     }
-    let repairedToolCall = null;
     try {
-      repairedToolCall = await repairToolCall({
-        toolCall,
-        tools,
-        inputSchema: ({ toolName }) => {
-          const { inputSchema } = tools[toolName];
-          return asSchema(inputSchema).jsonSchema;
-        },
-        system,
-        messages,
-        error: error81
-      });
-    } catch (repairError) {
-      throw new ToolCallRepairError({
-        cause: repairError,
-        originalError: error81
-      });
-    }
-    if (repairedToolCall == null) {
-      throw error81;
+      return await doParseToolCall({ toolCall, tools });
+    } catch (error82) {
+      if (repairToolCall == null || !(NoSuchToolError.isInstance(error82) || InvalidToolInputError.isInstance(error82))) {
+        throw error82;
+      }
+      let repairedToolCall = null;
+      try {
+        repairedToolCall = await repairToolCall({
+          toolCall,
+          tools,
+          inputSchema: ({ toolName }) => {
+            const { inputSchema } = tools[toolName];
+            return asSchema(inputSchema).jsonSchema;
+          },
+          system,
+          messages,
+          error: error82
+        });
+      } catch (repairError) {
+        throw new ToolCallRepairError({
+          cause: repairError,
+          originalError: error82
+        });
+      }
+      if (repairedToolCall == null) {
+        throw error82;
+      }
+      return await doParseToolCall({ toolCall: repairedToolCall, tools });
     }
-    return await doParseToolCall({ toolCall: repairedToolCall, tools });
+  } catch (error82) {
+    return {
+      type: "tool-call",
+      toolCallId: toolCall.toolCallId,
+      toolName: toolCall.toolName,
+      input: toolCall.input,
+      dynamic: true,
+      invalid: true,
+      error: error82
+    };
   }
 }
 async function doParseToolCall({
@@ -47107,7 +47450,15 @@ async function doParseToolCall({
       cause: parseResult.error
     });
   }
-  return {
+  return tool3.type === "dynamic" ? {
+    type: "tool-call",
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    input: parseResult.value,
+    providerExecuted: toolCall.providerExecuted,
+    providerMetadata: toolCall.providerMetadata,
+    dynamic: true
+  } : {
     type: "tool-call",
     toolCallId: toolCall.toolCallId,
     toolName,
@@ -47152,9 +47503,21 @@ var DefaultStepResult = class {
   get toolCalls() {
     return this.content.filter((part) => part.type === "tool-call");
   }
+  get staticToolCalls() {
+    return this.toolCalls.filter((toolCall) => toolCall.dynamic === false);
+  }
+  get dynamicToolCalls() {
+    return this.toolCalls.filter((toolCall) => toolCall.dynamic === true);
+  }
   get toolResults() {
     return this.content.filter((part) => part.type === "tool-result");
   }
+  get staticToolResults() {
+    return this.toolResults.filter((toolResult) => toolResult.dynamic === false);
+  }
+  get dynamicToolResults() {
+    return this.toolResults.filter((toolResult) => toolResult.dynamic === true);
+  }
 };
 function stepCountIs(stepCount) {
   return ({ steps }) => steps.length === stepCount;
@@ -47173,12 +47536,15 @@ function createToolModelOutput({
   if (errorMode === "text") {
     return { type: "error-text", value: getErrorMessage(output) };
   } else if (errorMode === "json") {
-    return { type: "error-json", value: output };
+    return { type: "error-json", value: toJSONValue(output) };
   }
   if (tool3 == null ? undefined : tool3.toModelOutput) {
     return tool3.toModelOutput(output);
   }
-  return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: output };
+  return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: toJSONValue(output) };
+}
+function toJSONValue(value) {
+  return value === undefined ? null : value;
 }
 function toResponseMessages({
   content: inputContent,
@@ -47289,6 +47655,7 @@ async function generateText({
   experimental_prepareStep,
   prepareStep = experimental_prepareStep,
   experimental_repairToolCall: repairToolCall,
+  experimental_context,
   _internal: {
     generateId: generateId3 = originalGenerateId,
     currentDate = () => /* @__PURE__ */ new Date
@@ -47298,7 +47665,10 @@ async function generateText({
 }) {
   const model = resolveLanguageModel(modelArg);
   const stopConditions = asArray(stopWhen);
-  const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg });
+  const { maxRetries, retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal
+  });
   const callSettings = prepareCallSettings(settings);
   const baseTelemetryAttributes = getBaseTelemetryAttributes({
     model,
@@ -47455,25 +47825,44 @@ async function generateText({
             messages: stepInputMessages
           })));
           for (const toolCall of stepToolCalls) {
+            if (toolCall.invalid) {
+              continue;
+            }
             const tool3 = tools[toolCall.toolName];
             if ((tool3 == null ? undefined : tool3.onInputAvailable) != null) {
               await tool3.onInputAvailable({
                 input: toolCall.input,
                 toolCallId: toolCall.toolCallId,
                 messages: stepInputMessages,
-                abortSignal
+                abortSignal,
+                experimental_context
               });
             }
           }
-          clientToolCalls = stepToolCalls.filter((toolCall) => toolCall.providerExecuted !== true);
-          clientToolOutputs = tools == null ? [] : await executeTools({
-            toolCalls: clientToolCalls,
-            tools,
-            tracer,
-            telemetry,
-            messages: stepInputMessages,
-            abortSignal
-          });
+          const invalidToolCalls = stepToolCalls.filter((toolCall) => toolCall.invalid && toolCall.dynamic);
+          clientToolOutputs = [];
+          for (const toolCall of invalidToolCalls) {
+            clientToolOutputs.push({
+              type: "tool-error",
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              input: toolCall.input,
+              error: getErrorMessage2(toolCall.error),
+              dynamic: true
+            });
+          }
+          clientToolCalls = stepToolCalls.filter((toolCall) => !toolCall.providerExecuted);
+          if (tools != null) {
+            clientToolOutputs.push(...await executeTools({
+              toolCalls: clientToolCalls.filter((toolCall) => !toolCall.invalid),
+              tools,
+              tracer,
+              telemetry,
+              messages: stepInputMessages,
+              abortSignal,
+              experimental_context
+            }));
+          }
           const stepContent = asContent({
             content: currentModelResponse.content,
             toolCalls: stepToolCalls,
@@ -47527,8 +47916,8 @@ async function generateText({
         });
       }
     });
-  } catch (error81) {
-    throw wrapGatewayError(error81);
+  } catch (error82) {
+    throw wrapGatewayError(error82);
   }
 }
 async function executeTools({
@@ -47537,7 +47926,8 @@ async function executeTools({
   tracer,
   telemetry,
   messages,
-  abortSignal
+  abortSignal,
+  experimental_context
 }) {
   const toolOutputs = await Promise.all(toolCalls.map(async ({ toolCallId, toolName, input }) => {
     const tool3 = tools[toolName];
@@ -47555,7 +47945,7 @@ async function executeTools({
           }),
           "ai.toolCall.name": toolName,
           "ai.toolCall.id": toolCallId,
-          "ai.toolCall.input": {
+          "ai.toolCall.args": {
             output: () => JSON.stringify(input)
           }
         }
@@ -47563,17 +47953,18 @@ async function executeTools({
       tracer,
       fn: async (span) => {
         try {
-          const result = await tool3.execute(input, {
+          const output = await tool3.execute(input, {
             toolCallId,
             messages,
-            abortSignal
+            abortSignal,
+            experimental_context
           });
           try {
             span.setAttributes(selectTelemetryAttributes({
               telemetry,
               attributes: {
                 "ai.toolCall.result": {
-                  output: () => JSON.stringify(result)
+                  output: () => JSON.stringify(output)
                 }
               }
             }));
@@ -47583,16 +47974,18 @@ async function executeTools({
             toolCallId,
             toolName,
             input,
-            output: result
+            output,
+            dynamic: tool3.type === "dynamic"
           };
-        } catch (error81) {
-          recordErrorOnSpan(span, error81);
+        } catch (error82) {
+          recordErrorOnSpan(span, error82);
           return {
             type: "tool-error",
             toolCallId,
             toolName,
             input,
-            error: error81
+            error: error82,
+            dynamic: tool3.type === "dynamic"
           };
         }
       }
@@ -47626,9 +48019,21 @@ var DefaultGenerateTextResult = class {
   get toolCalls() {
     return this.finalStep.toolCalls;
   }
+  get staticToolCalls() {
+    return this.finalStep.staticToolCalls;
+  }
+  get dynamicToolCalls() {
+    return this.finalStep.dynamicToolCalls;
+  }
   get toolResults() {
     return this.finalStep.toolResults;
   }
+  get staticToolResults() {
+    return this.finalStep.staticToolResults;
+  }
+  get dynamicToolResults() {
+    return this.finalStep.dynamicToolResults;
+  }
   get sources() {
     return this.finalStep.sources;
   }
@@ -47712,7 +48117,8 @@ function asContent({
               toolName: part.toolName,
               input: toolCall.input,
               error: part.result,
-              providerExecuted: true
+              providerExecuted: true,
+              dynamic: toolCall.dynamic
             };
           }
           return {
@@ -47721,7 +48127,8 @@ function asContent({
             toolName: part.toolName,
             input: toolCall.input,
             output: part.result,
-            providerExecuted: true
+            providerExecuted: true,
+            dynamic: toolCall.dynamic
           };
         }
       }
@@ -47769,8 +48176,8 @@ function writeToServerResponse({
           break;
         response.write(value);
       }
-    } catch (error81) {
-      throw error81;
+    } catch (error82) {
+      throw error82;
     } finally {
       response.end();
     }
@@ -47871,7 +48278,8 @@ var uiMessageChunkSchema = exports_external2.union([
     type: exports_external2.literal("tool-input-start"),
     toolCallId: exports_external2.string(),
     toolName: exports_external2.string(),
-    providerExecuted: exports_external2.boolean().optional()
+    providerExecuted: exports_external2.boolean().optional(),
+    dynamic: exports_external2.boolean().optional()
   }),
   exports_external2.strictObject({
     type: exports_external2.literal("tool-input-delta"),
@@ -47884,19 +48292,32 @@ var uiMessageChunkSchema = exports_external2.union([
     toolName: exports_external2.string(),
     input: exports_external2.unknown(),
     providerExecuted: exports_external2.boolean().optional(),
-    providerMetadata: providerMetadataSchema.optional()
+    providerMetadata: providerMetadataSchema.optional(),
+    dynamic: exports_external2.boolean().optional()
+  }),
+  exports_external2.strictObject({
+    type: exports_external2.literal("tool-input-error"),
+    toolCallId: exports_external2.string(),
+    toolName: exports_external2.string(),
+    input: exports_external2.unknown(),
+    providerExecuted: exports_external2.boolean().optional(),
+    providerMetadata: providerMetadataSchema.optional(),
+    dynamic: exports_external2.boolean().optional(),
+    errorText: exports_external2.string()
   }),
   exports_external2.strictObject({
     type: exports_external2.literal("tool-output-available"),
     toolCallId: exports_external2.string(),
     output: exports_external2.unknown(),
-    providerExecuted: exports_external2.boolean().optional()
+    providerExecuted: exports_external2.boolean().optional(),
+    dynamic: exports_external2.boolean().optional()
   }),
   exports_external2.strictObject({
     type: exports_external2.literal("tool-output-error"),
     toolCallId: exports_external2.string(),
     errorText: exports_external2.string(),
-    providerExecuted: exports_external2.boolean().optional()
+    providerExecuted: exports_external2.boolean().optional(),
+    dynamic: exports_external2.boolean().optional()
   }),
   exports_external2.strictObject({
     type: exports_external2.literal("reasoning"),
@@ -48357,18 +48778,34 @@ function createStreamingUIMessageState({
 }
 function processUIMessageStream({
   stream,
-  onToolCall,
   messageMetadataSchema,
   dataPartSchemas,
   runUpdateMessageJob,
   onError,
+  onToolCall,
   onData
 }) {
   return stream.pipeThrough(new TransformStream({
     async transform(chunk, controller) {
       await runUpdateMessageJob(async ({ state, write }) => {
         var _a16, _b8, _c, _d;
-        function updateToolInvocationPart(options) {
+        function getToolInvocation(toolCallId) {
+          const toolInvocations = state.message.parts.filter(isToolUIPart);
+          const toolInvocation = toolInvocations.find((invocation) => invocation.toolCallId === toolCallId);
+          if (toolInvocation == null) {
+            throw new Error("tool-output-error must be preceded by a tool-input-available");
+          }
+          return toolInvocation;
+        }
+        function getDynamicToolInvocation(toolCallId) {
+          const toolInvocations = state.message.parts.filter((part) => part.type === "dynamic-tool");
+          const toolInvocation = toolInvocations.find((invocation) => invocation.toolCallId === toolCallId);
+          if (toolInvocation == null) {
+            throw new Error("tool-output-error must be preceded by a tool-input-available");
+          }
+          return toolInvocation;
+        }
+        function updateToolPart(options) {
           var _a172;
           const part = state.message.parts.find((part2) => isToolUIPart(part2) && part2.toolCallId === options.toolCallId);
           const anyOptions = options;
@@ -48378,6 +48815,7 @@ function processUIMessageStream({
             anyPart.input = anyOptions.input;
             anyPart.output = anyOptions.output;
             anyPart.errorText = anyOptions.errorText;
+            anyPart.rawInput = anyOptions.rawInput;
             anyPart.providerExecuted = (_a172 = anyOptions.providerExecuted) != null ? _a172 : part.providerExecuted;
             if (anyOptions.providerMetadata != null && part.state === "input-available") {
               part.callProviderMetadata = anyOptions.providerMetadata;
@@ -48389,12 +48827,41 @@ function processUIMessageStream({
               state: options.state,
               input: anyOptions.input,
               output: anyOptions.output,
+              rawInput: anyOptions.rawInput,
               errorText: anyOptions.errorText,
               providerExecuted: anyOptions.providerExecuted,
               ...anyOptions.providerMetadata != null ? { callProviderMetadata: anyOptions.providerMetadata } : {}
             });
           }
         }
+        function updateDynamicToolPart(options) {
+          var _a172;
+          const part = state.message.parts.find((part2) => part2.type === "dynamic-tool" && part2.toolCallId === options.toolCallId);
+          const anyOptions = options;
+          const anyPart = part;
+          if (part != null) {
+            part.state = options.state;
+            anyPart.toolName = options.toolName;
+            anyPart.input = anyOptions.input;
+            anyPart.output = anyOptions.output;
+            anyPart.errorText = anyOptions.errorText;
+            anyPart.rawInput = (_a172 = anyOptions.rawInput) != null ? _a172 : anyPart.rawInput;
+            if (anyOptions.providerMetadata != null && part.state === "input-available") {
+              part.callProviderMetadata = anyOptions.providerMetadata;
+            }
+          } else {
+            state.message.parts.push({
+              type: "dynamic-tool",
+              toolName: options.toolName,
+              toolCallId: options.toolCallId,
+              state: options.state,
+              input: anyOptions.input,
+              output: anyOptions.output,
+              errorText: anyOptions.errorText,
+              ...anyOptions.providerMetadata != null ? { callProviderMetadata: anyOptions.providerMetadata } : {}
+            });
+          }
+        }
         async function updateMessageMetadata(metadata) {
           if (metadata != null) {
             const mergedMetadata = state.message.metadata != null ? mergeObjects(state.message.metadata, metadata) : metadata;
@@ -48499,15 +48966,25 @@ function processUIMessageStream({
             state.partialToolCalls[chunk.toolCallId] = {
               text: "",
               toolName: chunk.toolName,
-              index: toolInvocations.length
+              index: toolInvocations.length,
+              dynamic: chunk.dynamic
             };
-            updateToolInvocationPart({
-              toolCallId: chunk.toolCallId,
-              toolName: chunk.toolName,
-              state: "input-streaming",
-              input: undefined,
-              providerExecuted: chunk.providerExecuted
-            });
+            if (chunk.dynamic) {
+              updateDynamicToolPart({
+                toolCallId: chunk.toolCallId,
+                toolName: chunk.toolName,
+                state: "input-streaming",
+                input: undefined
+              });
+            } else {
+              updateToolPart({
+                toolCallId: chunk.toolCallId,
+                toolName: chunk.toolName,
+                state: "input-streaming",
+                input: undefined,
+                providerExecuted: chunk.providerExecuted
+              });
+            }
             write();
             break;
           }
@@ -48515,81 +48992,121 @@ function processUIMessageStream({
             const partialToolCall = state.partialToolCalls[chunk.toolCallId];
             partialToolCall.text += chunk.inputTextDelta;
             const { value: partialArgs } = await parsePartialJson(partialToolCall.text);
-            updateToolInvocationPart({
-              toolCallId: chunk.toolCallId,
-              toolName: partialToolCall.toolName,
-              state: "input-streaming",
-              input: partialArgs
-            });
+            if (partialToolCall.dynamic) {
+              updateDynamicToolPart({
+                toolCallId: chunk.toolCallId,
+                toolName: partialToolCall.toolName,
+                state: "input-streaming",
+                input: partialArgs
+              });
+            } else {
+              updateToolPart({
+                toolCallId: chunk.toolCallId,
+                toolName: partialToolCall.toolName,
+                state: "input-streaming",
+                input: partialArgs
+              });
+            }
             write();
             break;
           }
           case "tool-input-available": {
-            updateToolInvocationPart({
-              toolCallId: chunk.toolCallId,
-              toolName: chunk.toolName,
-              state: "input-available",
-              input: chunk.input,
-              providerExecuted: chunk.providerExecuted,
-              providerMetadata: chunk.providerMetadata
-            });
+            if (chunk.dynamic) {
+              updateDynamicToolPart({
+                toolCallId: chunk.toolCallId,
+                toolName: chunk.toolName,
+                state: "input-available",
+                input: chunk.input,
+                providerMetadata: chunk.providerMetadata
+              });
+            } else {
+              updateToolPart({
+                toolCallId: chunk.toolCallId,
+                toolName: chunk.toolName,
+                state: "input-available",
+                input: chunk.input,
+                providerExecuted: chunk.providerExecuted,
+                providerMetadata: chunk.providerMetadata
+              });
+            }
             write();
             if (onToolCall && !chunk.providerExecuted) {
-              const result = await onToolCall({
+              await onToolCall({
                 toolCall: chunk
               });
-              if (result != null) {
-                updateToolInvocationPart({
-                  toolCallId: chunk.toolCallId,
-                  toolName: chunk.toolName,
-                  state: "output-available",
-                  input: chunk.input,
-                  output: result
-                });
-                write();
-              }
             }
             break;
           }
-          case "tool-output-available": {
-            const toolInvocations = state.message.parts.filter(isToolUIPart);
-            if (toolInvocations == null) {
-              throw new Error("tool_result must be preceded by a tool_call");
+          case "tool-input-error": {
+            if (chunk.dynamic) {
+              updateDynamicToolPart({
+                toolCallId: chunk.toolCallId,
+                toolName: chunk.toolName,
+                state: "output-error",
+                input: chunk.input,
+                errorText: chunk.errorText,
+                providerMetadata: chunk.providerMetadata
+              });
+            } else {
+              updateToolPart({
+                toolCallId: chunk.toolCallId,
+                toolName: chunk.toolName,
+                state: "output-error",
+                input: undefined,
+                rawInput: chunk.input,
+                errorText: chunk.errorText,
+                providerExecuted: chunk.providerExecuted,
+                providerMetadata: chunk.providerMetadata
+              });
             }
-            const toolInvocationIndex = toolInvocations.findIndex((invocation) => invocation.toolCallId === chunk.toolCallId);
-            if (toolInvocationIndex === -1) {
-              throw new Error("tool_result must be preceded by a tool_call with the same toolCallId");
+            write();
+            break;
+          }
+          case "tool-output-available": {
+            if (chunk.dynamic) {
+              const toolInvocation = getDynamicToolInvocation(chunk.toolCallId);
+              updateDynamicToolPart({
+                toolCallId: chunk.toolCallId,
+                toolName: toolInvocation.toolName,
+                state: "output-available",
+                input: toolInvocation.input,
+                output: chunk.output
+              });
+            } else {
+              const toolInvocation = getToolInvocation(chunk.toolCallId);
+              updateToolPart({
+                toolCallId: chunk.toolCallId,
+                toolName: getToolName(toolInvocation),
+                state: "output-available",
+                input: toolInvocation.input,
+                output: chunk.output,
+                providerExecuted: chunk.providerExecuted
+              });
             }
-            const toolName = getToolName(toolInvocations[toolInvocationIndex]);
-            updateToolInvocationPart({
-              toolCallId: chunk.toolCallId,
-              toolName,
-              state: "output-available",
-              input: toolInvocations[toolInvocationIndex].input,
-              output: chunk.output,
-              providerExecuted: chunk.providerExecuted
-            });
             write();
             break;
           }
           case "tool-output-error": {
-            const toolInvocations = state.message.parts.filter(isToolUIPart);
-            if (toolInvocations == null) {
-              throw new Error("tool_result must be preceded by a tool_call");
-            }
-            const toolInvocationIndex = toolInvocations.findIndex((invocation) => invocation.toolCallId === chunk.toolCallId);
-            if (toolInvocationIndex === -1) {
-              throw new Error("tool_result must be preceded by a tool_call with the same toolCallId");
+            if (chunk.dynamic) {
+              const toolInvocation = getDynamicToolInvocation(chunk.toolCallId);
+              updateDynamicToolPart({
+                toolCallId: chunk.toolCallId,
+                toolName: toolInvocation.toolName,
+                state: "output-error",
+                input: toolInvocation.input,
+                errorText: chunk.errorText
+              });
+            } else {
+              const toolInvocation = getToolInvocation(chunk.toolCallId);
+              updateToolPart({
+                toolCallId: chunk.toolCallId,
+                toolName: getToolName(toolInvocation),
+                state: "output-error",
+                input: toolInvocation.input,
+                rawInput: toolInvocation.rawInput,
+                errorText: chunk.errorText
+              });
             }
-            const toolName = getToolName(toolInvocations[toolInvocationIndex]);
-            updateToolInvocationPart({
-              toolCallId: chunk.toolCallId,
-              toolName,
-              state: "output-error",
-              input: toolInvocations[toolInvocationIndex].input,
-              errorText: chunk.errorText,
-              providerExecuted: chunk.providerExecuted
-            });
             write();
             break;
           }
@@ -48765,8 +49282,8 @@ async function consumeStream({
       if (done)
         break;
     }
-  } catch (error81) {
-    onError == null || onError(error81);
+  } catch (error82) {
+    onError == null || onError(error82);
   } finally {
     reader.releaseLock();
   }
@@ -48818,8 +49335,8 @@ function createStitchableStream() {
       } else {
         controller == null || controller.enqueue(value);
       }
-    } catch (error81) {
-      controller == null || controller.error(error81);
+    } catch (error82) {
+      controller == null || controller.error(error82);
       innerStreamReaders.shift();
       terminate();
     }
@@ -48883,18 +49400,14 @@ var DelayedPromise = class {
       (_a16 = this._resolve) == null || _a16.call(this, value);
     }
   }
-  reject(error81) {
+  reject(error82) {
     var _a16;
-    this.status = { type: "rejected", error: error81 };
+    this.status = { type: "rejected", error: error82 };
     if (this._promise) {
-      (_a16 = this._reject) == null || _a16.call(this, error81);
+      (_a16 = this._reject) == null || _a16.call(this, error82);
     }
   }
 };
-function now() {
-  var _a16, _b8;
-  return (_b8 = (_a16 = globalThis == null ? undefined : globalThis.performance) == null ? undefined : _a16.now()) != null ? _b8 : Date.now();
-}
 function filterStreamErrors(readable, onError) {
   return new ReadableStream({
     async start(controller) {
@@ -48908,8 +49421,8 @@ function filterStreamErrors(readable, onError) {
           }
           controller.enqueue(value);
         }
-      } catch (error81) {
-        await onError({ error: error81, controller });
+      } catch (error82) {
+        await onError({ error: error82, controller });
       }
     },
     cancel(reason) {
@@ -48917,6 +49430,10 @@ function filterStreamErrors(readable, onError) {
     }
   });
 }
+function now() {
+  var _a16, _b8;
+  return (_b8 = (_a16 = globalThis == null ? undefined : globalThis.performance) == null ? undefined : _a16.now()) != null ? _b8 : Date.now();
+}
 function runToolsTransformation({
   tools,
   generatorStream,
@@ -48925,7 +49442,8 @@ function runToolsTransformation({
   system,
   messages,
   abortSignal,
-  repairToolCall
+  repairToolCall,
+  experimental_context
 }) {
   let toolResultsStreamController = null;
   const toolResultsStream = new ReadableStream({
@@ -48995,6 +49513,17 @@ function runToolsTransformation({
               messages
             });
             controller.enqueue(toolCall);
+            if (toolCall.invalid) {
+              toolResultsStreamController.enqueue({
+                type: "tool-error",
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                input: toolCall.input,
+                error: getErrorMessage2(toolCall.error),
+                dynamic: true
+              });
+              break;
+            }
             const tool3 = tools[toolCall.toolName];
             toolInputs.set(toolCall.toolCallId, toolCall.input);
             if (tool3.onInputAvailable != null) {
@@ -49002,7 +49531,8 @@ function runToolsTransformation({
                 input: toolCall.input,
                 toolCallId: toolCall.toolCallId,
                 messages,
-                abortSignal
+                abortSignal,
+                experimental_context
               });
             }
             if (tool3.execute != null && toolCall.providerExecuted !== true) {
@@ -49019,7 +49549,7 @@ function runToolsTransformation({
                     }),
                     "ai.toolCall.name": toolCall.toolName,
                     "ai.toolCall.id": toolCall.toolCallId,
-                    "ai.toolCall.input": {
+                    "ai.toolCall.args": {
                       output: () => JSON.stringify(toolCall.input)
                     }
                   }
@@ -49031,14 +49561,15 @@ function runToolsTransformation({
                     output = await tool3.execute(toolCall.input, {
                       toolCallId: toolCall.toolCallId,
                       messages,
-                      abortSignal
+                      abortSignal,
+                      experimental_context
                     });
-                  } catch (error81) {
-                    recordErrorOnSpan(span, error81);
+                  } catch (error82) {
+                    recordErrorOnSpan(span, error82);
                     toolResultsStreamController.enqueue({
                       ...toolCall,
                       type: "tool-error",
-                      error: error81
+                      error: error82
                     });
                     outstandingToolResults.delete(toolExecutionId);
                     attemptClose();
@@ -49055,7 +49586,7 @@ function runToolsTransformation({
                     span.setAttributes(selectTelemetryAttributes({
                       telemetry,
                       attributes: {
-                        "ai.toolCall.output": {
+                        "ai.toolCall.result": {
                           output: () => JSON.stringify(output)
                         }
                       }
@@ -49064,8 +49595,8 @@ function runToolsTransformation({
                 }
               });
             }
-          } catch (error81) {
-            toolResultsStreamController.enqueue({ type: "error", error: error81 });
+          } catch (error82) {
+            toolResultsStreamController.enqueue({ type: "error", error: error82 });
           }
           break;
         }
@@ -49149,12 +49680,13 @@ function streamText({
   experimental_transform: transform3,
   includeRawChunks = false,
   onChunk,
-  onError = ({ error: error81 }) => {
-    console.error(error81);
+  onError = ({ error: error82 }) => {
+    console.error(error82);
   },
   onFinish,
   onAbort,
   onStepFinish,
+  experimental_context,
   _internal: {
     now: now2 = now,
     generateId: generateId3 = originalGenerateId2,
@@ -49189,7 +49721,8 @@ function streamText({
     onStepFinish,
     now: now2,
     currentDate,
-    generateId: generateId3
+    generateId: generateId3,
+    experimental_context
   });
 }
 function createOutputTransformStream(output) {
@@ -49210,7 +49743,7 @@ function createOutputTransformStream(output) {
   }) {
     controller.enqueue({
       part: {
-        type: "text",
+        type: "text-delta",
         id: firstTextChunkId,
         text: textChunk
       },
@@ -49223,7 +49756,7 @@ function createOutputTransformStream(output) {
       if (chunk.type === "finish-step" && textChunk.length > 0) {
         publishTextChunk({ controller });
       }
-      if (chunk.type !== "text" && chunk.type !== "text-start" && chunk.type !== "text-end") {
+      if (chunk.type !== "text-delta" && chunk.type !== "text-start" && chunk.type !== "text-end") {
         controller.enqueue({ part: chunk, partialOutput: undefined });
         return;
       }
@@ -49285,13 +49818,15 @@ var DefaultStreamTextResult = class {
     onError,
     onFinish,
     onAbort,
-    onStepFinish
+    onStepFinish,
+    experimental_context
   }) {
     this._totalUsage = new DelayedPromise;
     this._finishReason = new DelayedPromise;
     this._steps = new DelayedPromise;
     this.output = output;
     this.includeRawChunks = includeRawChunks;
+    this.tools = tools;
     let stepFinish;
     let recordedContent = [];
     const recordedResponseMessages = [];
@@ -49308,7 +49843,7 @@ var DefaultStreamTextResult = class {
         var _a16, _b8, _c;
         controller.enqueue(chunk);
         const { part } = chunk;
-        if (part.type === "text" || part.type === "reasoning" || part.type === "source" || part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-input-start" || part.type === "tool-input-delta" || part.type === "raw") {
+        if (part.type === "text-delta" || part.type === "reasoning-delta" || part.type === "source" || part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-input-start" || part.type === "tool-input-delta" || part.type === "raw") {
           await (onChunk == null ? undefined : onChunk({ chunk: part }));
         }
         if (part.type === "error") {
@@ -49322,7 +49857,7 @@ var DefaultStreamTextResult = class {
           };
           recordedContent.push(activeTextContent[part.id]);
         }
-        if (part.type === "text") {
+        if (part.type === "text-delta") {
           const activeText = activeTextContent[part.id];
           if (activeText == null) {
             controller.enqueue({
@@ -49348,7 +49883,7 @@ var DefaultStreamTextResult = class {
           };
           recordedContent.push(activeReasoningContent[part.id]);
         }
-        if (part.type === "reasoning") {
+        if (part.type === "reasoning-delta") {
           const activeReasoning = activeReasoningContent[part.id];
           if (activeReasoning == null) {
             controller.enqueue({
@@ -49453,7 +49988,11 @@ var DefaultStreamTextResult = class {
             files: finalStep.files,
             sources: finalStep.sources,
             toolCalls: finalStep.toolCalls,
+            staticToolCalls: finalStep.staticToolCalls,
+            dynamicToolCalls: finalStep.dynamicToolCalls,
             toolResults: finalStep.toolResults,
+            staticToolResults: finalStep.staticToolResults,
+            dynamicToolResults: finalStep.dynamicToolResults,
             request: finalStep.request,
             response: finalStep.response,
             warnings: finalStep.warnings,
@@ -49479,8 +50018,8 @@ var DefaultStreamTextResult = class {
               "ai.usage.cachedInputTokens": totalUsage.cachedInputTokens
             }
           }));
-        } catch (error81) {
-          controller.error(error81);
+        } catch (error82) {
+          controller.error(error82);
         } finally {
           rootSpan.end();
         }
@@ -49490,13 +50029,13 @@ var DefaultStreamTextResult = class {
     this.addStream = stitchableStream.addStream;
     this.closeStream = stitchableStream.close;
     let stream = stitchableStream.stream;
-    stream = filterStreamErrors(stream, ({ error: error81, controller }) => {
-      if (isAbortError(error81) && (abortSignal == null ? undefined : abortSignal.aborted)) {
+    stream = filterStreamErrors(stream, ({ error: error82, controller }) => {
+      if (isAbortError(error82) && (abortSignal == null ? undefined : abortSignal.aborted)) {
         onAbort == null || onAbort({ steps: recordedSteps });
         controller.enqueue({ type: "abort" });
         controller.close();
       } else {
-        controller.error(error81);
+        controller.error(error82);
       }
     });
     stream = stream.pipeThrough(new TransformStream({
@@ -49514,7 +50053,8 @@ var DefaultStreamTextResult = class {
     }
     this.baseStream = stream.pipeThrough(createOutputTransformStream(output)).pipeThrough(eventProcessor);
     const { maxRetries, retry } = prepareRetries({
-      maxRetries: maxRetriesArg
+      maxRetries: maxRetriesArg,
+      abortSignal
     });
     const tracer = getTracer(telemetry);
     const callSettings = prepareCallSettings(settings);
@@ -49641,7 +50181,8 @@ var DefaultStreamTextResult = class {
             system,
             messages: stepInputMessages,
             repairToolCall,
-            abortSignal
+            abortSignal,
+            experimental_context
           });
           const stepRequest = request != null ? request : {};
           const stepToolCalls = [];
@@ -49694,7 +50235,7 @@ var DefaultStreamTextResult = class {
                 case "text-delta": {
                   if (chunk.delta.length > 0) {
                     controller.enqueue({
-                      type: "text",
+                      type: "text-delta",
                       id: chunk.id,
                       text: chunk.delta,
                       providerMetadata: chunk.providerMetadata
@@ -49710,7 +50251,7 @@ var DefaultStreamTextResult = class {
                 }
                 case "reasoning-delta": {
                   controller.enqueue({
-                    type: "reasoning",
+                    type: "reasoning-delta",
                     id: chunk.id,
                     text: chunk.delta,
                     providerMetadata: chunk.providerMetadata
@@ -49767,10 +50308,14 @@ var DefaultStreamTextResult = class {
                     await tool3.onInputStart({
                       toolCallId: chunk.id,
                       messages: stepInputMessages,
-                      abortSignal
+                      abortSignal,
+                      experimental_context
                     });
                   }
-                  controller.enqueue(chunk);
+                  controller.enqueue({
+                    ...chunk,
+                    dynamic: (tool3 == null ? undefined : tool3.type) === "dynamic"
+                  });
                   break;
                 }
                 case "tool-input-end": {
@@ -49786,7 +50331,8 @@ var DefaultStreamTextResult = class {
                       inputTextDelta: chunk.delta,
                       toolCallId: chunk.id,
                       messages: stepInputMessages,
-                      abortSignal
+                      abortSignal,
+                      experimental_context
                     });
                   }
                   controller.enqueue(chunk);
@@ -49838,7 +50384,7 @@ var DefaultStreamTextResult = class {
                     "gen_ai.usage.output_tokens": stepUsage.outputTokens
                   }
                 }));
-              } catch (error81) {} finally {
+              } catch (error82) {} finally {
                 doStreamSpan.end();
               }
               controller.enqueue({
@@ -49869,10 +50415,10 @@ var DefaultStreamTextResult = class {
                     responseMessages,
                     usage: combinedUsage
                   });
-                } catch (error81) {
+                } catch (error82) {
                   controller.enqueue({
                     type: "error",
-                    error: error81
+                    error: error82
                   });
                   self2.closeStream();
                 }
@@ -49897,10 +50443,10 @@ var DefaultStreamTextResult = class {
           }
         });
       }
-    }).catch((error81) => {
+    }).catch((error82) => {
       self2.addStream(new ReadableStream({
         start(controller) {
-          controller.enqueue({ type: "error", error: error81 });
+          controller.enqueue({ type: "error", error: error82 });
           controller.close();
         }
       }));
@@ -49940,9 +50486,21 @@ var DefaultStreamTextResult = class {
   get toolCalls() {
     return this.finalStep.then((step) => step.toolCalls);
   }
+  get staticToolCalls() {
+    return this.finalStep.then((step) => step.staticToolCalls);
+  }
+  get dynamicToolCalls() {
+    return this.finalStep.then((step) => step.dynamicToolCalls);
+  }
   get toolResults() {
     return this.finalStep.then((step) => step.toolResults);
   }
+  get staticToolResults() {
+    return this.finalStep.then((step) => step.staticToolResults);
+  }
+  get dynamicToolResults() {
+    return this.finalStep.then((step) => step.dynamicToolResults);
+  }
   get usage() {
     return this.finalStep.then((step) => step.usage);
   }
@@ -49966,7 +50524,7 @@ var DefaultStreamTextResult = class {
   get textStream() {
     return createAsyncIterableStream(this.teeStream().pipeThrough(new TransformStream({
       transform({ part }, controller) {
-        if (part.type === "text") {
+        if (part.type === "text-delta") {
           controller.enqueue(part.text);
         }
       }
@@ -49986,8 +50544,8 @@ var DefaultStreamTextResult = class {
         stream: this.fullStream,
         onError: options == null ? undefined : options.onError
       });
-    } catch (error81) {
-      (_a16 = options == null ? undefined : options.onError) == null || _a16.call(options, error81);
+    } catch (error82) {
+      (_a16 = options == null ? undefined : options.onError) == null || _a16.call(options, error82);
     }
   }
   get experimental_partialOutputStream() {
@@ -50017,6 +50575,13 @@ var DefaultStreamTextResult = class {
       originalMessages,
       responseMessageId: generateMessageId
     }) : undefined;
+    const toolNamesByCallId = {};
+    const isDynamic = (toolCallId) => {
+      var _a16, _b8;
+      const toolName = toolNamesByCallId[toolCallId];
+      const dynamic = ((_b8 = (_a16 = this.tools) == null ? undefined : _a16[toolName]) == null ? undefined : _b8.type) === "dynamic";
+      return dynamic ? true : undefined;
+    };
     const baseStream = this.fullStream.pipeThrough(new TransformStream({
       transform: async (part, controller) => {
         const messageMetadataValue = messageMetadata == null ? undefined : messageMetadata({ part });
@@ -50030,7 +50595,7 @@ var DefaultStreamTextResult = class {
             });
             break;
           }
-          case "text": {
+          case "text-delta": {
             controller.enqueue({
               type: "text-delta",
               id: part.id,
@@ -50055,7 +50620,7 @@ var DefaultStreamTextResult = class {
             });
             break;
           }
-          case "reasoning": {
+          case "reasoning-delta": {
             if (sendReasoning) {
               controller.enqueue({
                 type: "reasoning-delta",
@@ -50105,11 +50670,14 @@ var DefaultStreamTextResult = class {
             break;
           }
           case "tool-input-start": {
+            toolNamesByCallId[part.id] = part.toolName;
+            const dynamic = isDynamic(part.id);
             controller.enqueue({
               type: "tool-input-start",
               toolCallId: part.id,
               toolName: part.toolName,
-              providerExecuted: part.providerExecuted
+              ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+              ...dynamic != null ? { dynamic } : {}
             });
             break;
           }
@@ -50122,31 +50690,51 @@ var DefaultStreamTextResult = class {
             break;
           }
           case "tool-call": {
-            controller.enqueue({
-              type: "tool-input-available",
-              toolCallId: part.toolCallId,
-              toolName: part.toolName,
-              input: part.input,
-              providerExecuted: part.providerExecuted,
-              providerMetadata: part.providerMetadata
-            });
+            toolNamesByCallId[part.toolCallId] = part.toolName;
+            const dynamic = isDynamic(part.toolCallId);
+            if (part.invalid) {
+              controller.enqueue({
+                type: "tool-input-error",
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                input: part.input,
+                ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+                ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
+                ...dynamic != null ? { dynamic } : {},
+                errorText: onError(part.error)
+              });
+            } else {
+              controller.enqueue({
+                type: "tool-input-available",
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                input: part.input,
+                ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+                ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
+                ...dynamic != null ? { dynamic } : {}
+              });
+            }
             break;
           }
           case "tool-result": {
+            const dynamic = isDynamic(part.toolCallId);
             controller.enqueue({
               type: "tool-output-available",
               toolCallId: part.toolCallId,
               output: part.output,
-              providerExecuted: part.providerExecuted
+              ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+              ...dynamic != null ? { dynamic } : {}
             });
             break;
           }
           case "tool-error": {
+            const dynamic = isDynamic(part.toolCallId);
             controller.enqueue({
               type: "tool-output-error",
               toolCallId: part.toolCallId,
               errorText: onError(part.error),
-              providerExecuted: part.providerExecuted
+              ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+              ...dynamic != null ? { dynamic } : {}
             });
             break;
           }
@@ -50363,32 +50951,32 @@ var marker152 = `vercel.ai.error.${name15}`;
 var symbol152 = Symbol.for(marker152);
 var _a152;
 _a152 = symbol152;
-var ClientOrServerImplementationSchema = exports_external2.object({
+var ClientOrServerImplementationSchema = exports_external2.looseObject({
   name: exports_external2.string(),
   version: exports_external2.string()
-}).passthrough();
-var BaseParamsSchema = exports_external2.object({
-  _meta: exports_external2.optional(exports_external2.object({}).passthrough())
-}).passthrough();
+});
+var BaseParamsSchema = exports_external2.looseObject({
+  _meta: exports_external2.optional(exports_external2.object({}).loose())
+});
 var ResultSchema = BaseParamsSchema;
 var RequestSchema = exports_external2.object({
   method: exports_external2.string(),
   params: exports_external2.optional(BaseParamsSchema)
 });
-var ServerCapabilitiesSchema = exports_external2.object({
-  experimental: exports_external2.optional(exports_external2.object({}).passthrough()),
-  logging: exports_external2.optional(exports_external2.object({}).passthrough()),
-  prompts: exports_external2.optional(exports_external2.object({
+var ServerCapabilitiesSchema = exports_external2.looseObject({
+  experimental: exports_external2.optional(exports_external2.object({}).loose()),
+  logging: exports_external2.optional(exports_external2.object({}).loose()),
+  prompts: exports_external2.optional(exports_external2.looseObject({
     listChanged: exports_external2.optional(exports_external2.boolean())
-  }).passthrough()),
-  resources: exports_external2.optional(exports_external2.object({
+  })),
+  resources: exports_external2.optional(exports_external2.looseObject({
     subscribe: exports_external2.optional(exports_external2.boolean()),
     listChanged: exports_external2.optional(exports_external2.boolean())
-  }).passthrough()),
-  tools: exports_external2.optional(exports_external2.object({
+  })),
+  tools: exports_external2.optional(exports_external2.looseObject({
     listChanged: exports_external2.optional(exports_external2.boolean())
-  }).passthrough())
-}).passthrough();
+  }))
+});
 var InitializeResultSchema = ResultSchema.extend({
   protocolVersion: exports_external2.string(),
   capabilities: ServerCapabilitiesSchema,
@@ -50403,35 +50991,35 @@ var ToolSchema = exports_external2.object({
   description: exports_external2.optional(exports_external2.string()),
   inputSchema: exports_external2.object({
     type: exports_external2.literal("object"),
-    properties: exports_external2.optional(exports_external2.object({}).passthrough())
-  }).passthrough()
-}).passthrough();
+    properties: exports_external2.optional(exports_external2.object({}).loose())
+  }).loose()
+}).loose();
 var ListToolsResultSchema = PaginatedResultSchema.extend({
   tools: exports_external2.array(ToolSchema)
 });
 var TextContentSchema = exports_external2.object({
   type: exports_external2.literal("text"),
   text: exports_external2.string()
-}).passthrough();
+}).loose();
 var ImageContentSchema = exports_external2.object({
   type: exports_external2.literal("image"),
-  data: exports_external2.string().base64(),
+  data: exports_external2.base64(),
   mimeType: exports_external2.string()
-}).passthrough();
+}).loose();
 var ResourceContentsSchema = exports_external2.object({
   uri: exports_external2.string(),
   mimeType: exports_external2.optional(exports_external2.string())
-}).passthrough();
+}).loose();
 var TextResourceContentsSchema = ResourceContentsSchema.extend({
   text: exports_external2.string()
 });
 var BlobResourceContentsSchema = ResourceContentsSchema.extend({
-  blob: exports_external2.string().base64()
+  blob: exports_external2.base64()
 });
 var EmbeddedResourceSchema = exports_external2.object({
   type: exports_external2.literal("resource"),
   resource: exports_external2.union([TextResourceContentsSchema, BlobResourceContentsSchema])
-}).passthrough();
+}).loose();
 var CallToolResultSchema = ResultSchema.extend({
   content: exports_external2.array(exports_external2.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])),
   isError: exports_external2.boolean().default(false).optional()
@@ -50503,8 +51091,8 @@ function zodSchemaToParameters(schema) {
   }
   return parameters;
 }
-function toToolInfoV1(tool) {
-  const { parameters: zodSchema2, ...rest } = tool;
+function toToolInfoV1(tool2) {
+  const { parameters: zodSchema2, ...rest } = tool2;
   const v1Parameters = zodSchemaToParameters(zodSchema2);
   const examples = zodSchema2.meta()?.examples;
   const v1Tool = {
@@ -50568,7 +51156,7 @@ function parseNestedParameters(content, parameterPrefix, childrenParams) {
 function parseAssistantMessage(assistantMessage, tools, toolNamePrefix) {
   const parameterPrefix = `${toolNamePrefix}parameter_`;
   const results = [];
-  const toolTags = tools.map((tool) => `${toolNamePrefix}${tool.name}`);
+  const toolTags = tools.map((tool2) => `${toolNamePrefix}${tool2.name}`);
   const toolPattern = toolTags.join("|");
   let remainingMessage = assistantMessage;
   let match;
@@ -50586,11 +51174,11 @@ function parseAssistantMessage(assistantMessage, tools, toolNamePrefix) {
     }
     const tagName = match[1];
     const toolName = tagName.replace(toolNamePrefix, "");
-    const tool = tools.find((t) => t.name === toolName);
+    const tool2 = tools.find((t) => t.name === toolName);
     const fullTagContent = match[0];
-    if (tool) {
+    if (tool2) {
       const params = {};
-      for (const param of tool.parameters) {
+      for (const param of tool2.parameters) {
         const paramName = `${parameterPrefix}${param.name}`;
         const escapedParamName = paramName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
         const paramRegex = new RegExp(`<${escapedParamName}>([\\s\\S]*?)<\\/${escapedParamName}>`, "gs");
@@ -50671,28 +51259,28 @@ var renderParameterValue = (key, value, parameterPrefix) => {
 ${inner}
 </${parameterPrefix}${key}>`;
 };
-var toolInfoPrompt = (tool, toolNamePrefix, parameterPrefix) => `
-## ${toolNamePrefix}${tool.name}
+var toolInfoPrompt = (tool2, toolNamePrefix, parameterPrefix) => `
+## ${toolNamePrefix}${tool2.name}
 
-Description: ${tool.description}
+Description: ${tool2.description}
 
 Parameters:
-${tool.parameters.map((param) => `- ${parameterPrefix}${param.name}: (${param.required ? "required" : "optional"})${param.allowMultiple ? " (multiple allowed)" : ""} ${param.description}`).join(`
+${tool2.parameters.map((param) => `- ${parameterPrefix}${param.name}: (${param.required ? "required" : "optional"})${param.allowMultiple ? " (multiple allowed)" : ""} ${param.description}`).join(`
 `)}
 
 Usage:
-<${toolNamePrefix}${tool.name}>
-${tool.parameters.map((param) => param.allowMultiple ? `<${parameterPrefix}${param.name}>${param.usageValue}</${parameterPrefix}${param.name}>
+<${toolNamePrefix}${tool2.name}>
+${tool2.parameters.map((param) => param.allowMultiple ? `<${parameterPrefix}${param.name}>${param.usageValue}</${parameterPrefix}${param.name}>
 <${parameterPrefix}${param.name}>${param.usageValue}</${parameterPrefix}${param.name}>` : `<${parameterPrefix}${param.name}>${param.usageValue}</${parameterPrefix}${param.name}>`).join(`
 `)}
-</${toolNamePrefix}${tool.name}>`;
-var toolInfoExamplesPrompt = (tool, example, toolNamePrefix, parameterPrefix) => `
+</${toolNamePrefix}${tool2.name}>`;
+var toolInfoExamplesPrompt = (tool2, example, toolNamePrefix, parameterPrefix) => `
 ## Example: ${example.description}
 
-<${toolNamePrefix}${tool.name}>
+<${toolNamePrefix}${tool2.name}>
 ${Object.entries(example.input).map(([name17, value]) => renderParameterValue(name17, value, parameterPrefix)).join(`
 `)}
-</${toolNamePrefix}${tool.name}>
+</${toolNamePrefix}${tool2.name}>
 `;
 var toolUsePrompt = (useNativeTool, tools, toolNamePrefix) => {
   if (useNativeTool) {
@@ -50768,14 +51356,14 @@ Always adhere to this format, ensuring every opening tag has a matching closing
 NEVER surround tool use with triple backticks (\`\`\`).
 
 # Tools
-${v1Tools.map((tool) => toolInfoPrompt(tool, toolNamePrefix, parameterPrefix)).join(`
+${v1Tools.map((tool2) => toolInfoPrompt(tool2, toolNamePrefix, parameterPrefix)).join(`
 `)}
 
 # Tool Use Examples
-${v1Tools.map((tool) => {
+${v1Tools.map((tool2) => {
     let promp = "";
-    for (const example of tool.examples ?? []) {
-      promp += toolInfoExamplesPrompt(tool, example, toolNamePrefix, parameterPrefix);
+    for (const example of tool2.examples ?? []) {
+      promp += toolInfoExamplesPrompt(tool2, example, toolNamePrefix, parameterPrefix);
     }
     return promp;
   }).join("")}
@@ -50858,7 +51446,7 @@ The following additional commands are provided by the user, and should be follow
 ${joined}`;
 };
 var responsePrompts = {
-  errorInvokeTool: (tool, error81) => `An error occurred while invoking the tool "${tool}": ${error81}`,
+  errorInvokeTool: (tool2, error82) => `An error occurred while invoking the tool "${tool2}": ${error82}`,
   requireUseTool: `Error: No tool use detected. You MUST use a tool before proceeding.
 e.g. <tool_tool_name>tool_name</tool_tool_name>
 
@@ -50868,19 +51456,19 @@ Avoid unnecessary escape characters or special characters.
 `,
   requireUseToolNative: `Error: No tool use detected. You MUST use a tool before proceeding.
 `,
-  toolResults: (tool, result) => {
+  toolResults: (tool2, result) => {
     if (typeof result === "string") {
       return [
         {
           type: "text",
-          text: `<tool_response name=${tool}>${result}</tool_response>`
+          text: `<tool_response name=${tool2}>${result}</tool_response>`
         }
       ];
     }
     return [
       {
         type: "text",
-        text: `<tool_response name=${tool}>`
+        text: `<tool_response name=${tool2}>`
       },
       ...result,
       {
@@ -50917,8 +51505,8 @@ class AgentBase {
 ${agents}`;
     }
     const handlers = {};
-    for (const tool of config3.tools) {
-      handlers[tool.name] = tool;
+    for (const tool2 of config3.tools) {
+      handlers[tool2.name] = tool2;
     }
     const policies = [];
     for (const policy of config3.policies) {
@@ -50930,8 +51518,8 @@ ${agents}`;
 ${instance.prompt}`;
         }
         if (instance.tools) {
-          for (const tool of instance.tools) {
-            handlers[tool.name] = tool;
+          for (const tool2 of instance.tools) {
+            handlers[tool2.name] = tool2;
           }
         }
       }
@@ -50945,13 +51533,13 @@ ${instance.prompt}`;
     });
     if (this.config.toolFormat === "native") {
       const tools = {};
-      for (const tool of Object.values(this.handlers)) {
-        const toolName = import_lodash.camelCase(tool.name);
+      for (const tool2 of Object.values(this.handlers)) {
+        const toolName = import_lodash.camelCase(tool2.name);
         tools[toolName] = {
-          description: tool.description,
-          inputSchema: jsonSchema(toJSONSchema(tool.parameters))
+          description: tool2.description,
+          inputSchema: jsonSchema(toJSONSchema(tool2.parameters))
         };
-        this.handlers[toolName] = tool;
+        this.handlers[toolName] = tool2;
       }
       this.#toolSet = tools;
     } else {
@@ -51071,10 +51659,10 @@ Request timeout after ${requestTimeoutSeconds} seconds. Canceling current reques
           onChunk: async ({ chunk }) => {
             resetTimeout();
             switch (chunk.type) {
-              case "text":
+              case "text-delta":
                 await this.#callback({ kind: "Text" /* Text */, agent: this, newText: chunk.text });
                 break;
-              case "reasoning":
+              case "reasoning-delta":
                 await this.#callback({ kind: "Reasoning" /* Reasoning */, agent: this, newText: chunk.text });
                 break;
               case "tool-call":
@@ -51082,8 +51670,8 @@ Request timeout after ${requestTimeoutSeconds} seconds. Canceling current reques
             }
           },
           onFinish: this.config.usageMeter.onFinishHandler(this.ai),
-          onError: async (error81) => {
-            console.error("Error in stream:", error81);
+          onError: async (error82) => {
+            console.error("Error in stream:", error82);
           },
           abortSignal: requestAbortController.signal
         };
@@ -51092,8 +51680,8 @@ Request timeout after ${requestTimeoutSeconds} seconds. Canceling current reques
         }
         const stream = streamText(streamTextOptions);
         await stream.consumeStream({
-          onError: (error81) => {
-            console.error("Error in stream:", error81);
+          onError: (error82) => {
+            console.error("Error in stream:", error82);
           }
         });
         const resp = await stream.response;
@@ -51102,14 +51690,14 @@ Request timeout after ${requestTimeoutSeconds} seconds. Canceling current reques
           clearTimeout(timeout);
           timeout = undefined;
         }
-      } catch (error81) {
-        if (error81 instanceof Error && error81.name === "AbortError") {
+      } catch (error82) {
+        if (error82 instanceof Error && error82.name === "AbortError") {
           if (this.#aborted) {
             break;
           }
           console.debug(`Request attempt ${i + 1} timed out, will retry`);
         } else {
-          console.error("Error in stream:", error81);
+          console.error("Error in stream:", error82);
         }
       } finally {
         if (timeout) {
@@ -51306,7 +51894,7 @@ Retrying request ${i + 2} of ${retryCount}`);
         }
       };
     }
-    const finalResp = toolResponses.filter((resp) => resp.type === "response").flatMap(({ tool, response: response2 }) => responsePrompts.toolResults(tool, response2));
+    const finalResp = toolResponses.filter((resp) => resp.type === "response").flatMap(({ tool: tool2, response: response2 }) => responsePrompts.toolResults(tool2, response2));
     return {
       type: "reply",
       message: {
@@ -51338,10 +51926,10 @@ Retrying request ${i + 2} of ${retryCount}`);
         return resp;
       }
       return await handler14(this.config.provider, args);
-    } catch (error81) {
+    } catch (error82) {
       return {
         type: "Error" /* Error */,
-        message: responsePrompts.errorInvokeTool(name17, error81),
+        message: responsePrompts.errorInvokeTool(name17, error82),
         canRetry: false
       };
     }
@@ -51560,8 +52148,8 @@ class CodeFixerAgent extends AgentBase {
               message: responsePrompts.commandResult(checkCommand, exitCode, stdout, stderr)
             };
           }
-        } catch (error81) {
-          console.warn(`Failed to check code using command: ${checkCommand}`, error81);
+        } catch (error82) {
+          console.warn(`Failed to check code using command: ${checkCommand}`, error82);
         }
       }
       const test = this.config.scripts?.test;
@@ -51575,8 +52163,8 @@ class CodeFixerAgent extends AgentBase {
               message: responsePrompts.commandResult(testCommand, exitCode, stdout, stderr)
             };
           }
-        } catch (error81) {
-          console.warn(`Failed to test code using command: ${testCommand}`, error81);
+        } catch (error82) {
+          console.warn(`Failed to test code using command: ${testCommand}`, error82);
         }
       }
     }
@@ -51753,8 +52341,8 @@ class CoderAgent extends AgentBase {
             message: responsePrompts.commandResult(command, exitCode, stdout, stderr)
           };
         }
-      } catch (error81) {
-        console.warn(`Failed to run ${scriptName} using command: ${command}`, error81);
+      } catch (error82) {
+        console.warn(`Failed to run ${scriptName} using command: ${command}`, error82);
       }
     }
   }
@@ -52372,10 +52960,10 @@ ${diffOutput}
       message: `\`${command}\` exited with code ${result.exitCode}:
 ${result.stderr}`
     };
-  } catch (error81) {
+  } catch (error82) {
     return {
       type: "Error" /* Error */,
-      message: error81 instanceof Error ? error81.message : String(error81)
+      message: error82 instanceof Error ? error82.message : String(error82)
     };
   }
 };
@@ -52499,8 +53087,8 @@ ${instructions}
     const content = match ? match[1] : output;
     try {
       return JSON.parse(content);
-    } catch (error81) {
-      console.error("Error parsing JSON output:", error81);
+    } catch (error82) {
+      console.error("Error parsing JSON output:", error82);
       return {
         overview: `Could not parse review output. Raw output:
 ${output}`,
@@ -52797,8 +53385,8 @@ class ZodError4 extends Error {
       return issue3.message;
     };
     const fieldErrors = { _errors: [] };
-    const processError = (error81) => {
-      for (const issue3 of error81.issues) {
+    const processError = (error82) => {
+      for (const issue3 of error82.issues) {
         if (issue3.code === "invalid_union") {
           issue3.unionErrors.map(processError);
         } else if (issue3.code === "invalid_return_type") {
@@ -52860,8 +53448,8 @@ class ZodError4 extends Error {
   }
 }
 ZodError4.create = (issues) => {
-  const error81 = new ZodError4(issues);
-  return error81;
+  const error82 = new ZodError4(issues);
+  return error82;
 };
 var errorMap2 = (issue3, _ctx) => {
   let message;
@@ -53124,8 +53712,8 @@ var handleResult2 = (ctx, result) => {
       get error() {
         if (this._error)
           return this._error;
-        const error81 = new ZodError4(ctx.common.issues);
-        this._error = error81;
+        const error82 = new ZodError4(ctx.common.issues);
+        this._error = error82;
         return this._error;
       }
     };
@@ -55709,7 +56297,7 @@ class ZodFunction2 extends ZodType4 {
       });
       return INVALID2;
     }
-    function makeArgsIssue(args, error81) {
+    function makeArgsIssue(args, error82) {
       return makeIssue2({
         data: args,
         path: ctx.path,
@@ -55721,11 +56309,11 @@ class ZodFunction2 extends ZodType4 {
         ].filter((x) => !!x),
         issueData: {
           code: ZodIssueCode4.invalid_arguments,
-          argumentsError: error81
+          argumentsError: error82
         }
       });
     }
-    function makeReturnsIssue(returns, error81) {
+    function makeReturnsIssue(returns, error82) {
       return makeIssue2({
         data: returns,
         path: ctx.path,
@@ -55737,7 +56325,7 @@ class ZodFunction2 extends ZodType4 {
         ].filter((x) => !!x),
         issueData: {
           code: ZodIssueCode4.invalid_return_type,
-          returnTypeError: error81
+          returnTypeError: error82
         }
       });
     }
@@ -55746,15 +56334,15 @@ class ZodFunction2 extends ZodType4 {
     if (this._def.returns instanceof ZodPromise4) {
       const me = this;
       return OK2(async function(...args) {
-        const error81 = new ZodError4([]);
+        const error82 = new ZodError4([]);
         const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
-          error81.addIssue(makeArgsIssue(args, e));
-          throw error81;
+          error82.addIssue(makeArgsIssue(args, e));
+          throw error82;
         });
         const result = await Reflect.apply(fn, this, parsedArgs);
         const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
-          error81.addIssue(makeReturnsIssue(result, e));
-          throw error81;
+          error82.addIssue(makeReturnsIssue(result, e));
+          throw error82;
         });
         return parsedReturns;
       });
@@ -56507,9 +57095,9 @@ function loadConfig(paths, cwd = process.cwd(), home = homedir()) {
     try {
       const globalConfig3 = readConfig(globalConfigPath);
       configs.push(globalConfig3);
-    } catch (error81) {
+    } catch (error82) {
       console.warn(`Error loading global config file: ${globalConfigPath}
-${error81}`);
+${error82}`);
     }
   }
   if (paths && paths.length > 0) {
@@ -56518,10 +57106,10 @@ ${error81}`);
       try {
         const config4 = readConfig(path);
         configs.push(config4);
-      } catch (error81) {
+      } catch (error82) {
         console.error(`Error loading config file: ${path}
-${error81}`);
-        throw error81;
+${error82}`);
+        throw error82;
       }
     }
   } else {
@@ -56529,11 +57117,11 @@ ${error81}`);
     try {
       const projectConfig = readConfig(configPath);
       configs.push(projectConfig);
-    } catch (error81) {
-      if (error81 instanceof ZodError4) {
+    } catch (error82) {
+      if (error82 instanceof ZodError4) {
         console.error(`Error in config file: ${configPath}
-${error81}`);
-        throw error81;
+${error82}`);
+        throw error82;
       }
     }
   }
@@ -57570,16 +58158,16 @@ function createPrompt(view) {
           const [content, bottomContent] = typeof nextView === "string" ? [nextView] : nextView;
           screen.render(content, bottomContent);
           effectScheduler.run();
-        } catch (error81) {
-          reject(error81);
+        } catch (error82) {
+          reject(error82);
         }
       });
       return Object.assign(promise4.then((answer) => {
         effectScheduler.clearAll();
         return answer;
-      }, (error81) => {
+      }, (error82) => {
         effectScheduler.clearAll();
-        throw error81;
+        throw error82;
       }).finally(() => {
         cleanups.forEach((cleanup) => cleanup());
         screen.done({ clearContent: Boolean(context.clearPromptOnDone) });
@@ -57665,13 +58253,13 @@ var esm_default3 = createPrompt((config4, done) => {
   if (defaultValue && status !== "done" && !value) {
     defaultStr = theme.style.defaultAnswer(defaultValue);
   }
-  let error81 = "";
+  let error82 = "";
   if (errorMsg) {
-    error81 = theme.style.error(errorMsg);
+    error82 = theme.style.error(errorMsg);
   }
   return [
     [prefix, message, defaultStr, formattedValue].filter((v) => v !== undefined).join(" "),
-    error81
+    error82
   ];
 });
 // ../../node_modules/@inquirer/select/dist/esm/index.js
@@ -57983,8 +58571,8 @@ async function searchFiles(path, regex, filePattern, cwd, excludeFiles) {
 `).filter(Boolean);
       results.push(...lines);
     });
-    rg.on("error", (error81) => {
-      reject(new Error(`Failed to execute ripgrep: ${error81.message}`));
+    rg.on("error", (error82) => {
+      reject(new Error(`Failed to execute ripgrep: ${error82.message}`));
     });
     rg.on("close", (code) => {
       if (code !== 0 && code !== 1) {
@@ -58095,9 +58683,9 @@ var getProvider = (_agentName, _config, options = {}) => {
           throw new Error(`HTTP error! status: ${response.status}`);
         }
         return await response.text();
-      } catch (error81) {
-        console.error("Error fetching URL:", error81);
-        throw error81;
+      } catch (error82) {
+        console.error("Error fetching URL:", error82);
+        throw error82;
       }
     }
   };
@@ -58378,6 +58966,9 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
   if (env.TERM === "xterm-kitty") {
     return 3;
   }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
   if ("TERM_PROGRAM" in env) {
     const version3 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
     switch (env.TERM_PROGRAM) {
@@ -58761,10 +59352,10 @@ Tool error:`, event.tool));
 
 ======== Tool Call Stats ========`);
         if (toolCallStats.size > 0) {
-          const tableData = [...toolCallStats.entries()].map(([tool2, stats]) => {
+          const tableData = [...toolCallStats.entries()].map(([tool3, stats]) => {
             const successRate = stats.calls > 0 ? stats.success / stats.calls * 100 : 0;
             return {
-              "Tool Name": tool2,
+              "Tool Name": tool3,
               Calls: stats.calls,
               Success: stats.success,
               Errors: stats.errors,