@opencx/widget-react-headless 4.0.62 → 5.0.0-beta.0

package/dist/index.js

@@ -1,273 +1,4795 @@
-import E, { createContext as v, useRef as y, useState as b, useMemo as m, useEffect as C, useContext as F, useSyncExternalStore as k } from "react";
-import { WidgetCtx as T } from "@opencx/widget-core";
-import { v4 as W } from "uuid";
-const O = "4.0.62";
-class P {
+import V, { useSyncExternalStore as Oe, useRef as D, useCallback as U, useEffect as $, useMemo as X, useState as Z, createContext as Ue, useContext as qe } from "react";
+import { isAgentStreamKeepalive as Zt, isRecord as Rr, isTurnSteeredPart as Or, buildSendMessageBody as Pr, log as q, genUuid as yt, WidgetCtx as Nr, resolveSidebarMode as jr, resolveSidebarSide as Dr, normalizeCompanionLayouts as Lr, resolveCompanionDefaultLayout as Fr } from "@opencx/widget-core";
+import * as bt from "zod/v4";
+import { z as s } from "zod/v4";
+import { ZodFirstPartyTypeKind as C } from "zod/v3";
+import "react/jsx-runtime";
+import { z } from "zod";
+import { v4 as kr } from "uuid";
+const $r = "5.0.0-beta.0";
+class Ur {
   constructor(t) {
     this.components = [];
-    const { components: n } = t;
-    if (n && n.forEach((o) => this.register(o)), this.components.length === 0)
+    const { components: r } = t;
+    if (r && r.forEach((a) => this.register(a)), this.components.length === 0)
       throw new Error("No components registered");
     if (!this.get("fallback"))
       throw new Error("No fallback component registered");
   }
   // TODO test that this registers or replaces the component
   register(t) {
-    const n = this.components.findIndex((o) => o.key === t.key);
-    return n !== -1 ? this.components[n] = t : this.components.push(t), this;
+    const r = this.components.findIndex((a) => a.key === t.key);
+    return r !== -1 ? this.components[r] = t : this.components.push(t), this;
   }
   get(t) {
-    const n = this.components.find(
-      (o) => o.key.toUpperCase() === t.toUpperCase()
+    const r = this.components.find(
+      (a) => a.key.toUpperCase() === t.toUpperCase()
     );
-    return n || null;
+    return r || null;
   }
   getComponent(t) {
-    var n;
-    return (n = this.get(t)) == null ? void 0 : n.component;
+    var r;
+    return (r = this.get(t)) == null ? void 0 : r.component;
   }
 }
-const U = v(null);
-function B({
+function de(e) {
+  return Oe(e.subscribe, e.get, e.get);
+}
+function qr({
+  turnSources: e,
+  liveItems: t,
+  isStreaming: r,
+  lastMessageIsFromUser: a
+}) {
+  var o;
+  if (r || a) return null;
+  const n = t.length > 0 ? t : (o = e.at(-1)) == null ? void 0 : o.items;
+  return n ? Zr(n) : null;
+}
+function Zr(e) {
+  for (let t = e.length - 1; t >= 0; t--) {
+    const r = e[t];
+    if ((r == null ? void 0 : r.kind) === "questions") return r.request;
+  }
+  return null;
+}
+var zt = "vercel.ai.error", zr = Symbol.for(zt), Et, St, re = class Bt extends (St = Error, Et = zr, St) {
+  /**
+   * Creates an AI SDK Error.
+   *
+   * @param {Object} params - The parameters for creating the error.
+   * @param {string} params.name - The name of the error.
+   * @param {string} params.message - The error message.
+   * @param {unknown} [params.cause] - The underlying cause of the error.
+   */
+  constructor({
+    name: t,
+    message: r,
+    cause: a
+  }) {
+    super(r), this[Et] = !0, this.name = t, this.cause = a;
+  }
+  /**
+   * Checks if the given error is an AI SDK Error.
+   * @param {unknown} error - The error to check.
+   * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
+   */
+  static isInstance(t) {
+    return Bt.hasMarker(t, zt);
+  }
+  static hasMarker(t, r) {
+    const a = Symbol.for(r);
+    return t != null && typeof t == "object" && a in t && typeof t[a] == "boolean" && t[a] === !0;
+  }
+};
+function Wt(e) {
+  return e == null ? "unknown error" : typeof e == "string" ? e : e instanceof Error ? e.toString() : JSON.stringify(e);
+}
+var Vt = "AI_InvalidArgumentError", Jt = `vercel.ai.error.${Vt}`, Br = Symbol.for(Jt), It, _t, Wr = class extends (_t = re, It = Br, _t) {
+  constructor({
+    message: e,
+    cause: t,
+    argument: r
+  }) {
+    super({ name: Vt, message: e, cause: t }), this[It] = !0, this.argument = r;
+  }
+  static isInstance(e) {
+    return re.hasMarker(e, Jt);
+  }
+}, Kt = "AI_JSONParseError", Yt = `vercel.ai.error.${Kt}`, Vr = Symbol.for(Yt), wt, Mt, Tt = class extends (Mt = re, wt = Vr, Mt) {
+  constructor({ text: e, cause: t }) {
+    super({
+      name: Kt,
+      message: `JSON parsing failed: Text: ${e}.
+Error message: ${Wt(t)}`,
+      cause: t
+    }), this[wt] = !0, this.text = e;
+  }
+  static isInstance(e) {
+    return re.hasMarker(e, Yt);
+  }
+}, Ht = "AI_TypeValidationError", Gt = `vercel.ai.error.${Ht}`, Jr = Symbol.for(Gt), At, Ct, we = class et extends (Ct = re, At = Jr, Ct) {
+  constructor({
+    value: t,
+    cause: r,
+    context: a
+  }) {
+    let n = "Type validation failed";
+    if (a != null && a.field && (n += ` for ${a.field}`), a != null && a.entityName || a != null && a.entityId) {
+      n += " (";
+      const o = [];
+      a.entityName && o.push(a.entityName), a.entityId && o.push(`id: "${a.entityId}"`), n += o.join(", "), n += ")";
+    }
+    super({
+      name: Ht,
+      message: `${n}: Value: ${JSON.stringify(t)}.
+Error message: ${Wt(r)}`,
+      cause: r
+    }), this[At] = !0, this.value = t, this.context = a;
+  }
+  static isInstance(t) {
+    return re.hasMarker(t, Gt);
+  }
+  /**
+   * Wraps an error into a TypeValidationError.
+   * If the cause is already a TypeValidationError with the same value and context, it returns the cause.
+   * Otherwise, it creates a new TypeValidationError.
+   *
+   * @param {Object} params - The parameters for wrapping the error.
+   * @param {unknown} params.value - The value that failed validation.
+   * @param {unknown} params.cause - The original error or cause of the validation failure.
+   * @param {TypeValidationContext} params.context - Optional context about what is being validated.
+   * @returns {TypeValidationError} A TypeValidationError instance.
+   */
+  static wrap({
+    value: t,
+    cause: r,
+    context: a
+  }) {
+    var n, o, u;
+    return et.isInstance(r) && r.value === t && ((n = r.context) == null ? void 0 : n.field) === (a == null ? void 0 : a.field) && ((o = r.context) == null ? void 0 : o.entityName) === (a == null ? void 0 : a.entityName) && ((u = r.context) == null ? void 0 : u.entityId) === (a == null ? void 0 : a.entityId) ? r : new et({ value: t, cause: r, context: a });
+  }
+};
+class Ke extends Error {
+  constructor(t, r) {
+    super(t), this.name = "ParseError", this.type = r.type, this.field = r.field, this.value = r.value, this.line = r.line;
+  }
+}
+const xt = 10, Kr = 13, fe = 32;
+function Ye(e) {
+}
+function Yr(e) {
+  if (typeof e == "function")
+    throw new TypeError(
+      "`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?"
+    );
+  const { onEvent: t = Ye, onError: r = Ye, onRetry: a = Ye, onComment: n, maxBufferSize: o } = e, u = [];
+  let i = 0, g = !0, c, l = "", p = 0, v, h = !1;
+  function T(f) {
+    if (h)
+      throw new Error(
+        "Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing."
+      );
+    if (g && (g = !1, f.charCodeAt(0) === 239 && f.charCodeAt(1) === 187 && f.charCodeAt(2) === 191 && (f = f.slice(3))), u.length === 0) {
+      const y = _(f);
+      y !== "" && (u.push(y), i = y.length), A();
+      return;
+    }
+    if (f.indexOf(`
+`) === -1 && f.indexOf("\r") === -1) {
+      u.push(f), i += f.length, A();
+      return;
+    }
+    u.push(f);
+    const m = u.join("");
+    u.length = 0, i = 0;
+    const b = _(m);
+    b !== "" && (u.push(b), i = b.length), A();
+  }
+  function A() {
+    o !== void 0 && (i + l.length <= o || (h = !0, u.length = 0, i = 0, c = void 0, l = "", p = 0, v = void 0, r(
+      new Ke(`Buffered data exceeded max buffer size of ${o} characters`, {
+        type: "max-buffer-size-exceeded"
+      })
+    )));
+  }
+  function _(f) {
+    let m = 0;
+    if (f.indexOf("\r") === -1) {
+      let b = f.indexOf(`
+`, m);
+      for (; b !== -1; ) {
+        if (m === b) {
+          p > 0 && t({ id: c, event: v, data: l }), c = void 0, l = "", p = 0, v = void 0, m = b + 1, b = f.indexOf(`
+`, m);
+          continue;
+        }
+        const y = f.charCodeAt(m);
+        if (Rt(f, m, y)) {
+          const w = f.charCodeAt(m + 5) === fe ? m + 6 : m + 5, j = f.slice(w, b);
+          if (p === 0 && f.charCodeAt(b + 1) === xt) {
+            t({ id: c, event: v, data: j }), c = void 0, l = "", v = void 0, m = b + 2, b = f.indexOf(`
+`, m);
+            continue;
+          }
+          l = p === 0 ? j : `${l}
+${j}`, p++;
+        } else Ot(f, m, y) ? v = f.slice(
+          f.charCodeAt(m + 6) === fe ? m + 7 : m + 6,
+          b
+        ) || void 0 : S(f, m, b);
+        m = b + 1, b = f.indexOf(`
+`, m);
+      }
+      return f.slice(m);
+    }
+    for (; m < f.length; ) {
+      const b = f.indexOf("\r", m), y = f.indexOf(`
+`, m);
+      let w = -1;
+      if (b !== -1 && y !== -1 ? w = b < y ? b : y : b !== -1 ? b === f.length - 1 ? w = -1 : w = b : y !== -1 && (w = y), w === -1)
+        break;
+      S(f, m, w), m = w + 1, f.charCodeAt(m - 1) === Kr && f.charCodeAt(m) === xt && m++;
+    }
+    return f.slice(m);
+  }
+  function S(f, m, b) {
+    if (m === b) {
+      R();
+      return;
+    }
+    const y = f.charCodeAt(m);
+    if (Rt(f, m, y)) {
+      const Y = f.charCodeAt(m + 5) === fe ? m + 6 : m + 5, ee = f.slice(Y, b);
+      l = p === 0 ? ee : `${l}
+${ee}`, p++;
+      return;
+    }
+    if (Ot(f, m, y)) {
+      v = f.slice(f.charCodeAt(m + 6) === fe ? m + 7 : m + 6, b) || void 0;
+      return;
+    }
+    if (y === 105 && f.charCodeAt(m + 1) === 100 && f.charCodeAt(m + 2) === 58) {
+      const Y = f.slice(f.charCodeAt(m + 3) === fe ? m + 4 : m + 3, b);
+      c = Y.includes("\0") ? void 0 : Y;
+      return;
+    }
+    if (y === 58) {
+      if (n) {
+        const Y = f.slice(m, b);
+        n(Y.slice(f.charCodeAt(m + 1) === fe ? 2 : 1));
+      }
+      return;
+    }
+    const w = f.slice(m, b), j = w.indexOf(":");
+    if (j === -1) {
+      I(w, "", w);
+      return;
+    }
+    const se = w.slice(0, j), Be = w.charCodeAt(j + 1) === fe ? 2 : 1, We = w.slice(j + Be);
+    I(se, We, w);
+  }
+  function I(f, m, b) {
+    switch (f) {
+      case "event":
+        v = m || void 0;
+        break;
+      case "data":
+        l = p === 0 ? m : `${l}
+${m}`, p++;
+        break;
+      case "id":
+        c = m.includes("\0") ? void 0 : m;
+        break;
+      case "retry":
+        /^\d+$/.test(m) ? a(parseInt(m, 10)) : r(
+          new Ke(`Invalid \`retry\` value: "${m}"`, {
+            type: "invalid-retry",
+            value: m,
+            line: b
+          })
+        );
+        break;
+      default:
+        r(
+          new Ke(
+            `Unknown field "${f.length > 20 ? `${f.slice(0, 20)}…` : f}"`,
+            { type: "unknown-field", field: f, value: m, line: b }
+          )
+        );
+        break;
+    }
+  }
+  function R() {
+    p > 0 && t({
+      id: c,
+      event: v,
+      data: l
+    }), c = void 0, l = "", p = 0, v = void 0;
+  }
+  function d(f = {}) {
+    if (f.consume && u.length > 0) {
+      const m = u.join("");
+      S(m, 0, m.length);
+    }
+    g = !0, c = void 0, l = "", p = 0, v = void 0, u.length = 0, i = 0, h = !1;
+  }
+  return { feed: T, reset: d };
+}
+function Rt(e, t, r) {
+  return r === 100 && e.charCodeAt(t + 1) === 97 && e.charCodeAt(t + 2) === 116 && e.charCodeAt(t + 3) === 97 && e.charCodeAt(t + 4) === 58;
+}
+function Ot(e, t, r) {
+  return r === 101 && e.charCodeAt(t + 1) === 118 && e.charCodeAt(t + 2) === 101 && e.charCodeAt(t + 3) === 110 && e.charCodeAt(t + 4) === 116 && e.charCodeAt(t + 5) === 58;
+}
+class Hr extends TransformStream {
+  constructor({ onError: t, onRetry: r, onComment: a, maxBufferSize: n } = {}) {
+    let o;
+    super({
+      start(u) {
+        o = Yr({
+          onEvent: (i) => {
+            u.enqueue(i);
+          },
+          onError(i) {
+            typeof t == "function" && t(i), (t === "terminate" || i.type === "max-buffer-size-exceeded") && u.error(i);
+          },
+          onRetry: r,
+          onComment: a,
+          maxBufferSize: n
+        });
+      },
+      transform(u) {
+        o.feed(u);
+      }
+    });
+  }
+}
+new TextDecoder();
+var J = ({
+  prefix: e,
+  size: t = 16,
+  alphabet: r = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  separator: a = "-"
+} = {}) => {
+  const n = () => {
+    const o = r.length, u = new Array(t);
+    for (let i = 0; i < t; i++)
+      u[i] = r[Math.random() * o | 0];
+    return u.join("");
+  };
+  if (e == null)
+    return n;
+  if (r.includes(a))
+    throw new Wr({
+      argument: "separator",
+      message: `The separator "${a}" must not be part of the alphabet "${r}".`
+    });
+  return () => `${e}${a}${n()}`;
+}, Gr = J();
+function Ee(e) {
+  if (e == null)
+    return {};
+  const t = {};
+  if (e instanceof Headers)
+    e.forEach((r, a) => {
+      t[a.toLowerCase()] = r;
+    });
+  else {
+    Array.isArray(e) || (e = Object.entries(e));
+    for (const [r, a] of e)
+      a != null && (t[r.toLowerCase()] = a);
+  }
+  return t;
+}
+function Qr(e) {
+  var t, r;
+  return (r = (t = globalThis.Buffer) == null ? void 0 : t.isBuffer(e)) != null ? r : !1;
+}
+var Xr = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/, ea = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+function Pt(e) {
+  const t = JSON.parse(e);
+  return t === null || typeof t != "object" || Xr.test(e) === !1 && ea.test(e) === !1 ? t : ta(t);
+}
+function ta(e) {
+  let t = [e];
+  for (; t.length; ) {
+    const r = t;
+    t = [];
+    for (const a of r) {
+      if (Object.prototype.hasOwnProperty.call(a, "__proto__"))
+        throw new SyntaxError("Object contains forbidden prototype property");
+      if (Object.prototype.hasOwnProperty.call(a, "constructor") && a.constructor !== null && typeof a.constructor == "object" && Object.prototype.hasOwnProperty.call(a.constructor, "prototype"))
+        throw new SyntaxError("Object contains forbidden prototype property");
+      for (const n in a) {
+        const o = a[n];
+        o && typeof o == "object" && t.push(o);
+      }
+    }
+  }
+  return e;
+}
+function ra(e) {
+  const { stackTraceLimit: t } = Error;
+  try {
+    Error.stackTraceLimit = 0;
+  } catch {
+    return Pt(e);
+  }
+  try {
+    return Pt(e);
+  } finally {
+    Error.stackTraceLimit = t;
+  }
+}
+function lt(e) {
+  if (e.type === "object" || Array.isArray(e.type) && e.type.includes("object")) {
+    e.additionalProperties = !1;
+    const { properties: r } = e;
+    if (r != null)
+      for (const a of Object.keys(r))
+        r[a] = me(r[a]);
+  }
+  e.items != null && (e.items = Array.isArray(e.items) ? e.items.map(me) : me(e.items)), e.anyOf != null && (e.anyOf = e.anyOf.map(me)), e.allOf != null && (e.allOf = e.allOf.map(me)), e.oneOf != null && (e.oneOf = e.oneOf.map(me));
+  const { definitions: t } = e;
+  if (t != null)
+    for (const r of Object.keys(t))
+      t[r] = me(t[r]);
+  return e;
+}
+function me(e) {
+  return typeof e == "boolean" ? e : lt(e);
+}
+var aa = /* @__PURE__ */ Symbol(
+  "Let zodToJsonSchema decide on which parser to use"
+), Nt = {
+  name: void 0,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  allowedAdditionalProperties: !0,
+  rejectedAdditionalProperties: !1,
+  definitionPath: "definitions",
+  strictUnions: !1,
+  definitions: {},
+  errorMessages: !1,
+  patternStrategy: "escape",
+  applyRegexFlags: !1,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref"
+}, sa = (e) => typeof e == "string" ? {
+  ...Nt,
+  name: e
+} : {
+  ...Nt,
+  ...e
+};
+function B() {
+  return {};
+}
+function na(e, t) {
+  var r, a, n;
+  const o = {
+    type: "array"
+  };
+  return (r = e.type) != null && r._def && ((n = (a = e.type) == null ? void 0 : a._def) == null ? void 0 : n.typeName) !== C.ZodAny && (o.items = P(e.type._def, {
+    ...t,
+    currentPath: [...t.currentPath, "items"]
+  })), e.minLength && (o.minItems = e.minLength.value), e.maxLength && (o.maxItems = e.maxLength.value), e.exactLength && (o.minItems = e.exactLength.value, o.maxItems = e.exactLength.value), o;
+}
+function ia(e) {
+  const t = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!e.checks) return t;
+  for (const r of e.checks)
+    switch (r.kind) {
+      case "min":
+        r.inclusive ? t.minimum = r.value : t.exclusiveMinimum = r.value;
+        break;
+      case "max":
+        r.inclusive ? t.maximum = r.value : t.exclusiveMaximum = r.value;
+        break;
+      case "multipleOf":
+        t.multipleOf = r.value;
+        break;
+    }
+  return t;
+}
+function oa() {
+  return { type: "boolean" };
+}
+function Qt(e, t) {
+  return P(e.type._def, t);
+}
+var la = (e, t) => P(e.innerType._def, t);
+function Xt(e, t, r) {
+  const a = r ?? t.dateStrategy;
+  if (Array.isArray(a))
+    return {
+      anyOf: a.map((n) => Xt(e, t, n))
+    };
+  switch (a) {
+    case "string":
+    case "format:date-time":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "format:date":
+      return {
+        type: "string",
+        format: "date"
+      };
+    case "integer":
+      return ua(e);
+  }
+}
+var ua = (e) => {
+  const t = {
+    type: "integer",
+    format: "unix-time"
+  };
+  for (const r of e.checks)
+    switch (r.kind) {
+      case "min":
+        t.minimum = r.value;
+        break;
+      case "max":
+        t.maximum = r.value;
+        break;
+    }
+  return t;
+};
+function ca(e, t) {
+  return {
+    ...P(e.innerType._def, t),
+    default: e.defaultValue()
+  };
+}
+function da(e, t) {
+  return t.effectStrategy === "input" ? P(e.schema._def, t) : B();
+}
+function pa(e) {
+  return {
+    type: "string",
+    enum: Array.from(e.values)
+  };
+}
+var fa = (e) => "type" in e && e.type === "string" ? !1 : "allOf" in e;
+function ma(e, t) {
+  const r = [
+    P(e.left._def, {
+      ...t,
+      currentPath: [...t.currentPath, "allOf", "0"]
+    }),
+    P(e.right._def, {
+      ...t,
+      currentPath: [...t.currentPath, "allOf", "1"]
+    })
+  ].filter((n) => !!n), a = [];
+  return r.forEach((n) => {
+    if (fa(n))
+      a.push(...n.allOf);
+    else {
+      let o = n;
+      if ("additionalProperties" in n && n.additionalProperties === !1) {
+        const { additionalProperties: u, ...i } = n;
+        o = i;
+      }
+      a.push(o);
+    }
+  }), a.length ? { allOf: a } : void 0;
+}
+function ga(e) {
+  const t = typeof e.value;
+  return t !== "bigint" && t !== "number" && t !== "boolean" && t !== "string" ? {
+    type: Array.isArray(e.value) ? "array" : "object"
+  } : {
+    type: t === "bigint" ? "integer" : t,
+    const: e.value
+  };
+}
+var He = void 0, G = {
+  /**
+   * `c` was changed to `[cC]` to replicate /i flag
+   */
+  cuid: /^[cC][^\s-]{8,}$/,
+  cuid2: /^[0-9a-z]+$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  /**
+   * `a-z` was added to replicate /i flag
+   */
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  /**
+   * Constructed a valid Unicode RegExp
+   *
+   * Lazily instantiate since this type of regex isn't supported
+   * in all envs (e.g. React Native).
+   *
+   * See:
+   * https://github.com/colinhacks/zod/issues/2433
+   * Fix in Zod:
+   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+   */
+  emoji: () => (He === void 0 && (He = RegExp(
+    "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
+    "u"
+  )), He),
+  /**
+   * Unused
+   */
+  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+  /**
+   * Unused
+   */
+  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+  /**
+   * Unused
+   */
+  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+  nanoid: /^[a-zA-Z0-9_-]{21}$/,
+  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+};
+function er(e, t) {
+  const r = {
+    type: "string"
+  };
+  if (e.checks)
+    for (const a of e.checks)
+      switch (a.kind) {
+        case "min":
+          r.minLength = typeof r.minLength == "number" ? Math.max(r.minLength, a.value) : a.value;
+          break;
+        case "max":
+          r.maxLength = typeof r.maxLength == "number" ? Math.min(r.maxLength, a.value) : a.value;
+          break;
+        case "email":
+          switch (t.emailStrategy) {
+            case "format:email":
+              Q(r, "email", a.message, t);
+              break;
+            case "format:idn-email":
+              Q(r, "idn-email", a.message, t);
+              break;
+            case "pattern:zod":
+              k(r, G.email, a.message, t);
+              break;
+          }
+          break;
+        case "url":
+          Q(r, "uri", a.message, t);
+          break;
+        case "uuid":
+          Q(r, "uuid", a.message, t);
+          break;
+        case "regex":
+          k(r, a.regex, a.message, t);
+          break;
+        case "cuid":
+          k(r, G.cuid, a.message, t);
+          break;
+        case "cuid2":
+          k(r, G.cuid2, a.message, t);
+          break;
+        case "startsWith":
+          k(
+            r,
+            RegExp(`^${Ge(a.value, t)}`),
+            a.message,
+            t
+          );
+          break;
+        case "endsWith":
+          k(
+            r,
+            RegExp(`${Ge(a.value, t)}$`),
+            a.message,
+            t
+          );
+          break;
+        case "datetime":
+          Q(r, "date-time", a.message, t);
+          break;
+        case "date":
+          Q(r, "date", a.message, t);
+          break;
+        case "time":
+          Q(r, "time", a.message, t);
+          break;
+        case "duration":
+          Q(r, "duration", a.message, t);
+          break;
+        case "length":
+          r.minLength = typeof r.minLength == "number" ? Math.max(r.minLength, a.value) : a.value, r.maxLength = typeof r.maxLength == "number" ? Math.min(r.maxLength, a.value) : a.value;
+          break;
+        case "includes": {
+          k(
+            r,
+            RegExp(Ge(a.value, t)),
+            a.message,
+            t
+          );
+          break;
+        }
+        case "ip": {
+          a.version !== "v6" && Q(r, "ipv4", a.message, t), a.version !== "v4" && Q(r, "ipv6", a.message, t);
+          break;
+        }
+        case "base64url":
+          k(r, G.base64url, a.message, t);
+          break;
+        case "jwt":
+          k(r, G.jwt, a.message, t);
+          break;
+        case "cidr": {
+          a.version !== "v6" && k(r, G.ipv4Cidr, a.message, t), a.version !== "v4" && k(r, G.ipv6Cidr, a.message, t);
+          break;
+        }
+        case "emoji":
+          k(r, G.emoji(), a.message, t);
+          break;
+        case "ulid": {
+          k(r, G.ulid, a.message, t);
+          break;
+        }
+        case "base64": {
+          switch (t.base64Strategy) {
+            case "format:binary": {
+              Q(r, "binary", a.message, t);
+              break;
+            }
+            case "contentEncoding:base64": {
+              r.contentEncoding = "base64";
+              break;
+            }
+            case "pattern:zod": {
+              k(r, G.base64, a.message, t);
+              break;
+            }
+          }
+          break;
+        }
+        case "nanoid":
+          k(r, G.nanoid, a.message, t);
+      }
+  return r;
+}
+function Ge(e, t) {
+  return t.patternStrategy === "escape" ? ha(e) : e;
+}
+var va = new Set(
+  "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
+);
+function ha(e) {
+  let t = "";
+  for (let r = 0; r < e.length; r++)
+    va.has(e[r]) || (t += "\\"), t += e[r];
+  return t;
+}
+function Q(e, t, r, a) {
+  var n;
+  e.format || (n = e.anyOf) != null && n.some((o) => o.format) ? (e.anyOf || (e.anyOf = []), e.format && (e.anyOf.push({
+    format: e.format
+  }), delete e.format), e.anyOf.push({
+    format: t,
+    ...r && a.errorMessages && { errorMessage: { format: r } }
+  })) : e.format = t;
+}
+function k(e, t, r, a) {
+  var n;
+  e.pattern || (n = e.allOf) != null && n.some((o) => o.pattern) ? (e.allOf || (e.allOf = []), e.pattern && (e.allOf.push({
+    pattern: e.pattern
+  }), delete e.pattern), e.allOf.push({
+    pattern: jt(t, a),
+    ...r && a.errorMessages && { errorMessage: { pattern: r } }
+  })) : e.pattern = jt(t, a);
+}
+function jt(e, t) {
+  var r;
+  if (!t.applyRegexFlags || !e.flags)
+    return e.source;
+  const a = {
+    i: e.flags.includes("i"),
+    // Case-insensitive
+    m: e.flags.includes("m"),
+    // `^` and `$` matches adjacent to newline characters
+    s: e.flags.includes("s")
+    // `.` matches newlines
+  }, n = a.i ? e.source.toLowerCase() : e.source;
+  let o = "", u = !1, i = !1, g = !1;
+  for (let c = 0; c < n.length; c++) {
+    if (u) {
+      o += n[c], u = !1;
+      continue;
+    }
+    if (a.i) {
+      if (i) {
+        if (n[c].match(/[a-z]/)) {
+          g ? (o += n[c], o += `${n[c - 2]}-${n[c]}`.toUpperCase(), g = !1) : n[c + 1] === "-" && ((r = n[c + 2]) != null && r.match(/[a-z]/)) ? (o += n[c], g = !0) : o += `${n[c]}${n[c].toUpperCase()}`;
+          continue;
+        }
+      } else if (n[c].match(/[a-z]/)) {
+        o += `[${n[c]}${n[c].toUpperCase()}]`;
+        continue;
+      }
+    }
+    if (a.m) {
+      if (n[c] === "^") {
+        o += `(^|(?<=[\r
+]))`;
+        continue;
+      } else if (n[c] === "$") {
+        o += `($|(?=[\r
+]))`;
+        continue;
+      }
+    }
+    if (a.s && n[c] === ".") {
+      o += i ? `${n[c]}\r
+` : `[${n[c]}\r
+]`;
+      continue;
+    }
+    o += n[c], n[c] === "\\" ? u = !0 : i && n[c] === "]" ? i = !1 : !i && n[c] === "[" && (i = !0);
+  }
+  try {
+    new RegExp(o);
+  } catch {
+    return console.warn(
+      `Could not convert regex pattern at ${t.currentPath.join(
+        "/"
+      )} to a flag-independent form! Falling back to the flag-ignorant source`
+    ), e.source;
+  }
+  return o;
+}
+function tr(e, t) {
+  var r, a, n, o, u, i;
+  const g = {
+    type: "object",
+    additionalProperties: (r = P(e.valueType._def, {
+      ...t,
+      currentPath: [...t.currentPath, "additionalProperties"]
+    })) != null ? r : t.allowedAdditionalProperties
+  };
+  if (((a = e.keyType) == null ? void 0 : a._def.typeName) === C.ZodString && ((n = e.keyType._def.checks) != null && n.length)) {
+    const { type: c, ...l } = er(e.keyType._def, t);
+    return {
+      ...g,
+      propertyNames: l
+    };
+  } else {
+    if (((o = e.keyType) == null ? void 0 : o._def.typeName) === C.ZodEnum)
+      return {
+        ...g,
+        propertyNames: {
+          enum: e.keyType._def.values
+        }
+      };
+    if (((u = e.keyType) == null ? void 0 : u._def.typeName) === C.ZodBranded && e.keyType._def.type._def.typeName === C.ZodString && ((i = e.keyType._def.type._def.checks) != null && i.length)) {
+      const { type: c, ...l } = Qt(
+        e.keyType._def,
+        t
+      );
+      return {
+        ...g,
+        propertyNames: l
+      };
+    }
+  }
+  return g;
+}
+function ya(e, t) {
+  if (t.mapStrategy === "record")
+    return tr(e, t);
+  const r = P(e.keyType._def, {
+    ...t,
+    currentPath: [...t.currentPath, "items", "items", "0"]
+  }) || B(), a = P(e.valueType._def, {
+    ...t,
+    currentPath: [...t.currentPath, "items", "items", "1"]
+  }) || B();
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [r, a],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+function ba(e) {
+  const t = e.values, a = Object.keys(e.values).filter((o) => typeof t[t[o]] != "number").map((o) => t[o]), n = Array.from(
+    new Set(a.map((o) => typeof o))
+  );
+  return {
+    type: n.length === 1 ? n[0] === "string" ? "string" : "number" : ["string", "number"],
+    enum: a
+  };
+}
+function Ea() {
+  return { not: B() };
+}
+function Sa() {
+  return {
+    type: "null"
+  };
+}
+var tt = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "integer",
+  ZodBoolean: "boolean",
+  ZodNull: "null"
+};
+function Ia(e, t) {
+  const r = e.options instanceof Map ? Array.from(e.options.values()) : e.options;
+  if (r.every(
+    (a) => a._def.typeName in tt && (!a._def.checks || !a._def.checks.length)
+  )) {
+    const a = r.reduce((n, o) => {
+      const u = tt[o._def.typeName];
+      return u && !n.includes(u) ? [...n, u] : n;
+    }, []);
+    return {
+      type: a.length > 1 ? a : a[0]
+    };
+  } else if (r.every((a) => a._def.typeName === "ZodLiteral" && !a.description)) {
+    const a = r.reduce(
+      (n, o) => {
+        const u = typeof o._def.value;
+        switch (u) {
+          case "string":
+          case "number":
+          case "boolean":
+            return [...n, u];
+          case "bigint":
+            return [...n, "integer"];
+          case "object":
+            if (o._def.value === null) return [...n, "null"];
+          case "symbol":
+          case "undefined":
+          case "function":
+          default:
+            return n;
+        }
+      },
+      []
+    );
+    if (a.length === r.length) {
+      const n = a.filter((o, u, i) => i.indexOf(o) === u);
+      return {
+        type: n.length > 1 ? n : n[0],
+        enum: r.reduce(
+          (o, u) => o.includes(u._def.value) ? o : [...o, u._def.value],
+          []
+        )
+      };
+    }
+  } else if (r.every((a) => a._def.typeName === "ZodEnum"))
+    return {
+      type: "string",
+      enum: r.reduce(
+        (a, n) => [
+          ...a,
+          ...n._def.values.filter((o) => !a.includes(o))
+        ],
+        []
+      )
+    };
+  return _a(e, t);
+}
+var _a = (e, t) => {
+  const r = (e.options instanceof Map ? Array.from(e.options.values()) : e.options).map(
+    (a, n) => P(a._def, {
+      ...t,
+      currentPath: [...t.currentPath, "anyOf", `${n}`]
+    })
+  ).filter(
+    (a) => !!a && (!t.strictUnions || typeof a == "object" && Object.keys(a).length > 0)
+  );
+  return r.length ? { anyOf: r } : void 0;
+};
+function wa(e, t) {
+  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(
+    e.innerType._def.typeName
+  ) && (!e.innerType._def.checks || !e.innerType._def.checks.length))
+    return {
+      type: [
+        tt[e.innerType._def.typeName],
+        "null"
+      ]
+    };
+  const r = P(e.innerType._def, {
+    ...t,
+    currentPath: [...t.currentPath, "anyOf", "0"]
+  });
+  return r && { anyOf: [r, { type: "null" }] };
+}
+function Ma(e) {
+  const t = {
+    type: "number"
+  };
+  if (!e.checks) return t;
+  for (const r of e.checks)
+    switch (r.kind) {
+      case "int":
+        t.type = "integer";
+        break;
+      case "min":
+        r.inclusive ? t.minimum = r.value : t.exclusiveMinimum = r.value;
+        break;
+      case "max":
+        r.inclusive ? t.maximum = r.value : t.exclusiveMaximum = r.value;
+        break;
+      case "multipleOf":
+        t.multipleOf = r.value;
+        break;
+    }
+  return t;
+}
+function Ta(e, t) {
+  const r = {
+    type: "object",
+    properties: {}
+  }, a = [], n = e.shape();
+  for (const u in n) {
+    let i = n[u];
+    if (i === void 0 || i._def === void 0)
+      continue;
+    const g = Ca(i), c = P(i._def, {
+      ...t,
+      currentPath: [...t.currentPath, "properties", u],
+      propertyPath: [...t.currentPath, "properties", u]
+    });
+    c !== void 0 && (r.properties[u] = c, g || a.push(u));
+  }
+  a.length && (r.required = a);
+  const o = Aa(e, t);
+  return o !== void 0 && (r.additionalProperties = o), r;
+}
+function Aa(e, t) {
+  if (e.catchall._def.typeName !== "ZodNever")
+    return P(e.catchall._def, {
+      ...t,
+      currentPath: [...t.currentPath, "additionalProperties"]
+    });
+  switch (e.unknownKeys) {
+    case "passthrough":
+      return t.allowedAdditionalProperties;
+    case "strict":
+      return t.rejectedAdditionalProperties;
+    case "strip":
+      return t.removeAdditionalStrategy === "strict" ? t.allowedAdditionalProperties : t.rejectedAdditionalProperties;
+  }
+}
+function Ca(e) {
+  try {
+    return e.isOptional();
+  } catch {
+    return !0;
+  }
+}
+var xa = (e, t) => {
+  var r;
+  if (t.currentPath.toString() === ((r = t.propertyPath) == null ? void 0 : r.toString()))
+    return P(e.innerType._def, t);
+  const a = P(e.innerType._def, {
+    ...t,
+    currentPath: [...t.currentPath, "anyOf", "1"]
+  });
+  return a ? { anyOf: [{ not: B() }, a] } : B();
+}, Ra = (e, t) => {
+  if (t.pipeStrategy === "input")
+    return P(e.in._def, t);
+  if (t.pipeStrategy === "output")
+    return P(e.out._def, t);
+  const r = P(e.in._def, {
+    ...t,
+    currentPath: [...t.currentPath, "allOf", "0"]
+  }), a = P(e.out._def, {
+    ...t,
+    currentPath: [...t.currentPath, "allOf", r ? "1" : "0"]
+  });
+  return {
+    allOf: [r, a].filter(
+      (n) => n !== void 0
+    )
+  };
+};
+function Oa(e, t) {
+  return P(e.type._def, t);
+}
+function Pa(e, t) {
+  const a = {
+    type: "array",
+    uniqueItems: !0,
+    items: P(e.valueType._def, {
+      ...t,
+      currentPath: [...t.currentPath, "items"]
+    })
+  };
+  return e.minSize && (a.minItems = e.minSize.value), e.maxSize && (a.maxItems = e.maxSize.value), a;
+}
+function Na(e, t) {
+  return e.rest ? {
+    type: "array",
+    minItems: e.items.length,
+    items: e.items.map(
+      (r, a) => P(r._def, {
+        ...t,
+        currentPath: [...t.currentPath, "items", `${a}`]
+      })
+    ).reduce(
+      (r, a) => a === void 0 ? r : [...r, a],
+      []
+    ),
+    additionalItems: P(e.rest._def, {
+      ...t,
+      currentPath: [...t.currentPath, "additionalItems"]
+    })
+  } : {
+    type: "array",
+    minItems: e.items.length,
+    maxItems: e.items.length,
+    items: e.items.map(
+      (r, a) => P(r._def, {
+        ...t,
+        currentPath: [...t.currentPath, "items", `${a}`]
+      })
+    ).reduce(
+      (r, a) => a === void 0 ? r : [...r, a],
+      []
+    )
+  };
+}
+function ja() {
+  return {
+    not: B()
+  };
+}
+function Da() {
+  return B();
+}
+var La = (e, t) => P(e.innerType._def, t), Fa = (e, t, r) => {
+  switch (t) {
+    case C.ZodString:
+      return er(e, r);
+    case C.ZodNumber:
+      return Ma(e);
+    case C.ZodObject:
+      return Ta(e, r);
+    case C.ZodBigInt:
+      return ia(e);
+    case C.ZodBoolean:
+      return oa();
+    case C.ZodDate:
+      return Xt(e, r);
+    case C.ZodUndefined:
+      return ja();
+    case C.ZodNull:
+      return Sa();
+    case C.ZodArray:
+      return na(e, r);
+    case C.ZodUnion:
+    case C.ZodDiscriminatedUnion:
+      return Ia(e, r);
+    case C.ZodIntersection:
+      return ma(e, r);
+    case C.ZodTuple:
+      return Na(e, r);
+    case C.ZodRecord:
+      return tr(e, r);
+    case C.ZodLiteral:
+      return ga(e);
+    case C.ZodEnum:
+      return pa(e);
+    case C.ZodNativeEnum:
+      return ba(e);
+    case C.ZodNullable:
+      return wa(e, r);
+    case C.ZodOptional:
+      return xa(e, r);
+    case C.ZodMap:
+      return ya(e, r);
+    case C.ZodSet:
+      return Pa(e, r);
+    case C.ZodLazy:
+      return () => e.getter()._def;
+    case C.ZodPromise:
+      return Oa(e, r);
+    case C.ZodNaN:
+    case C.ZodNever:
+      return Ea();
+    case C.ZodEffects:
+      return da(e, r);
+    case C.ZodAny:
+      return B();
+    case C.ZodUnknown:
+      return Da();
+    case C.ZodDefault:
+      return ca(e, r);
+    case C.ZodBranded:
+      return Qt(e, r);
+    case C.ZodReadonly:
+      return La(e, r);
+    case C.ZodCatch:
+      return la(e, r);
+    case C.ZodPipeline:
+      return Ra(e, r);
+    case C.ZodFunction:
+    case C.ZodVoid:
+    case C.ZodSymbol:
+      return;
+    default:
+      return /* @__PURE__ */ ((a) => {
+      })();
+  }
+}, ka = (e, t) => {
+  let r = 0;
+  for (; r < e.length && r < t.length && e[r] === t[r]; r++)
+    ;
+  return [(e.length - r).toString(), ...t.slice(r)].join("/");
+};
+function P(e, t, r = !1) {
+  var a;
+  const n = t.seen.get(e);
+  if (t.override) {
+    const g = (a = t.override) == null ? void 0 : a.call(
+      t,
+      e,
+      t,
+      n,
+      r
+    );
+    if (g !== aa)
+      return g;
+  }
+  if (n && !r) {
+    const g = $a(n, t);
+    if (g !== void 0)
+      return g;
+  }
+  const o = { def: e, path: t.currentPath, jsonSchema: void 0 };
+  t.seen.set(e, o);
+  const u = Fa(e, e.typeName, t), i = typeof u == "function" ? P(u(), t) : u;
+  if (i && Ua(e, t, i), t.postProcess) {
+    const g = t.postProcess(i, e, t);
+    return o.jsonSchema = i, g;
+  }
+  return o.jsonSchema = i, i;
+}
+var $a = (e, t) => {
+  switch (t.$refStrategy) {
+    case "root":
+      return { $ref: e.path.join("/") };
+    case "relative":
+      return { $ref: ka(t.currentPath, e.path) };
+    case "none":
+    case "seen":
+      return e.path.length < t.currentPath.length && e.path.every((r, a) => t.currentPath[a] === r) ? (console.warn(
+        `Recursive reference detected at ${t.currentPath.join(
+          "/"
+        )}! Defaulting to any`
+      ), B()) : t.$refStrategy === "seen" ? B() : void 0;
+  }
+}, Ua = (e, t, r) => (e.description && (r.description = e.description), r), qa = (e) => {
+  const t = sa(e), r = t.name !== void 0 ? [...t.basePath, t.definitionPath, t.name] : t.basePath;
+  return {
+    ...t,
+    currentPath: r,
+    propertyPath: void 0,
+    seen: new Map(
+      Object.entries(t.definitions).map(([a, n]) => [
+        n._def,
+        {
+          def: n._def,
+          path: [...t.basePath, t.definitionPath, a],
+          // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+          jsonSchema: void 0
+        }
+      ])
+    )
+  };
+}, Za = (e, t) => {
+  var r;
+  const a = qa(t);
+  let n = typeof t == "object" && t.definitions ? Object.entries(t.definitions).reduce(
+    (c, [l, p]) => {
+      var v;
+      return {
+        ...c,
+        [l]: (v = P(
+          p._def,
+          {
+            ...a,
+            currentPath: [...a.basePath, a.definitionPath, l]
+          },
+          !0
+        )) != null ? v : B()
+      };
+    },
+    {}
+  ) : void 0;
+  const o = typeof t == "string" ? t : (t == null ? void 0 : t.nameStrategy) === "title" || t == null ? void 0 : t.name, u = (r = P(
+    e._def,
+    o === void 0 ? a : {
+      ...a,
+      currentPath: [...a.basePath, a.definitionPath, o]
+    },
+    !1
+  )) != null ? r : B(), i = typeof t == "object" && t.name !== void 0 && t.nameStrategy === "title" ? t.name : void 0;
+  i !== void 0 && (u.title = i);
+  const g = o === void 0 ? n ? {
+    ...u,
+    [a.definitionPath]: n
+  } : u : {
+    $ref: [
+      ...a.$refStrategy === "relative" ? [] : a.basePath,
+      a.definitionPath,
+      o
+    ].join("/"),
+    [a.definitionPath]: {
+      ...n,
+      [o]: u
+    }
+  };
+  return g.$schema = "http://json-schema.org/draft-07/schema#", g;
+}, rt = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
+function za(e) {
+  let t;
+  return () => (t == null && (t = e()), t);
+}
+function Ze(e, {
+  validate: t
+} = {}) {
+  return {
+    [rt]: !0,
+    _type: void 0,
+    // should never be used directly
+    get jsonSchema() {
+      return typeof e == "function" && (e = e()), e;
+    },
+    validate: t
+  };
+}
+function Ba(e) {
+  return typeof e == "object" && e !== null && rt in e && e[rt] === !0 && "jsonSchema" in e && "validate" in e;
+}
+function ut(e) {
+  return e == null ? Ze({
+    type: "object",
+    properties: {},
+    additionalProperties: !1
+  }) : Ba(e) ? e : "~standard" in e ? e["~standard"].vendor === "zod" ? rr(e) : Wa(e) : e();
+}
+function Wa(e) {
+  return Ze(
+    () => {
+      if (!Va(e))
+        throw new Error(
+          `Standard schema vendor '${e["~standard"].vendor}' does not support JSON Schema conversion.`
+        );
+      return lt(
+        e["~standard"].jsonSchema.input({
+          target: "draft-07"
+        })
+      );
+    },
+    {
+      validate: async (t) => {
+        const r = await e["~standard"].validate(t);
+        return "value" in r ? { success: !0, value: r.value } : {
+          success: !1,
+          error: new we({
+            value: t,
+            cause: r.issues
+          })
+        };
+      }
+    }
+  );
+}
+function Va(e) {
+  return e["~standard"].jsonSchema != null;
+}
+function Ja(e, t) {
+  var r;
+  const a = (r = void 0) != null ? r : !1;
+  return Ze(
+    // defer json schema creation to avoid unnecessary computation when only validation is needed
+    () => Za(e, {
+      $refStrategy: a ? "root" : "none"
+    }),
+    {
+      validate: async (n) => {
+        const o = await e.safeParseAsync(n);
+        return o.success ? { success: !0, value: o.data } : { success: !1, error: o.error };
+      }
+    }
+  );
+}
+function Ka(e, t) {
+  var r;
+  const a = (r = void 0) != null ? r : !1;
+  return Ze(
+    // defer json schema creation to avoid unnecessary computation when only validation is needed
+    () => lt(
+      bt.toJSONSchema(e, {
+        target: "draft-7",
+        io: "input",
+        reused: a ? "ref" : "inline"
+      })
+    ),
+    {
+      validate: async (n) => {
+        const o = await bt.safeParseAsync(e, n);
+        return o.success ? { success: !0, value: o.data } : { success: !1, error: o.error };
+      }
+    }
+  );
+}
+function Ya(e) {
+  return "_zod" in e;
+}
+function rr(e, t) {
+  return Ya(e) ? Ka(e) : Ja(e);
+}
+async function Dt({
+  value: e,
+  schema: t,
+  context: r
+}) {
+  const a = await Ne({ value: e, schema: t, context: r });
+  if (!a.success)
+    throw we.wrap({ value: e, cause: a.error, context: r });
+  return a.value;
+}
+async function Ne({
+  value: e,
+  schema: t,
+  context: r
+}) {
+  const a = ut(t);
+  try {
+    if (a.validate == null)
+      return { success: !0, value: e, rawValue: e };
+    const n = await a.validate(e);
+    return n.success ? { success: !0, value: n.value, rawValue: e } : {
+      success: !1,
+      error: we.wrap({ value: e, cause: n.error, context: r }),
+      rawValue: e
+    };
+  } catch (n) {
+    return {
+      success: !1,
+      error: we.wrap({ value: e, cause: n, context: r }),
+      rawValue: e
+    };
+  }
+}
+async function ve({
+  text: e,
+  schema: t
+}) {
+  try {
+    const r = ra(e);
+    return t == null ? { success: !0, value: r, rawValue: r } : await Ne({ value: r, schema: t });
+  } catch (r) {
+    return {
+      success: !1,
+      error: Tt.isInstance(r) ? r : new Tt({ text: e, cause: r }),
+      rawValue: void 0
+    };
+  }
+}
+function Ha({
+  stream: e,
+  schema: t
+}) {
+  return e.pipeThrough(new TextDecoderStream()).pipeThrough(new Hr()).pipeThrough(
+    new TransformStream({
+      async transform({ data: r }, a) {
+        r !== "[DONE]" && a.enqueue(await ve({ text: r, schema: t }));
+      }
+    })
+  );
+}
+async function ue(e) {
+  return typeof e == "function" && (e = e()), Promise.resolve(e);
+}
+new TextDecoder();
+function Ga(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var Qa = Object.defineProperty, Xa = (e, t) => {
+  for (var r in t)
+    Qa(e, r, { get: t[r], enumerable: !0 });
+}, ar = "AI_NoObjectGeneratedError", sr = `vercel.ai.error.${ar}`, es = Symbol.for(sr), nr, ce = class extends re {
+  constructor({
+    message: e = "No object generated.",
+    cause: t,
+    text: r,
+    response: a,
+    usage: n,
+    finishReason: o
+  }) {
+    super({ name: ar, message: e, cause: t }), this[nr] = !0, this.text = r, this.response = a, this.usage = n, this.finishReason = o;
+  }
+  static isInstance(e) {
+    return re.hasMarker(e, sr);
+  }
+};
+nr = es;
+var ir = "AI_UIMessageStreamError", or = `vercel.ai.error.${ir}`, ts = Symbol.for(or), lr, ge = class extends re {
+  constructor({
+    chunkType: e,
+    chunkId: t,
+    message: r
+  }) {
+    super({ name: ir, message: r }), this[lr] = !0, this.chunkType = e, this.chunkId = t;
+  }
+  static isInstance(e) {
+    return re.hasMarker(e, or);
+  }
+};
+lr = ts;
+var he = s.lazy(
+  () => s.union([
+    s.null(),
+    s.string(),
+    s.number(),
+    s.boolean(),
+    s.record(s.string(), he.optional()),
+    s.array(he)
+  ])
+), M = s.record(
+  s.string(),
+  s.record(s.string(), he.optional())
+), je = s.union([
+  s.string(),
+  s.instanceof(Uint8Array),
+  s.instanceof(ArrayBuffer),
+  s.custom(Qr, { message: "Must be a Buffer" })
+]), ct = s.record(s.string(), s.string()), ur = s.object({
+  type: s.literal("text"),
+  text: s.string(),
+  providerOptions: M.optional()
+}), rs = s.object({
+  type: s.literal("image"),
+  image: s.union([
+    je,
+    s.instanceof(URL),
+    ct
+  ]),
+  mediaType: s.string().optional(),
+  providerOptions: M.optional()
+}), cr = s.discriminatedUnion("type", [
+  s.object({ type: s.literal("data"), data: je }),
+  s.object({ type: s.literal("url"), url: s.instanceof(URL) }),
+  s.object({
+    type: s.literal("reference"),
+    reference: ct
+  }),
+  s.object({ type: s.literal("text"), text: s.string() })
+]), as = s.discriminatedUnion("type", [
+  s.object({ type: s.literal("data"), data: je }),
+  s.object({ type: s.literal("url"), url: s.instanceof(URL) })
+]), dr = s.object({
+  type: s.literal("file"),
+  data: s.union([
+    cr,
+    je,
+    s.instanceof(URL),
+    ct
+  ]),
+  filename: s.string().optional(),
+  mediaType: s.string(),
+  providerOptions: M.optional()
+}), ss = s.object({
+  type: s.literal("reasoning"),
+  text: s.string(),
+  providerOptions: M.optional()
+}), ns = s.object({
+  type: s.literal("custom"),
+  kind: s.string().transform((e) => e),
+  providerOptions: M.optional()
+}), is = s.object({
+  type: s.literal("reasoning-file"),
+  data: s.union([
+    as,
+    je,
+    s.instanceof(URL)
+  ]),
+  mediaType: s.string(),
+  providerOptions: M.optional()
+}), os = s.object({
+  type: s.literal("tool-call"),
+  toolCallId: s.string(),
+  toolName: s.string(),
+  input: s.unknown(),
+  providerOptions: M.optional(),
+  providerExecuted: s.boolean().optional()
+}), ls = s.discriminatedUnion(
+  "type",
+  [
+    s.object({
+      type: s.literal("text"),
+      value: s.string(),
+      providerOptions: M.optional()
+    }),
+    s.object({
+      type: s.literal("json"),
+      value: he,
+      providerOptions: M.optional()
+    }),
+    s.object({
+      type: s.literal("execution-denied"),
+      reason: s.string().optional(),
+      providerOptions: M.optional()
+    }),
+    s.object({
+      type: s.literal("error-text"),
+      value: s.string(),
+      providerOptions: M.optional()
+    }),
+    s.object({
+      type: s.literal("error-json"),
+      value: he,
+      providerOptions: M.optional()
+    }),
+    s.object({
+      type: s.literal("content"),
+      value: s.array(
+        s.union([
+          s.object({
+            type: s.literal("text"),
+            text: s.string(),
+            providerOptions: M.optional()
+          }),
+          s.object({
+            type: s.literal("file"),
+            data: cr,
+            mediaType: s.string(),
+            filename: s.string().optional(),
+            providerOptions: M.optional()
+          }),
+          s.object({
+            // Deprecated.
+            type: s.literal("file-data"),
+            data: s.string(),
+            mediaType: s.string(),
+            filename: s.string().optional(),
+            providerOptions: M.optional()
+          }),
+          s.object({
+            // Deprecated.
+            type: s.literal("file-url"),
+            url: s.string(),
+            mediaType: s.string().optional(),
+            providerOptions: M.optional()
+          }),
+          s.object({
+            // Deprecated.
+            type: s.literal("file-id"),
+            fileId: s.union([s.string(), s.record(s.string(), s.string())]),
+            providerOptions: M.optional()
+          }),
+          s.object({
+            // Deprecated.
+            type: s.literal("file-reference"),
+            providerReference: s.record(s.string(), s.string()),
+            providerOptions: M.optional()
+          }),
+          s.object({
+            // Deprecated.
+            type: s.literal("image-data"),
+            data: s.string(),
+            mediaType: s.string(),
+            providerOptions: M.optional()
+          }),
+          s.object({
+            // Deprecated.
+            type: s.literal("image-url"),
+            url: s.string(),
+            providerOptions: M.optional()
+          }),
+          s.object({
+            // Deprecated.
+            type: s.literal("image-file-id"),
+            fileId: s.union([s.string(), s.record(s.string(), s.string())]),
+            providerOptions: M.optional()
+          }),
+          s.object({
+            // Deprecated.
+            type: s.literal("image-file-reference"),
+            providerReference: s.record(s.string(), s.string()),
+            providerOptions: M.optional()
+          }),
+          s.object({
+            type: s.literal("custom"),
+            providerOptions: M.optional()
+          })
+        ])
+      )
+    })
+  ]
+), pr = s.object({
+  type: s.literal("tool-result"),
+  toolCallId: s.string(),
+  toolName: s.string(),
+  output: ls,
+  providerOptions: M.optional()
+}), us = s.object({
+  type: s.literal("tool-approval-request"),
+  approvalId: s.string(),
+  toolCallId: s.string()
+}), cs = s.object({
+  type: s.literal("tool-approval-response"),
+  approvalId: s.string(),
+  approved: s.boolean(),
+  reason: s.string().optional()
+}), ds = s.object(
+  {
+    role: s.literal("system"),
+    content: s.string(),
+    providerOptions: M.optional()
+  }
+), ps = s.object({
+  role: s.literal("user"),
+  content: s.union([
+    s.string(),
+    s.array(s.union([ur, rs, dr]))
+  ]),
+  providerOptions: M.optional()
+}), fs = s.object({
+  role: s.literal("assistant"),
+  content: s.union([
+    s.string(),
+    s.array(
+      s.union([
+        ur,
+        ns,
+        dr,
+        ss,
+        is,
+        os,
+        pr,
+        us
+      ])
+    )
+  ]),
+  providerOptions: M.optional()
+}), ms = s.object({
+  role: s.literal("tool"),
+  content: s.array(s.union([pr, cs])),
+  providerOptions: M.optional()
+});
+s.union([
+  ds,
+  ps,
+  fs,
+  ms
+]);
+function fr(e, t) {
+  if (e === void 0 && t === void 0)
+    return;
+  if (e === void 0)
+    return t;
+  if (t === void 0)
+    return e;
+  const r = { ...e };
+  for (const a in t)
+    if (!(a === "__proto__" || a === "constructor" || a === "prototype") && Object.prototype.hasOwnProperty.call(t, a)) {
+      const n = t[a];
+      if (n === void 0)
+        continue;
+      const o = a in e ? e[a] : void 0, u = n !== null && typeof n == "object" && !Array.isArray(n) && !(n instanceof Date) && !(n instanceof RegExp), i = o != null && typeof o == "object" && !Array.isArray(o) && !(o instanceof Date) && !(o instanceof RegExp);
+      u && i ? r[a] = fr(
+        o,
+        n
+      ) : r[a] = n;
+    }
+  return r;
+}
+var gs = {};
+Xa(gs, {
+  array: () => bs,
+  choice: () => Es,
+  json: () => Ss,
+  object: () => ys,
+  text: () => hs
+});
+function vs(e) {
+  const t = ["ROOT"];
+  let r = -1, a = null, n = 0;
+  function o(l) {
+    return l >= "0" && l <= "9" || l >= "A" && l <= "F" || l >= "a" && l <= "f";
+  }
+  function u(l, p, v) {
+    switch (l) {
+      case '"': {
+        r = p, t.pop(), t.push(v), t.push("INSIDE_STRING");
+        break;
+      }
+      case "f":
+      case "t":
+      case "n": {
+        r = p, a = p, t.pop(), t.push(v), t.push("INSIDE_LITERAL");
+        break;
+      }
+      case "-": {
+        t.pop(), t.push(v), t.push("INSIDE_NUMBER");
+        break;
+      }
+      case "0":
+      case "1":
+      case "2":
+      case "3":
+      case "4":
+      case "5":
+      case "6":
+      case "7":
+      case "8":
+      case "9": {
+        r = p, t.pop(), t.push(v), t.push("INSIDE_NUMBER");
+        break;
+      }
+      case "{": {
+        r = p, t.pop(), t.push(v), t.push("INSIDE_OBJECT_START");
+        break;
+      }
+      case "[": {
+        r = p, t.pop(), t.push(v), t.push("INSIDE_ARRAY_START");
+        break;
+      }
+    }
+  }
+  function i(l, p) {
+    switch (l) {
+      case ",": {
+        t.pop(), t.push("INSIDE_OBJECT_AFTER_COMMA");
+        break;
+      }
+      case "}": {
+        r = p, t.pop();
+        break;
+      }
+    }
+  }
+  function g(l, p) {
+    switch (l) {
+      case ",": {
+        t.pop(), t.push("INSIDE_ARRAY_AFTER_COMMA");
+        break;
+      }
+      case "]": {
+        r = p, t.pop();
+        break;
+      }
+    }
+  }
+  for (let l = 0; l < e.length; l++) {
+    const p = e[l];
+    switch (t[t.length - 1]) {
+      case "ROOT":
+        u(p, l, "FINISH");
+        break;
+      case "INSIDE_OBJECT_START": {
+        switch (p) {
+          case '"': {
+            t.pop(), t.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+          case "}": {
+            r = l, t.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_COMMA": {
+        switch (p) {
+          case '"': {
+            t.pop(), t.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_KEY": {
+        switch (p) {
+          case '"': {
+            t.pop(), t.push("INSIDE_OBJECT_AFTER_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_KEY": {
+        switch (p) {
+          case ":": {
+            t.pop(), t.push("INSIDE_OBJECT_BEFORE_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_BEFORE_VALUE": {
+        u(p, l, "INSIDE_OBJECT_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        i(p, l);
+        break;
+      }
+      case "INSIDE_STRING": {
+        switch (p) {
+          case '"': {
+            t.pop(), r = l;
+            break;
+          }
+          case "\\": {
+            t.push("INSIDE_STRING_ESCAPE");
+            break;
+          }
+          default:
+            r = l;
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_START": {
+        switch (p) {
+          case "]": {
+            r = l, t.pop();
+            break;
+          }
+          default: {
+            r = l, u(p, l, "INSIDE_ARRAY_AFTER_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        switch (p) {
+          case ",": {
+            t.pop(), t.push("INSIDE_ARRAY_AFTER_COMMA");
+            break;
+          }
+          case "]": {
+            r = l, t.pop();
+            break;
+          }
+          default: {
+            r = l;
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_COMMA": {
+        u(p, l, "INSIDE_ARRAY_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_STRING_ESCAPE": {
+        t.pop(), p === "u" ? (n = 0, t.push("INSIDE_STRING_UNICODE_ESCAPE")) : r = l;
+        break;
+      }
+      case "INSIDE_STRING_UNICODE_ESCAPE": {
+        o(p) && (n++, n === 4 && (t.pop(), r = l));
+        break;
+      }
+      case "INSIDE_NUMBER": {
+        switch (p) {
+          case "0":
+          case "1":
+          case "2":
+          case "3":
+          case "4":
+          case "5":
+          case "6":
+          case "7":
+          case "8":
+          case "9": {
+            r = l;
+            break;
+          }
+          case "e":
+          case "E":
+          case "-":
+          case ".":
+            break;
+          case ",": {
+            t.pop(), t[t.length - 1] === "INSIDE_ARRAY_AFTER_VALUE" && g(p, l), t[t.length - 1] === "INSIDE_OBJECT_AFTER_VALUE" && i(p, l);
+            break;
+          }
+          case "}": {
+            t.pop(), t[t.length - 1] === "INSIDE_OBJECT_AFTER_VALUE" && i(p, l);
+            break;
+          }
+          case "]": {
+            t.pop(), t[t.length - 1] === "INSIDE_ARRAY_AFTER_VALUE" && g(p, l);
+            break;
+          }
+          default: {
+            t.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const h = e.substring(a, l + 1);
+        !"false".startsWith(h) && !"true".startsWith(h) && !"null".startsWith(h) ? (t.pop(), t[t.length - 1] === "INSIDE_OBJECT_AFTER_VALUE" ? i(p, l) : t[t.length - 1] === "INSIDE_ARRAY_AFTER_VALUE" && g(p, l)) : r = l;
+        break;
+      }
+    }
+  }
+  let c = e.slice(0, r + 1);
+  for (let l = t.length - 1; l >= 0; l--)
+    switch (t[l]) {
+      case "INSIDE_STRING": {
+        c += '"';
+        break;
+      }
+      case "INSIDE_OBJECT_KEY":
+      case "INSIDE_OBJECT_AFTER_KEY":
+      case "INSIDE_OBJECT_AFTER_COMMA":
+      case "INSIDE_OBJECT_START":
+      case "INSIDE_OBJECT_BEFORE_VALUE":
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        c += "}";
+        break;
+      }
+      case "INSIDE_ARRAY_START":
+      case "INSIDE_ARRAY_AFTER_COMMA":
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        c += "]";
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const v = e.substring(a, e.length);
+        "true".startsWith(v) ? c += "true".slice(v.length) : "false".startsWith(v) ? c += "false".slice(v.length) : "null".startsWith(v) && (c += "null".slice(v.length));
+      }
+    }
+  return c;
+}
+async function De(e) {
+  if (e === void 0)
+    return { value: void 0, state: "undefined-input" };
+  let t = await ve({ text: e });
+  return t.success ? { value: t.value, state: "successful-parse" } : (t = await ve({ text: vs(e) }), t.success ? { value: t.value, state: "repaired-parse" } : { value: void 0, state: "failed-parse" });
+}
+var hs = () => ({
+  name: "text",
+  responseFormat: Promise.resolve({ type: "text" }),
+  async parseCompleteOutput({ text: e }) {
+    return e;
+  },
+  async parsePartialOutput({ text: e }) {
+    return { partial: e };
+  },
+  createElementStreamTransform() {
+  }
+}), ys = ({
+  schema: e,
+  name: t,
+  description: r
+}) => {
+  const a = ut(e);
+  return {
+    name: "object",
+    responseFormat: ue(a.jsonSchema).then((n) => ({
+      type: "json",
+      schema: n,
+      ...t != null && { name: t },
+      ...r != null && { description: r }
+    })),
+    async parseCompleteOutput({ text: n }, o) {
+      const u = await ve({ text: n });
+      if (!u.success)
+        throw new ce({
+          message: "No object generated: could not parse the response.",
+          cause: u.error,
+          text: n,
+          response: o.response,
+          usage: o.usage,
+          finishReason: o.finishReason
+        });
+      const i = await Ne({
+        value: u.value,
+        schema: a
+      });
+      if (!i.success)
+        throw new ce({
+          message: "No object generated: response did not match schema.",
+          cause: i.error,
+          text: n,
+          response: o.response,
+          usage: o.usage,
+          finishReason: o.finishReason
+        });
+      return i.value;
+    },
+    async parsePartialOutput({ text: n }) {
+      const o = await De(n);
+      switch (o.state) {
+        case "failed-parse":
+        case "undefined-input":
+          return;
+        case "repaired-parse":
+        case "successful-parse":
+          return {
+            // Note: currently no validation of partial results:
+            partial: o.value
+          };
+      }
+    },
+    createElementStreamTransform() {
+    }
+  };
+}, bs = ({
+  element: e,
+  name: t,
+  description: r
+}) => {
+  const a = ut(e);
+  return {
+    name: "array",
+    // JSON schema that describes an array of elements:
+    responseFormat: ue(a.jsonSchema).then((n) => {
+      const { $schema: o, ...u } = n;
+      return {
+        type: "json",
+        schema: {
+          $schema: "http://json-schema.org/draft-07/schema#",
+          type: "object",
+          properties: {
+            elements: { type: "array", items: u }
+          },
+          required: ["elements"],
+          additionalProperties: !1
+        },
+        ...t != null && { name: t },
+        ...r != null && { description: r }
+      };
+    }),
+    async parseCompleteOutput({ text: n }, o) {
+      const u = await ve({ text: n });
+      if (!u.success)
+        throw new ce({
+          message: "No object generated: could not parse the response.",
+          cause: u.error,
+          text: n,
+          response: o.response,
+          usage: o.usage,
+          finishReason: o.finishReason
+        });
+      const i = u.value;
+      if (i == null || typeof i != "object" || !("elements" in i) || !Array.isArray(i.elements))
+        throw new ce({
+          message: "No object generated: response did not match schema.",
+          cause: new we({
+            value: i,
+            cause: "response must be an object with an elements array"
+          }),
+          text: n,
+          response: o.response,
+          usage: o.usage,
+          finishReason: o.finishReason
+        });
+      const g = [];
+      for (const c of i.elements) {
+        const l = await Ne({
+          value: c,
+          schema: a
+        });
+        if (!l.success)
+          throw new ce({
+            message: "No object generated: response did not match schema.",
+            cause: l.error,
+            text: n,
+            response: o.response,
+            usage: o.usage,
+            finishReason: o.finishReason
+          });
+        g.push(l.value);
+      }
+      return g;
+    },
+    async parsePartialOutput({ text: n }) {
+      const o = await De(n);
+      switch (o.state) {
+        case "failed-parse":
+        case "undefined-input":
+          return;
+        case "repaired-parse":
+        case "successful-parse": {
+          const u = o.value;
+          if (u == null || typeof u != "object" || !("elements" in u) || !Array.isArray(u.elements))
+            return;
+          const i = o.state === "repaired-parse" && u.elements.length > 0 ? u.elements.slice(0, -1) : u.elements, g = [];
+          for (const c of i) {
+            const l = await Ne({
+              value: c,
+              schema: a
+            });
+            l.success && g.push(l.value);
+          }
+          return { partial: g };
+        }
+      }
+    },
+    createElementStreamTransform() {
+      let n = 0;
+      return new TransformStream({
+        transform({ partialOutput: o }, u) {
+          if (o != null)
+            for (; n < o.length; n++)
+              u.enqueue(o[n]);
+        }
+      });
+    }
+  };
+}, Es = ({
   options: e,
-  children: t,
-  components: n,
-  storage: o,
-  loadingComponent: a
+  name: t,
+  description: r
+}) => ({
+  name: "choice",
+  // JSON schema that describes an enumeration:
+  responseFormat: Promise.resolve({
+    type: "json",
+    schema: {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      type: "object",
+      properties: {
+        result: { type: "string", enum: e }
+      },
+      required: ["result"],
+      additionalProperties: !1
+    },
+    ...t != null && { name: t },
+    ...r != null && { description: r }
+  }),
+  async parseCompleteOutput({ text: a }, n) {
+    const o = await ve({ text: a });
+    if (!o.success)
+      throw new ce({
+        message: "No object generated: could not parse the response.",
+        cause: o.error,
+        text: a,
+        response: n.response,
+        usage: n.usage,
+        finishReason: n.finishReason
+      });
+    const u = o.value;
+    if (u == null || typeof u != "object" || !("result" in u) || typeof u.result != "string" || !e.includes(u.result))
+      throw new ce({
+        message: "No object generated: response did not match schema.",
+        cause: new we({
+          value: u,
+          cause: "response must be an object that contains a choice value."
+        }),
+        text: a,
+        response: n.response,
+        usage: n.usage,
+        finishReason: n.finishReason
+      });
+    return u.result;
+  },
+  async parsePartialOutput({ text: a }) {
+    const n = await De(a);
+    switch (n.state) {
+      case "failed-parse":
+      case "undefined-input":
+        return;
+      case "repaired-parse":
+      case "successful-parse": {
+        const o = n.value;
+        if (o == null || typeof o != "object" || !("result" in o) || typeof o.result != "string")
+          return;
+        const u = e.filter(
+          (i) => i.startsWith(o.result)
+        );
+        return n.state === "successful-parse" ? u.includes(o.result) ? { partial: o.result } : void 0 : u.length === 1 ? { partial: u[0] } : void 0;
+      }
+    }
+  },
+  createElementStreamTransform() {
+  }
+}), Ss = ({
+  name: e,
+  description: t
+} = {}) => ({
+  name: "json",
+  responseFormat: Promise.resolve({
+    type: "json",
+    ...e != null && { name: e },
+    ...t != null && { description: t }
+  }),
+  async parseCompleteOutput({ text: r }, a) {
+    const n = await ve({ text: r });
+    if (!n.success)
+      throw new ce({
+        message: "No object generated: could not parse the response.",
+        cause: n.error,
+        text: r,
+        response: a.response,
+        usage: a.usage,
+        finishReason: a.finishReason
+      });
+    return n.value;
+  },
+  async parsePartialOutput({ text: r }) {
+    const a = await De(r);
+    switch (a.state) {
+      case "failed-parse":
+      case "undefined-input":
+        return;
+      case "repaired-parse":
+      case "successful-parse":
+        return a.value === void 0 ? void 0 : { partial: a.value };
+    }
+  },
+  createElementStreamTransform() {
+  }
+});
+new TextEncoder();
+new TextEncoder();
+J({
+  prefix: "aitxt",
+  size: 24
+});
+J({
+  prefix: "call",
+  size: 24
+});
+(class extends TransformStream {
+  constructor() {
+    super({
+      transform(e, t) {
+        t.enqueue(`data: ${JSON.stringify(e)}
+
+`);
+      },
+      flush(e) {
+        e.enqueue(`data: [DONE]
+
+`);
+      }
+    });
+  }
+});
+var Ae = s.record(
+  s.string(),
+  he.optional()
+), Is = za(
+  () => rr(
+    s.union([
+      s.strictObject({
+        type: s.literal("text-start"),
+        id: s.string(),
+        providerMetadata: M.optional()
+      }),
+      s.strictObject({
+        type: s.literal("text-delta"),
+        id: s.string(),
+        delta: s.string(),
+        providerMetadata: M.optional()
+      }),
+      s.strictObject({
+        type: s.literal("text-end"),
+        id: s.string(),
+        providerMetadata: M.optional()
+      }),
+      s.strictObject({
+        type: s.literal("error"),
+        errorText: s.string()
+      }),
+      s.strictObject({
+        type: s.literal("tool-input-start"),
+        toolCallId: s.string(),
+        toolName: s.string(),
+        providerExecuted: s.boolean().optional(),
+        providerMetadata: M.optional(),
+        toolMetadata: Ae.optional(),
+        dynamic: s.boolean().optional(),
+        title: s.string().optional()
+      }),
+      s.strictObject({
+        type: s.literal("tool-input-delta"),
+        toolCallId: s.string(),
+        inputTextDelta: s.string()
+      }),
+      s.strictObject({
+        type: s.literal("tool-input-available"),
+        toolCallId: s.string(),
+        toolName: s.string(),
+        input: s.unknown(),
+        providerExecuted: s.boolean().optional(),
+        providerMetadata: M.optional(),
+        toolMetadata: Ae.optional(),
+        dynamic: s.boolean().optional(),
+        title: s.string().optional()
+      }),
+      s.strictObject({
+        type: s.literal("tool-input-error"),
+        toolCallId: s.string(),
+        toolName: s.string(),
+        input: s.unknown(),
+        providerExecuted: s.boolean().optional(),
+        providerMetadata: M.optional(),
+        toolMetadata: Ae.optional(),
+        dynamic: s.boolean().optional(),
+        errorText: s.string(),
+        title: s.string().optional()
+      }),
+      s.strictObject({
+        type: s.literal("tool-approval-request"),
+        approvalId: s.string(),
+        toolCallId: s.string(),
+        isAutomatic: s.boolean().optional(),
+        signature: s.string().optional()
+      }),
+      s.strictObject({
+        type: s.literal("tool-approval-response"),
+        approvalId: s.string(),
+        approved: s.boolean(),
+        reason: s.string().optional(),
+        providerExecuted: s.boolean().optional(),
+        providerMetadata: M.optional()
+      }),
+      s.strictObject({
+        type: s.literal("tool-output-available"),
+        toolCallId: s.string(),
+        output: s.unknown(),
+        providerExecuted: s.boolean().optional(),
+        providerMetadata: M.optional(),
+        toolMetadata: Ae.optional(),
+        dynamic: s.boolean().optional(),
+        preliminary: s.boolean().optional()
+      }),
+      s.strictObject({
+        type: s.literal("tool-output-error"),
+        toolCallId: s.string(),
+        errorText: s.string(),
+        providerExecuted: s.boolean().optional(),
+        providerMetadata: M.optional(),
+        toolMetadata: Ae.optional(),
+        dynamic: s.boolean().optional()
+      }),
+      s.strictObject({
+        type: s.literal("tool-output-denied"),
+        toolCallId: s.string()
+      }),
+      s.strictObject({
+        type: s.literal("reasoning-start"),
+        id: s.string(),
+        providerMetadata: M.optional()
+      }),
+      s.strictObject({
+        type: s.literal("reasoning-delta"),
+        id: s.string(),
+        delta: s.string(),
+        providerMetadata: M.optional()
+      }),
+      s.strictObject({
+        type: s.literal("reasoning-end"),
+        id: s.string(),
+        providerMetadata: M.optional()
+      }),
+      s.strictObject({
+        type: s.literal("custom"),
+        kind: s.string().transform((e) => e),
+        providerMetadata: M.optional()
+      }),
+      s.strictObject({
+        type: s.literal("source-url"),
+        sourceId: s.string(),
+        url: s.string(),
+        title: s.string().optional(),
+        providerMetadata: M.optional()
+      }),
+      s.strictObject({
+        type: s.literal("source-document"),
+        sourceId: s.string(),
+        mediaType: s.string(),
+        title: s.string(),
+        filename: s.string().optional(),
+        providerMetadata: M.optional()
+      }),
+      s.strictObject({
+        type: s.literal("file"),
+        url: s.string(),
+        mediaType: s.string(),
+        providerMetadata: M.optional()
+      }),
+      s.strictObject({
+        type: s.literal("reasoning-file"),
+        url: s.string(),
+        mediaType: s.string(),
+        providerMetadata: M.optional()
+      }),
+      s.strictObject({
+        type: s.custom(
+          (e) => typeof e == "string" && e.startsWith("data-"),
+          { message: 'Type must start with "data-"' }
+        ),
+        id: s.string().optional(),
+        data: s.unknown(),
+        transient: s.boolean().optional()
+      }),
+      s.strictObject({
+        type: s.literal("start-step")
+      }),
+      s.strictObject({
+        type: s.literal("finish-step")
+      }),
+      s.strictObject({
+        type: s.literal("start"),
+        messageId: s.string().optional(),
+        messageMetadata: s.unknown().optional()
+      }),
+      s.strictObject({
+        type: s.literal("finish"),
+        finishReason: s.enum([
+          "stop",
+          "length",
+          "content-filter",
+          "tool-calls",
+          "error",
+          "other"
+        ]).optional(),
+        messageMetadata: s.unknown().optional()
+      }),
+      s.strictObject({
+        type: s.literal("abort"),
+        reason: s.string().optional()
+      }),
+      s.strictObject({
+        type: s.literal("message-metadata"),
+        messageMetadata: s.unknown()
+      })
+    ])
+  )
+);
+function _s(e) {
+  return e.type.startsWith("data-");
+}
+function Pe() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function at(e) {
+  return e.type.startsWith("tool-");
+}
+function mr(e) {
+  return e.type === "dynamic-tool";
+}
+function _e(e) {
+  return at(e) || mr(e);
+}
+function st(e) {
+  return e.type.split("-").slice(1).join("-");
+}
+function ws(e) {
+  return mr(e) ? e.toolName : st(e);
+}
+function Ms({
+  lastMessage: e,
+  messageId: t
+}) {
+  return {
+    message: (e == null ? void 0 : e.role) === "assistant" ? e : {
+      id: t,
+      metadata: void 0,
+      role: "assistant",
+      parts: []
+    },
+    activeTextParts: Pe(),
+    activeReasoningParts: Pe(),
+    partialToolCalls: Pe()
+  };
+}
+function Ts({
+  stream: e,
+  messageMetadataSchema: t,
+  dataPartSchemas: r,
+  runUpdateMessageJob: a,
+  onError: n,
+  onToolCall: o,
+  onData: u
+}) {
+  return e.pipeThrough(
+    new TransformStream({
+      async transform(i, g) {
+        await a(async ({ state: c, write: l }) => {
+          var p, v, h, T;
+          function A(d) {
+            const m = c.message.parts.filter(_e).find(
+              (b) => b.toolCallId === d
+            );
+            if (m == null)
+              throw new ge({
+                chunkType: "tool-invocation",
+                chunkId: d,
+                message: `No tool invocation found for tool call ID "${d}".`
+              });
+            return m;
+          }
+          function _(d) {
+            const m = c.message.parts.filter(_e).find(
+              (b) => {
+                var y;
+                return ((y = b.approval) == null ? void 0 : y.id) === d;
+              }
+            );
+            if (m == null)
+              throw new ge({
+                chunkType: "tool-approval-response",
+                chunkId: d,
+                message: `No tool invocation found for approval ID "${d}".`
+              });
+            return m;
+          }
+          function S(d) {
+            var f;
+            const m = c.message.parts.find(
+              (w) => at(w) && w.toolCallId === d.toolCallId
+            ), b = d, y = m;
+            if (m != null) {
+              m.state = d.state, y.input = b.input, y.output = b.output, y.errorText = b.errorText, y.rawInput = b.rawInput, y.preliminary = b.preliminary, d.title !== void 0 && (y.title = d.title), d.toolMetadata !== void 0 && (y.toolMetadata = d.toolMetadata), y.providerExecuted = (f = b.providerExecuted) != null ? f : m.providerExecuted;
+              const w = b.providerMetadata;
+              if (w != null)
+                if (d.state === "output-available" || d.state === "output-error") {
+                  const j = m;
+                  j.resultProviderMetadata = w;
+                } else
+                  m.callProviderMetadata = w;
+            } else
+              c.message.parts.push({
+                type: `tool-${d.toolName}`,
+                toolCallId: d.toolCallId,
+                state: d.state,
+                title: d.title,
+                ...d.toolMetadata !== void 0 ? { toolMetadata: d.toolMetadata } : {},
+                input: b.input,
+                output: b.output,
+                rawInput: b.rawInput,
+                errorText: b.errorText,
+                providerExecuted: b.providerExecuted,
+                preliminary: b.preliminary,
+                ...b.providerMetadata != null && (d.state === "output-available" || d.state === "output-error") ? { resultProviderMetadata: b.providerMetadata } : {},
+                ...b.providerMetadata != null && !(d.state === "output-available" || d.state === "output-error") ? { callProviderMetadata: b.providerMetadata } : {}
+              });
+          }
+          function I(d) {
+            var f, m;
+            const b = c.message.parts.find(
+              (j) => j.type === "dynamic-tool" && j.toolCallId === d.toolCallId
+            ), y = d, w = b;
+            if (b != null) {
+              b.state = d.state, w.toolName = d.toolName, w.input = y.input, w.output = y.output, w.errorText = y.errorText, w.rawInput = (f = y.rawInput) != null ? f : w.rawInput, w.preliminary = y.preliminary, d.title !== void 0 && (w.title = d.title), d.toolMetadata !== void 0 && (w.toolMetadata = d.toolMetadata), w.providerExecuted = (m = y.providerExecuted) != null ? m : b.providerExecuted;
+              const j = y.providerMetadata;
+              if (j != null)
+                if (d.state === "output-available" || d.state === "output-error") {
+                  const se = b;
+                  se.resultProviderMetadata = j;
+                } else
+                  b.callProviderMetadata = j;
+            } else
+              c.message.parts.push({
+                type: "dynamic-tool",
+                toolName: d.toolName,
+                toolCallId: d.toolCallId,
+                state: d.state,
+                input: y.input,
+                output: y.output,
+                errorText: y.errorText,
+                preliminary: y.preliminary,
+                providerExecuted: y.providerExecuted,
+                title: d.title,
+                ...d.toolMetadata !== void 0 ? { toolMetadata: d.toolMetadata } : {},
+                ...y.providerMetadata != null && (d.state === "output-available" || d.state === "output-error") ? { resultProviderMetadata: y.providerMetadata } : {},
+                ...y.providerMetadata != null && !(d.state === "output-available" || d.state === "output-error") ? { callProviderMetadata: y.providerMetadata } : {}
+              });
+          }
+          async function R(d) {
+            if (d != null) {
+              const f = c.message.metadata != null ? fr(c.message.metadata, d) : d;
+              t != null && await Dt({
+                value: f,
+                schema: t,
+                context: {
+                  field: "message.metadata",
+                  entityId: c.message.id
+                }
+              }), c.message.metadata = f;
+            }
+          }
+          switch (i.type) {
+            case "text-start": {
+              const d = {
+                type: "text",
+                text: "",
+                providerMetadata: i.providerMetadata,
+                state: "streaming"
+              };
+              c.activeTextParts[i.id] = d, c.message.parts.push(d), l();
+              break;
+            }
+            case "text-delta": {
+              const d = c.activeTextParts[i.id];
+              if (d == null)
+                throw new ge({
+                  chunkType: "text-delta",
+                  chunkId: i.id,
+                  message: `Received text-delta for missing text part with ID "${i.id}". Ensure a "text-start" chunk is sent before any "text-delta" chunks.`
+                });
+              d.text += i.delta, d.providerMetadata = (p = i.providerMetadata) != null ? p : d.providerMetadata, l();
+              break;
+            }
+            case "text-end": {
+              const d = c.activeTextParts[i.id];
+              if (d == null)
+                throw new ge({
+                  chunkType: "text-end",
+                  chunkId: i.id,
+                  message: `Received text-end for missing text part with ID "${i.id}". Ensure a "text-start" chunk is sent before any "text-end" chunks.`
+                });
+              d.state = "done", d.providerMetadata = (v = i.providerMetadata) != null ? v : d.providerMetadata, delete c.activeTextParts[i.id], l();
+              break;
+            }
+            case "custom": {
+              const d = {
+                type: "custom",
+                kind: i.kind,
+                providerMetadata: i.providerMetadata
+              };
+              c.message.parts.push(d), l();
+              break;
+            }
+            case "reasoning-start": {
+              const d = {
+                type: "reasoning",
+                text: "",
+                providerMetadata: i.providerMetadata,
+                state: "streaming"
+              };
+              c.activeReasoningParts[i.id] = d, c.message.parts.push(d), l();
+              break;
+            }
+            case "reasoning-delta": {
+              const d = c.activeReasoningParts[i.id];
+              if (d == null)
+                throw new ge({
+                  chunkType: "reasoning-delta",
+                  chunkId: i.id,
+                  message: `Received reasoning-delta for missing reasoning part with ID "${i.id}". Ensure a "reasoning-start" chunk is sent before any "reasoning-delta" chunks.`
+                });
+              d.text += i.delta, d.providerMetadata = (h = i.providerMetadata) != null ? h : d.providerMetadata, l();
+              break;
+            }
+            case "reasoning-end": {
+              const d = c.activeReasoningParts[i.id];
+              if (d == null)
+                throw new ge({
+                  chunkType: "reasoning-end",
+                  chunkId: i.id,
+                  message: `Received reasoning-end for missing reasoning part with ID "${i.id}". Ensure a "reasoning-start" chunk is sent before any "reasoning-end" chunks.`
+                });
+              d.providerMetadata = (T = i.providerMetadata) != null ? T : d.providerMetadata, d.state = "done", delete c.activeReasoningParts[i.id], l();
+              break;
+            }
+            case "file":
+            case "reasoning-file": {
+              c.message.parts.push({
+                type: i.type,
+                mediaType: i.mediaType,
+                url: i.url,
+                ...i.providerMetadata != null ? { providerMetadata: i.providerMetadata } : {}
+              }), l();
+              break;
+            }
+            case "source-url": {
+              c.message.parts.push({
+                type: "source-url",
+                sourceId: i.sourceId,
+                url: i.url,
+                title: i.title,
+                providerMetadata: i.providerMetadata
+              }), l();
+              break;
+            }
+            case "source-document": {
+              c.message.parts.push({
+                type: "source-document",
+                sourceId: i.sourceId,
+                mediaType: i.mediaType,
+                title: i.title,
+                filename: i.filename,
+                providerMetadata: i.providerMetadata
+              }), l();
+              break;
+            }
+            case "tool-input-start": {
+              const d = c.message.parts.filter(at);
+              c.partialToolCalls[i.toolCallId] = {
+                text: "",
+                toolName: i.toolName,
+                index: d.length,
+                dynamic: i.dynamic,
+                title: i.title,
+                toolMetadata: i.toolMetadata
+              }, i.dynamic ? I({
+                toolCallId: i.toolCallId,
+                toolName: i.toolName,
+                state: "input-streaming",
+                input: void 0,
+                providerExecuted: i.providerExecuted,
+                title: i.title,
+                toolMetadata: i.toolMetadata,
+                providerMetadata: i.providerMetadata
+              }) : S({
+                toolCallId: i.toolCallId,
+                toolName: i.toolName,
+                state: "input-streaming",
+                input: void 0,
+                providerExecuted: i.providerExecuted,
+                title: i.title,
+                toolMetadata: i.toolMetadata,
+                providerMetadata: i.providerMetadata
+              }), l();
+              break;
+            }
+            case "tool-input-delta": {
+              const d = c.partialToolCalls[i.toolCallId];
+              if (d == null)
+                throw new ge({
+                  chunkType: "tool-input-delta",
+                  chunkId: i.toolCallId,
+                  message: `Received tool-input-delta for missing tool call with ID "${i.toolCallId}". Ensure a "tool-input-start" chunk is sent before any "tool-input-delta" chunks.`
+                });
+              d.text += i.inputTextDelta;
+              const { value: f } = await De(
+                d.text
+              );
+              d.dynamic ? I({
+                toolCallId: i.toolCallId,
+                toolName: d.toolName,
+                state: "input-streaming",
+                input: f,
+                title: d.title,
+                toolMetadata: d.toolMetadata
+              }) : S({
+                toolCallId: i.toolCallId,
+                toolName: d.toolName,
+                state: "input-streaming",
+                input: f,
+                title: d.title,
+                toolMetadata: d.toolMetadata
+              }), l();
+              break;
+            }
+            case "tool-input-available": {
+              i.dynamic ? I({
+                toolCallId: i.toolCallId,
+                toolName: i.toolName,
+                state: "input-available",
+                input: i.input,
+                providerExecuted: i.providerExecuted,
+                providerMetadata: i.providerMetadata,
+                title: i.title,
+                toolMetadata: i.toolMetadata
+              }) : S({
+                toolCallId: i.toolCallId,
+                toolName: i.toolName,
+                state: "input-available",
+                input: i.input,
+                providerExecuted: i.providerExecuted,
+                providerMetadata: i.providerMetadata,
+                title: i.title,
+                toolMetadata: i.toolMetadata
+              }), l(), o && !i.providerExecuted && await o({
+                toolCall: i
+              });
+              break;
+            }
+            case "tool-input-error": {
+              const d = c.message.parts.filter(_e).find((m) => m.toolCallId === i.toolCallId);
+              (d != null ? d.type === "dynamic-tool" : !!i.dynamic) ? I({
+                toolCallId: i.toolCallId,
+                toolName: i.toolName,
+                state: "output-error",
+                input: i.input,
+                errorText: i.errorText,
+                providerExecuted: i.providerExecuted,
+                providerMetadata: i.providerMetadata,
+                toolMetadata: i.toolMetadata
+              }) : S({
+                toolCallId: i.toolCallId,
+                toolName: i.toolName,
+                state: "output-error",
+                input: void 0,
+                rawInput: i.input,
+                errorText: i.errorText,
+                providerExecuted: i.providerExecuted,
+                providerMetadata: i.providerMetadata,
+                toolMetadata: i.toolMetadata
+              }), l();
+              break;
+            }
+            case "tool-approval-request": {
+              const d = A(i.toolCallId);
+              d.state = "approval-requested", d.approval = {
+                id: i.approvalId,
+                ...i.isAutomatic === !0 ? { isAutomatic: !0 } : {},
+                ...i.signature != null ? { signature: i.signature } : {}
+              }, l();
+              break;
+            }
+            case "tool-approval-response": {
+              const d = _(
+                i.approvalId
+              ), f = d.approval == null ? { id: i.approvalId } : d.approval;
+              d.state = "approval-responded", d.approval = {
+                id: i.approvalId,
+                approved: i.approved,
+                ...i.reason != null ? { reason: i.reason } : {},
+                ...f.isAutomatic === !0 ? { isAutomatic: !0 } : {},
+                ...f.signature != null ? { signature: f.signature } : {}
+              }, i.providerExecuted != null && (d.providerExecuted = i.providerExecuted), i.providerMetadata != null && (d.callProviderMetadata = i.providerMetadata), l();
+              break;
+            }
+            case "tool-output-denied": {
+              const d = A(i.toolCallId);
+              d.state = "output-denied", l();
+              break;
+            }
+            case "tool-output-available": {
+              const d = A(i.toolCallId);
+              d.type === "dynamic-tool" ? I({
+                toolCallId: i.toolCallId,
+                toolName: d.toolName,
+                state: "output-available",
+                input: d.input,
+                output: i.output,
+                preliminary: i.preliminary,
+                providerExecuted: i.providerExecuted,
+                providerMetadata: i.providerMetadata,
+                title: d.title,
+                toolMetadata: d.toolMetadata
+              }) : S({
+                toolCallId: i.toolCallId,
+                toolName: st(d),
+                state: "output-available",
+                input: d.input,
+                output: i.output,
+                providerExecuted: i.providerExecuted,
+                preliminary: i.preliminary,
+                providerMetadata: i.providerMetadata,
+                title: d.title,
+                toolMetadata: d.toolMetadata
+              }), l();
+              break;
+            }
+            case "tool-output-error": {
+              const d = A(i.toolCallId);
+              d.type === "dynamic-tool" ? I({
+                toolCallId: i.toolCallId,
+                toolName: d.toolName,
+                state: "output-error",
+                input: d.input,
+                errorText: i.errorText,
+                providerExecuted: i.providerExecuted,
+                providerMetadata: i.providerMetadata,
+                title: d.title,
+                toolMetadata: d.toolMetadata
+              }) : S({
+                toolCallId: i.toolCallId,
+                toolName: st(d),
+                state: "output-error",
+                input: d.input,
+                rawInput: d.rawInput,
+                errorText: i.errorText,
+                providerExecuted: i.providerExecuted,
+                providerMetadata: i.providerMetadata,
+                title: d.title,
+                toolMetadata: d.toolMetadata
+              }), l();
+              break;
+            }
+            case "start-step": {
+              c.message.parts.push({ type: "step-start" });
+              break;
+            }
+            case "finish-step": {
+              c.activeTextParts = Pe(), c.activeReasoningParts = Pe();
+              break;
+            }
+            case "start": {
+              i.messageId != null && (c.message.id = i.messageId), await R(i.messageMetadata), (i.messageId != null || i.messageMetadata != null) && l();
+              break;
+            }
+            case "finish": {
+              i.finishReason != null && (c.finishReason = i.finishReason), await R(i.messageMetadata), i.messageMetadata != null && l();
+              break;
+            }
+            case "message-metadata": {
+              await R(i.messageMetadata), i.messageMetadata != null && l();
+              break;
+            }
+            case "error": {
+              n == null || n(new Error(i.errorText));
+              break;
+            }
+            default:
+              if (_s(i)) {
+                if ((r == null ? void 0 : r[i.type]) != null) {
+                  const m = c.message.parts.findIndex(
+                    (y) => "id" in y && "data" in y && y.id === i.id && y.type === i.type
+                  ), b = m >= 0 ? m : c.message.parts.length;
+                  await Dt({
+                    value: i.data,
+                    schema: r[i.type],
+                    context: {
+                      field: `message.parts[${b}].data`,
+                      entityName: i.type,
+                      entityId: i.id
+                    }
+                  });
+                }
+                const d = i;
+                if (d.transient) {
+                  u == null || u(d);
+                  break;
+                }
+                const f = d.id != null ? c.message.parts.find(
+                  (m) => d.type === m.type && d.id === m.id
+                ) : void 0;
+                f != null ? f.data = d.data : c.message.parts.push(d), u == null || u(d), l();
+              }
+          }
+          g.enqueue(i);
+        });
+      }
+    })
+  );
+}
+async function As({
+  stream: e,
+  onError: t
+}) {
+  const r = e.getReader();
+  try {
+    for (; ; ) {
+      const { done: a } = await r.read();
+      if (a)
+        break;
+    }
+  } catch (a) {
+    t == null || t(a);
+  } finally {
+    r.releaseLock();
+  }
+}
+J({
+  prefix: "aitxt",
+  size: 24
+});
+J({
+  prefix: "call",
+  size: 24
+});
+J({
+  prefix: "aitxt",
+  size: 24
+});
+J({
+  prefix: "call",
+  size: 24
+});
+s.record(
+  s.string(),
+  he.optional()
+);
+s.record(s.string(), s.string());
+J({
+  prefix: "call",
+  size: 24
+});
+J({
+  prefix: "call",
+  size: 24
+});
+J({ prefix: "aiobj", size: 24 });
+var Cs = class {
+  constructor() {
+    this.queue = [], this.isProcessing = !1;
+  }
+  async processQueue() {
+    if (!this.isProcessing) {
+      for (this.isProcessing = !0; this.queue.length > 0; )
+        await this.queue[0](), this.queue.shift();
+      this.isProcessing = !1;
+    }
+  }
+  async run(e) {
+    return new Promise((t, r) => {
+      this.queue.push(async () => {
+        try {
+          await e(), t();
+        } catch (a) {
+          r(a);
+        }
+      }), this.processQueue();
+    });
+  }
+};
+J({ prefix: "aiobj", size: 24 });
+J({
+  prefix: "call",
+  size: 24
+});
+async function xs(e) {
+  if (e == null)
+    return [];
+  if (!globalThis.FileList || !(e instanceof globalThis.FileList))
+    throw new Error("FileList is not supported in the current environment");
+  return Promise.all(
+    Array.from(e).map(async (t) => {
+      const { name: r, type: a } = t, n = await new Promise((o, u) => {
+        const i = new FileReader();
+        i.onload = (g) => {
+          var c;
+          o((c = g.target) == null ? void 0 : c.result);
+        }, i.onerror = (g) => u(g), i.readAsDataURL(t);
+      });
+      return {
+        type: "file",
+        mediaType: a,
+        filename: r,
+        url: n
+      };
+    })
+  );
+}
+var Rs = class {
+  constructor({
+    api: e = "/api/chat",
+    credentials: t,
+    headers: r,
+    body: a,
+    fetch: n,
+    prepareSendMessagesRequest: o,
+    prepareReconnectToStreamRequest: u
+  }) {
+    this.api = e, this.credentials = t, this.headers = r, this.body = a, this.fetch = n, this.prepareSendMessagesRequest = o, this.prepareReconnectToStreamRequest = u;
+  }
+  async sendMessages({
+    abortSignal: e,
+    ...t
+  }) {
+    var r, a, n, o, u;
+    const i = await ue(this.body), g = await ue(this.headers), c = await ue(this.credentials), l = {
+      ...Ee(g),
+      ...Ee(t.headers)
+    }, p = await ((r = this.prepareSendMessagesRequest) == null ? void 0 : r.call(this, {
+      api: this.api,
+      id: t.chatId,
+      messages: t.messages,
+      body: { ...i, ...t.body },
+      headers: l,
+      credentials: c,
+      requestMetadata: t.metadata,
+      trigger: t.trigger,
+      messageId: t.messageId
+    })), v = (a = p == null ? void 0 : p.api) != null ? a : this.api, h = (p == null ? void 0 : p.headers) !== void 0 ? Ee(p.headers) : l, T = (p == null ? void 0 : p.body) !== void 0 ? p.body : {
+      ...i,
+      ...t.body,
+      id: t.chatId,
+      messages: t.messages,
+      trigger: t.trigger,
+      messageId: t.messageId
+    }, A = (n = p == null ? void 0 : p.credentials) != null ? n : c, S = await ((o = this.fetch) != null ? o : globalThis.fetch)(v, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...h
+      },
+      body: JSON.stringify(T),
+      credentials: A,
+      signal: e
+    });
+    if (!S.ok)
+      throw new Error(
+        (u = await S.text()) != null ? u : "Failed to fetch the chat response."
+      );
+    if (!S.body)
+      throw new Error("The response body is empty.");
+    return this.processResponseStream(S.body);
+  }
+  async reconnectToStream(e) {
+    var t, r, a, n, o;
+    const u = await ue(this.body), i = await ue(this.headers), g = await ue(this.credentials), c = {
+      ...Ee(i),
+      ...Ee(e.headers)
+    }, l = await ((t = this.prepareReconnectToStreamRequest) == null ? void 0 : t.call(this, {
+      api: this.api,
+      id: e.chatId,
+      body: { ...u, ...e.body },
+      headers: c,
+      credentials: g,
+      requestMetadata: e.metadata
+    })), p = (r = l == null ? void 0 : l.api) != null ? r : `${this.api}/${e.chatId}/stream`, v = (l == null ? void 0 : l.headers) !== void 0 ? Ee(l.headers) : c, h = (a = l == null ? void 0 : l.credentials) != null ? a : g, A = await ((n = this.fetch) != null ? n : globalThis.fetch)(p, {
+      method: "GET",
+      headers: v,
+      credentials: h
+    });
+    if (A.status === 204)
+      return null;
+    if (!A.ok)
+      throw new Error(
+        (o = await A.text()) != null ? o : "Failed to fetch the chat response."
+      );
+    if (!A.body)
+      throw new Error("The response body is empty.");
+    return this.processResponseStream(A.body);
+  }
+}, dt = class extends Rs {
+  constructor(e = {}) {
+    super(e);
+  }
+  processResponseStream(e) {
+    return Ha({
+      stream: e,
+      schema: Is
+    }).pipeThrough(
+      new TransformStream({
+        async transform(t, r) {
+          if (!t.success)
+            throw t.error;
+          r.enqueue(t.value);
+        }
+      })
+    );
+  }
+}, Os = class {
+  constructor({
+    generateId: e = Gr,
+    id: t = e(),
+    transport: r = new dt(),
+    messageMetadataSchema: a,
+    dataPartSchemas: n,
+    state: o,
+    onError: u,
+    onToolCall: i,
+    onFinish: g,
+    onData: c,
+    sendAutomaticallyWhen: l
+  }) {
+    this.activeResponse = void 0, this.jobExecutor = new Cs(), this.sendMessage = async (p, v) => {
+      var h, T, A, _;
+      if (p == null) {
+        await this.makeRequest({
+          trigger: "submit-message",
+          messageId: (h = this.lastMessage) == null ? void 0 : h.id,
+          ...v
+        });
+        return;
+      }
+      let S;
+      if ("text" in p || "files" in p ? S = {
+        parts: [
+          ...Array.isArray(p.files) ? p.files : await xs(p.files),
+          ..."text" in p && p.text != null ? [{ type: "text", text: p.text }] : []
+        ]
+      } : S = p, p.messageId != null) {
+        const I = this.state.messages.findIndex(
+          (R) => R.id === p.messageId
+        );
+        if (I === -1)
+          throw new Error(`message with id ${p.messageId} not found`);
+        if (this.state.messages[I].role !== "user")
+          throw new Error(
+            `message with id ${p.messageId} is not a user message`
+          );
+        this.state.messages = this.state.messages.slice(0, I + 1), this.state.replaceMessage(I, {
+          ...S,
+          id: p.messageId,
+          role: (T = S.role) != null ? T : "user",
+          metadata: p.metadata
+        });
+      } else
+        this.state.pushMessage({
+          ...S,
+          id: (A = S.id) != null ? A : this.generateId(),
+          role: (_ = S.role) != null ? _ : "user",
+          metadata: p.metadata
+        });
+      await this.makeRequest({
+        trigger: "submit-message",
+        messageId: p.messageId,
+        ...v
+      });
+    }, this.regenerate = async ({
+      messageId: p,
+      ...v
+    } = {}) => {
+      const h = p == null ? this.state.messages.length - 1 : this.state.messages.findIndex((T) => T.id === p);
+      if (h === -1)
+        throw new Error(`message ${p} not found`);
+      this.state.messages = this.state.messages.slice(
+        0,
+        // if the message is a user message, we need to include it in the request:
+        this.messages[h].role === "assistant" ? h : h + 1
+      ), await this.makeRequest({
+        trigger: "regenerate-message",
+        messageId: p,
+        ...v
+      });
+    }, this.resumeStream = async (p = {}) => {
+      await this.makeRequest({ trigger: "resume-stream", ...p });
+    }, this.clearError = () => {
+      this.status === "error" && (this.state.error = void 0, this.setStatus({ status: "ready" }));
+    }, this.addToolApprovalResponse = async ({
+      id: p,
+      approved: v,
+      reason: h,
+      options: T
+    }) => this.jobExecutor.run(async () => {
+      const A = this.state.messages, _ = A[A.length - 1], S = (I) => _e(I) && I.state === "approval-requested" && I.approval.id === p ? {
+        ...I,
+        state: "approval-responded",
+        approval: { ...I.approval, id: p, approved: v, reason: h }
+      } : I;
+      this.state.replaceMessage(A.length - 1, {
+        ..._,
+        parts: _.parts.map(S)
+      }), this.activeResponse && (this.activeResponse.state.message.parts = this.activeResponse.state.message.parts.map(S)), this.status !== "streaming" && this.status !== "submitted" && this.sendAutomaticallyWhen && this.shouldSendAutomatically().then((I) => {
+        var R;
+        I && this.makeRequest({
+          trigger: "submit-message",
+          messageId: (R = this.lastMessage) == null ? void 0 : R.id,
+          ...T
+        });
+      });
+    }), this.addToolOutput = async ({
+      state: p = "output-available",
+      toolCallId: v,
+      output: h,
+      errorText: T,
+      options: A
+    }) => this.jobExecutor.run(async () => {
+      const _ = this.state.messages, S = _[_.length - 1], I = (R) => _e(R) && R.toolCallId === v ? { ...R, state: p, output: h, errorText: T } : R;
+      this.state.replaceMessage(_.length - 1, {
+        ...S,
+        parts: S.parts.map(I)
+      }), this.activeResponse && (this.activeResponse.state.message.parts = this.activeResponse.state.message.parts.map(I)), this.status !== "streaming" && this.status !== "submitted" && this.sendAutomaticallyWhen && this.shouldSendAutomatically().then((R) => {
+        var d;
+        R && this.makeRequest({
+          trigger: "submit-message",
+          messageId: (d = this.lastMessage) == null ? void 0 : d.id,
+          ...A
+        });
+      });
+    }), this.addToolResult = this.addToolOutput, this.stop = async () => {
+      var p;
+      this.status !== "streaming" && this.status !== "submitted" || (p = this.activeResponse) != null && p.abortController && this.activeResponse.abortController.abort();
+    }, this.id = t, this.transport = r, this.generateId = e, this.messageMetadataSchema = a, this.dataPartSchemas = n, this.state = o, this.onError = u, this.onToolCall = i, this.onFinish = g, this.onData = c, this.sendAutomaticallyWhen = l;
+  }
+  /**
+   * Hook status:
+   *
+   * - `submitted`: The message has been sent to the API and we're awaiting the start of the response stream.
+   * - `streaming`: The response is actively streaming in from the API, receiving chunks of data.
+   * - `ready`: The full response has been received and processed; a new user message can be submitted.
+   * - `error`: An error occurred during the API request, preventing successful completion.
+   */
+  get status() {
+    return this.state.status;
+  }
+  setStatus({
+    status: e,
+    error: t
+  }) {
+    this.status !== e && (this.state.status = e, this.state.error = t);
+  }
+  get error() {
+    return this.state.error;
+  }
+  get messages() {
+    return this.state.messages;
+  }
+  get lastMessage() {
+    return this.state.messages[this.state.messages.length - 1];
+  }
+  set messages(e) {
+    this.state.messages = e;
+  }
+  async shouldSendAutomatically() {
+    if (!this.sendAutomaticallyWhen)
+      return !1;
+    const e = this.sendAutomaticallyWhen({
+      messages: this.state.messages
+    });
+    return e && typeof e == "object" && "then" in e ? await e : e;
+  }
+  async makeRequest({
+    trigger: e,
+    metadata: t,
+    headers: r,
+    body: a,
+    messageId: n
+  }) {
+    var o, u;
+    let i;
+    if (e === "resume-stream")
+      try {
+        const h = await this.transport.reconnectToStream({
+          chatId: this.id,
+          metadata: t,
+          headers: r,
+          body: a
+        });
+        if (h == null)
+          return;
+        i = h;
+      } catch (h) {
+        this.onError && h instanceof Error && this.onError(h), this.setStatus({ status: "error", error: h });
+        return;
+      }
+    this.setStatus({ status: "submitted", error: void 0 });
+    const g = this.lastMessage;
+    let c = !1, l = !1, p = !1, v;
+    try {
+      const h = {
+        state: Ms({
+          lastMessage: this.state.snapshot(g),
+          messageId: this.generateId()
+        }),
+        abortController: new AbortController()
+      };
+      v = h, h.abortController.signal.addEventListener("abort", () => {
+        c = !0;
+      }), this.activeResponse = h;
+      let T;
+      e === "resume-stream" ? T = i : T = await this.transport.sendMessages({
+        chatId: this.id,
+        messages: this.state.messages,
+        abortSignal: h.abortController.signal,
+        metadata: t,
+        headers: r,
+        body: a,
+        trigger: e,
+        messageId: n
+      });
+      const A = (_) => (
+        // serialize the job execution to avoid race conditions:
+        this.jobExecutor.run(
+          () => _({
+            state: h.state,
+            write: () => {
+              var S;
+              this.setStatus({ status: "streaming" }), h.state.message.id === ((S = this.lastMessage) == null ? void 0 : S.id) ? this.state.replaceMessage(
+                this.state.messages.length - 1,
+                h.state.message
+              ) : this.state.pushMessage(h.state.message);
+            }
+          })
+        )
+      );
+      await As({
+        stream: Ts({
+          stream: T,
+          onToolCall: this.onToolCall,
+          onData: this.onData,
+          messageMetadataSchema: this.messageMetadataSchema,
+          dataPartSchemas: this.dataPartSchemas,
+          runUpdateMessageJob: A,
+          onError: (_) => {
+            throw _;
+          }
+        }),
+        onError: (_) => {
+          throw _;
+        }
+      }), this.setStatus({ status: "ready" });
+    } catch (h) {
+      if (c || h.name === "AbortError")
+        return c = !0, this.setStatus({ status: "ready" }), null;
+      p = !0, h instanceof TypeError && (h.message.toLowerCase().includes("fetch") || h.message.toLowerCase().includes("network")) && (l = !0), this.onError && h instanceof Error && this.onError(h), this.setStatus({ status: "error", error: h });
+    } finally {
+      try {
+        v && ((o = this.onFinish) == null || o.call(this, {
+          message: v.state.message,
+          messages: this.state.messages,
+          isAbort: c,
+          isDisconnect: l,
+          isError: p,
+          finishReason: v.state.finishReason
+        }));
+      } catch (h) {
+        console.error(h);
+      }
+      this.activeResponse === v && (this.activeResponse = void 0);
+    }
+    !p && await this.shouldSendAutomatically() && await this.makeRequest({
+      trigger: "submit-message",
+      messageId: (u = this.lastMessage) == null ? void 0 : u.id,
+      metadata: t,
+      headers: r,
+      body: a
+    });
+  }
+};
+function Ps(e, t) {
+  if (typeof e != "function")
+    throw new TypeError(`Expected the first argument to be a \`function\`, got \`${typeof e}\`.`);
+  let r, a = 0;
+  return function(...o) {
+    clearTimeout(r);
+    const u = Date.now(), i = u - a, g = t - i;
+    g <= 0 ? (a = u, e.apply(this, o)) : r = setTimeout(() => {
+      a = Date.now(), e.apply(this, o);
+    }, g);
+  };
+}
+var Ns = Ps;
+const js = /* @__PURE__ */ Ga(Ns);
+var gr = (e, t, r) => {
+  if (!t.has(e))
+    throw TypeError("Cannot " + r);
+}, N = (e, t, r) => (gr(e, t, "read from private field"), r ? r.call(e) : t.get(e)), te = (e, t, r) => {
+  if (t.has(e))
+    throw TypeError("Cannot add the same private member more than once");
+  t instanceof WeakSet ? t.add(e) : t.set(e, r);
+}, le = (e, t, r, a) => (gr(e, t, "write to private field"), t.set(e, r), r);
+function Ds(e, t) {
+  return t != null ? js(e, t) : e;
+}
+var W, ke, $e, Ce, xe, Re, Se, nt, it, Ls = class {
+  constructor(e = []) {
+    te(this, W, void 0), te(this, ke, "ready"), te(this, $e, void 0), te(this, Ce, /* @__PURE__ */ new Set()), te(this, xe, /* @__PURE__ */ new Set()), te(this, Re, /* @__PURE__ */ new Set()), this.pushMessage = (t) => {
+      le(this, W, N(this, W).concat(t)), N(this, Se).call(this);
+    }, this.popMessage = () => {
+      le(this, W, N(this, W).slice(0, -1)), N(this, Se).call(this);
+    }, this.replaceMessage = (t, r) => {
+      le(this, W, [
+        ...N(this, W).slice(0, t),
+        // We deep clone the message here to ensure the new React Compiler (currently in RC) detects deeply nested parts/metadata changes:
+        this.snapshot(r),
+        ...N(this, W).slice(t + 1)
+      ]), N(this, Se).call(this);
+    }, this.snapshot = (t) => structuredClone(t), this["~registerMessagesCallback"] = (t, r) => {
+      const a = r ? Ds(t, r) : t;
+      return N(this, Ce).add(a), () => {
+        N(this, Ce).delete(a);
+      };
+    }, this["~registerStatusCallback"] = (t) => (N(this, xe).add(t), () => {
+      N(this, xe).delete(t);
+    }), this["~registerErrorCallback"] = (t) => (N(this, Re).add(t), () => {
+      N(this, Re).delete(t);
+    }), te(this, Se, () => {
+      N(this, Ce).forEach((t) => t());
+    }), te(this, nt, () => {
+      N(this, xe).forEach((t) => t());
+    }), te(this, it, () => {
+      N(this, Re).forEach((t) => t());
+    }), le(this, W, e);
+  }
+  get status() {
+    return N(this, ke);
+  }
+  set status(e) {
+    le(this, ke, e), N(this, nt).call(this);
+  }
+  get error() {
+    return N(this, $e);
+  }
+  set error(e) {
+    le(this, $e, e), N(this, it).call(this);
+  }
+  get messages() {
+    return N(this, W);
+  }
+  set messages(e) {
+    le(this, W, [...e]), N(this, Se).call(this);
+  }
+};
+W = /* @__PURE__ */ new WeakMap();
+ke = /* @__PURE__ */ new WeakMap();
+$e = /* @__PURE__ */ new WeakMap();
+Ce = /* @__PURE__ */ new WeakMap();
+xe = /* @__PURE__ */ new WeakMap();
+Re = /* @__PURE__ */ new WeakMap();
+Se = /* @__PURE__ */ new WeakMap();
+nt = /* @__PURE__ */ new WeakMap();
+it = /* @__PURE__ */ new WeakMap();
+var Ie, Lt = class extends Os {
+  constructor({ messages: e, ...t }) {
+    const r = new Ls(e);
+    super({ ...t, state: r }), te(this, Ie, void 0), this["~registerMessagesCallback"] = (a, n) => N(this, Ie)["~registerMessagesCallback"](a, n), this["~registerStatusCallback"] = (a) => N(this, Ie)["~registerStatusCallback"](a), this["~registerErrorCallback"] = (a) => N(this, Ie)["~registerErrorCallback"](a), le(this, Ie, r);
+  }
+};
+Ie = /* @__PURE__ */ new WeakMap();
+function Fs({
+  throttle: e,
+  experimental_throttle: t,
+  resume: r = !1,
+  ...a
+} = {}) {
+  const n = e ?? t, o = D({});
+  "chat" in a || (o.current = {
+    onToolCall: a.onToolCall,
+    onData: a.onData,
+    onFinish: a.onFinish,
+    onError: a.onError,
+    sendAutomaticallyWhen: a.sendAutomaticallyWhen,
+    transport: a.transport
+  });
+  let u;
+  const i = () => {
+    var _;
+    return (_ = o.current.transport) != null ? _ : u ?? (u = new dt());
+  }, g = {
+    ...a,
+    transport: {
+      sendMessages: (_) => i().sendMessages(_),
+      reconnectToStream: (_) => i().reconnectToStream(_)
+    },
+    onToolCall: (_) => {
+      var S, I;
+      return (I = (S = o.current).onToolCall) == null ? void 0 : I.call(S, _);
+    },
+    onData: (_) => {
+      var S, I;
+      return (I = (S = o.current).onData) == null ? void 0 : I.call(S, _);
+    },
+    onFinish: (_) => {
+      var S, I;
+      return (I = (S = o.current).onFinish) == null ? void 0 : I.call(S, _);
+    },
+    onError: (_) => {
+      var S, I;
+      return (I = (S = o.current).onError) == null ? void 0 : I.call(S, _);
+    },
+    sendAutomaticallyWhen: (_) => {
+      var S, I, R;
+      return (R = (I = (S = o.current).sendAutomaticallyWhen) == null ? void 0 : I.call(S, _)) != null ? R : !1;
+    }
+  }, c = D(
+    "chat" in a ? a.chat : new Lt(g)
+  );
+  ("chat" in a && a.chat !== c.current || "id" in a && a.id != null && c.current.id !== a.id) && (c.current = "chat" in a ? a.chat : new Lt(g));
+  const p = U(
+    (_) => c.current["~registerMessagesCallback"](_, n),
+    // `chatRef.current.id` is required to trigger re-subscription when the chat ID changes
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [n, c.current.id]
+  ), v = Oe(
+    p,
+    () => c.current.messages,
+    () => c.current.messages
+  ), h = Oe(
+    c.current["~registerStatusCallback"],
+    () => c.current.status,
+    () => c.current.status
+  ), T = Oe(
+    c.current["~registerErrorCallback"],
+    () => c.current.error,
+    () => c.current.error
+  ), A = U(
+    (_) => {
+      typeof _ == "function" && (_ = _(c.current.messages)), c.current.messages = _;
+    },
+    [c]
+  );
+  return $(() => {
+    r && c.current.resumeStream();
+  }, [r, c]), {
+    id: c.current.id,
+    messages: v,
+    setMessages: A,
+    sendMessage: c.current.sendMessage,
+    regenerate: c.current.regenerate,
+    clearError: c.current.clearError,
+    stop: c.current.stop,
+    error: T,
+    resumeStream: c.current.resumeStream,
+    status: h,
+    /**
+     * @deprecated Use `addToolOutput` instead.
+     */
+    addToolResult: c.current.addToolOutput,
+    addToolOutput: c.current.addToolOutput,
+    addToolApprovalResponse: c.current.addToolApprovalResponse
+  };
+}
+class Ft {
+  constructor(t) {
+    this.buffer = [], this.cap = Math.max(1, Math.floor(t));
+  }
+  get size() {
+    return this.buffer.length;
+  }
+  /** Read-only snapshot of pending items, oldest first. */
+  get items() {
+    return this.buffer;
+  }
+  /**
+   * Append an item when capacity permits. Returns `false` without mutating
+   * the accepted FIFO backlog when full.
+   */
+  enqueue(t) {
+    return this.buffer.length >= this.cap ? !1 : (this.buffer.push(t), !0);
+  }
+  /** Remove and return the next item (FIFO), or `null` when empty. */
+  dequeueNext() {
+    return this.buffer.shift() ?? null;
+  }
+  /**
+   * Remove and return the first item matching `predicate`, or `null` when
+   * nothing matches. Used by the queue pill's per-message remove button.
+   */
+  removeWhere(t) {
+    const r = this.buffer.findIndex(t);
+    if (r === -1) return null;
+    const [a] = this.buffer.splice(r, 1);
+    return a ?? null;
+  }
+}
+const ks = z.union([
+  z.string(),
+  z.looseObject({ id: z.string().optional(), label: z.string() })
+]), $s = z.looseObject({
+  id: z.string().optional(),
+  prompt: z.string(),
+  selection: z.enum(["single", "multiple"]).default("single"),
+  options: z.array(ks).min(1)
+}), Us = z.looseObject({
+  request_id: z.string().optional(),
+  questions: z.array($s).min(1)
+});
+function qs(e) {
+  return !!(e != null && e.includes("ask_questions"));
+}
+const Zs = [
+  /\bi[’'ʼ‘]?ll\s+(type|describe|enter|write|tell)\b/i,
+  /\b(type|describe|enter|write|tell)\s+(it|my\s+own|manually)\b/i,
+  /^\s*(other|custom|none\s+of\s+the\s+above|something\s+else)\s*\.?\s*$/i
+];
+function zs(e) {
+  return Zs.some((t) => t.test(e));
+}
+function Bs(e, t) {
+  return {
+    request_id: e.request_id ?? t ?? "req-clarification",
+    questions: e.questions.map((r, a) => ({
+      id: r.id ?? `q${a}`,
+      prompt: r.prompt,
+      selection: r.selection,
+      options: r.options.map(
+        (n, o) => typeof n == "string" ? { id: `q${a}-o${o}`, label: n } : {
+          id: n.id ?? `q${a}-o${o}`,
+          label: n.label
+        }
+      ).filter((n) => !zs(n.label))
+    }))
+  };
+}
+function Qe(e) {
+  try {
+    return JSON.parse(e);
+  } catch {
+    return null;
+  }
+}
+function Ws(e) {
+  if (e == null) return null;
+  if (typeof e == "string") return Qe(e);
+  if (Array.isArray(e)) {
+    for (const t of e)
+      if (t && typeof t == "object" && "text" in t) {
+        const r = t.text;
+        if (typeof r == "string") return Qe(r);
+      }
+    return null;
+  }
+  if (typeof e == "object") {
+    if ("text" in e) {
+      const t = e.text;
+      if (typeof t == "string") return Qe(t);
+    }
+    return e;
+  }
+  return null;
+}
+function kt(e, t) {
+  const r = Ws(e);
+  if (r == null) return null;
+  const a = Us.safeParse(r);
+  return a.success ? Bs(a.data, t) : null;
+}
+function _n(e, t) {
+  const r = [];
+  for (const a of e.questions) {
+    const n = t.get(a.id);
+    n === void 0 || n.trim() === "" || r.push(`Q: ${a.prompt}
+A: ${n.trim()}`);
+  }
+  return r.join(`
+
+`);
+}
+const $t = "data-spec";
+function ot(e) {
+  const t = [], r = (o) => {
+    const u = t.at(-1);
+    (u == null ? void 0 : u.kind) === "steps" ? u.steps.push(o) : t.push({ kind: "steps", steps: [o] });
+  }, a = (o) => o === "output-available" || o === "output-error";
+  let n = null;
+  for (const o of e)
+    if (!Zt(o)) {
+      if (Js(o)) {
+        const u = Ks(o);
+        u && t.push(u);
+        continue;
+      }
+      if (o.type === $t)
+        n || (n = { kind: "spec", parts: [] }, t.push(n)), n.parts.push({ type: $t, data: o.data });
+      else if (o.type === "text") {
+        const u = typeof o.text == "string" ? o.text : "";
+        u.trim().length > 0 && t.push({ kind: "text", text: u });
+      } else o.type === "reasoning" ? r({
+        kind: "reasoning",
+        label: typeof o.text == "string" ? o.text : "",
+        done: o.state !== "streaming"
+      }) : o.type === "dynamic-tool" ? r({
+        kind: "tool",
+        label: typeof o.toolName == "string" ? o.toolName : "tool",
+        done: a(o.state),
+        ...Ut(o)
+      }) : o.type.startsWith("tool-") && r({
+        kind: "tool",
+        label: o.type.slice(5),
+        done: a(o.state),
+        ...Ut(o)
+      });
+    }
+  return t;
+}
+function Vs(e) {
+  return e.type === "dynamic-tool" ? typeof e.toolName == "string" ? e.toolName : void 0 : e.type.startsWith("tool-") ? e.type.slice(5) : void 0;
+}
+function Js(e) {
+  return qs(Vs(e));
+}
+function Ks(e) {
+  const t = typeof e.toolCallId == "string" ? e.toolCallId : void 0, r = kt(e.output, t) ?? kt(e.input, t);
+  return r ? { kind: "questions", request: r } : null;
+}
+function Ut(e) {
+  return {
+    ...e.input === void 0 ? {} : { input: e.input },
+    ...e.output === void 0 ? {} : { output: e.output }
+  };
+}
+function Ys(e) {
+  return ({ id: t }) => ({
+    api: e.reconnectApi(t),
+    headers: e.headers()
+  });
+}
+function Hs(e) {
+  return new dt({
+    api: e.api,
+    headers: () => e.headers(),
+    // Every send carries its full body; a send without one is a programming
+    // error, and an empty body would be rejected server-side just as loudly.
+    prepareSendMessagesRequest: ({ body: t }) => ({ body: t ?? {} }),
+    prepareReconnectToStreamRequest: Ys(e)
+  });
+}
+function Gs({
+  existing: e,
+  fetched: t
+}) {
+  const r = new Map(
+    e.map((u) => [u.turnId, u])
+  ), a = /* @__PURE__ */ new Set(), n = [];
+  for (const u of t.turns) {
+    if (a.add(u.turn_id), u.message_uuids.length === 0) continue;
+    const i = r.get(u.turn_id);
+    if (i) {
+      Qs(i.rowIds, u.message_uuids) ? n.push(i) : n.push({ ...i, rowIds: u.message_uuids });
+      continue;
+    }
+    if (u.ui_parts !== null) {
+      const g = ot(u.ui_parts);
+      if (g.length === 0) continue;
+      n.push({
+        key: `turn-${u.turn_id}`,
+        turnId: u.turn_id,
+        rowIds: u.message_uuids,
+        items: g
+      });
+    }
+  }
+  for (const u of e)
+    a.has(u.turnId) || n.push(u);
+  return n.length === e.length && n.every((u, i) => u === e[i]) ? e : n;
+}
+const Qs = (e, t) => e.length === t.length && e.every((r, a) => r === t[a]), Xs = (e) => Array.isArray(e) && e.every((t) => typeof t == "string");
+function en(e) {
+  for (const t of e) {
+    if (t.type !== "data-turn-settled") continue;
+    const r = t.data;
+    return !Rr(r) || typeof r.turn_id != "string" || !Xs(r.message_uuids) ? null : { turnId: r.turn_id, rowIds: r.message_uuids };
+  }
+  return null;
+}
+async function tn(e) {
+  const t = e.getReader();
+  try {
+    for (; ; ) {
+      const { value: r, done: a } = await t.read();
+      if (a || r === void 0) return { kind: "silent" };
+      if (!Zt(r))
+        return Or(r) ? { kind: "steered" } : r.type === "error" ? { kind: "failed", errorText: r.errorText } : { kind: "turn" };
+    }
+  } finally {
+    await t.cancel().catch(() => {
+    });
+  }
+}
+async function rn({
+  api: e,
+  sessionId: t,
+  chatStop: r
+}) {
+  try {
+    await r();
+  } finally {
+    t && await e.stopStream(t);
+  }
+}
+const qt = 20, an = "highlight_element";
+function sn({
+  widgetCtx: e,
+  config: t,
+  sessionId: r,
+  persistedMessages: a
 }) {
-  const i = y(null), l = y(!1), [u, g] = b(null), c = m(
-    () => new P({
-      components: n
+  const { api: n, messageCtx: o } = e, u = D(t);
+  u.current = t;
+  const { pageContext: i, clientTools: g } = e.features, c = X(
+    () => Hs({
+      ...n.getStreamTransportOptions(),
+      headers: () => n.getStreamTransportOptions().headers
     }),
     [n]
+  ), {
+    status: l,
+    messages: p,
+    sendMessage: v,
+    stop: h,
+    error: T,
+    clearError: A,
+    resumeStream: _
+  } = Fs({
+    id: r ?? void 0,
+    // Reattach to a still-live turn (reload, tab switch) — but only once a
+    // session actually exists. A fresh visitor has nothing to resume, and the
+    // engine mounts with the shell, so probing unconditionally would fire a
+    // spurious reconnect request on every page load.
+    resume: r !== null,
+    transport: c,
+    // Batch token updates: without it every streamed token re-renders the
+    // whole chat surface (transcript + composer), which stutters on long
+    // replies inside customer pages.
+    throttle: 50,
+    onError: (E) => q.error("agent chat stream error", E)
+  }), S = D(p);
+  S.current = p;
+  const I = D(new Ft(qt)), R = D("idle"), d = D(Promise.resolve()), f = D(0), [m, b] = Z(0), [y, w] = Z(!1), [j, se] = Z([]), [Be, We] = Z(null), Y = D(null), ee = U((E) => {
+    Y.current = E, We(E);
+  }, []), Me = D(null), ye = D(null), be = D(l), ft = D(r), Ve = D(null), Je = D(null), mt = D(h), pe = D(l);
+  pe.current = l;
+  const Le = U((E, x) => {
+    const O = en(E.parts);
+    if (!O || O.rowIds.length === 0) return;
+    const L = ot(E.parts);
+    L.length !== 0 && se(
+      (F) => F.some((Te) => Te.turnId === O.turnId) ? F : [
+        ...F,
+        { key: x, turnId: O.turnId, rowIds: O.rowIds, items: L }
+      ]
+    );
+  }, []), Fe = U(
+    (E) => Pr({
+      config: u.current,
+      input: E.input,
+      uuid: E.retryUuid ?? E.userMessage.id,
+      sessionId: E.sessionId,
+      content: E.userMessage.content,
+      initialMessages: E.initialMessages,
+      sendsPageContext: i
+    }),
+    [i]
+  ), gt = U(
+    async (E) => {
+      const x = f.current, O = new AbortController();
+      let L;
+      try {
+        const F = await c.sendMessages({
+          trigger: "submit-message",
+          chatId: E.sessionId,
+          messageId: void 0,
+          messages: [],
+          abortSignal: O.signal,
+          body: Fe(E)
+        });
+        L = await tn(F);
+      } catch (F) {
+        q.error("agent chat steer failed", F);
+        return;
+      } finally {
+        O.abort();
+      }
+      if (x === f.current) {
+        switch (L.kind) {
+          case "steered":
+            o.markUserMessageDelivered(E.userMessage.id);
+            return;
+          case "turn":
+            ye.current = E;
+            try {
+              await h();
+            } catch (F) {
+              q.error("agent chat steer fallback: client stop failed", F);
+            }
+            if (x !== f.current) return;
+            _();
+            return;
+          case "failed":
+            q.error("agent chat steer: the turn failed", {
+              errorText: L.errorText
+            });
+            break;
+          case "silent":
+            o.markUserMessageDelivered(E.userMessage.id);
+            break;
+        }
+        e.reconcileAfterStream(E.sessionId).catch((F) => {
+          q.error("agent chat post-steer reconcile failed", F);
+        });
+      }
+    },
+    [c, Fe, o, h, _, e]
+  ), vt = D(gt);
+  vt.current = gt, $(() => {
+    const E = mt.current;
+    mt.current = h;
+    const x = ft.current;
+    if (x === r) return;
+    if (ft.current = r, x === null) {
+      se([]);
+      return;
+    }
+    const O = pe.current === "submitted" || pe.current === "streaming" || be.current === "submitted" || be.current === "streaming" || R.current === "in-flight";
+    f.current += 1, d.current = Promise.resolve(), I.current = new Ft(qt), R.current = "idle", ye.current = null, Me.current = null, Je.current = null, Ve.current = l === "submitted" || l === "streaming" ? l : null, be.current = "ready", pe.current = "ready", A(), b((L) => L + 1), w(!1), se([]), ee(null), O && Promise.resolve().then(() => E()).catch((L) => {
+      q.error("agent chat client stream cancel failed", L);
+    });
+  }, [r, l, h, A, ee]), $(() => {
+    var F, Te;
+    const E = Ve.current;
+    if (E !== null && l === E) {
+      be.current = "ready";
+      return;
+    }
+    Ve.current = null;
+    const x = be.current;
+    if (be.current = l, (l === "submitted" || l === "streaming") && (x !== "submitted" && x !== "streaming" && Y.current === null && ee(`turn-resumed-${yt()}`), w(!0)), l === "streaming") {
+      const H = (F = ye.current) == null ? void 0 : F.userMessage.id;
+      H && o.markUserMessageDelivered(H);
+      return;
+    }
+    if (l !== "ready" && l !== "error") return;
+    if (x === "streaming" || x === "submitted") {
+      R.current === "in-flight" && (R.current = "idle");
+      const H = S.current.at(-1), ne = Y.current;
+      if (Me.current = ne, ne !== null && H && H.role === "assistant" && Le(H, ne), l === "ready") {
+        const ie = (Te = ye.current) == null ? void 0 : Te.userMessage.id;
+        ie && o.markUserMessageDelivered(ie);
+      }
+      R.current === "stopping" || (r ? (R.current = "reconciling", e.reconcileAfterStream(r).catch((ie) => {
+        q.error("agent chat post-turn reconcile failed", ie);
+      }).finally(() => {
+        R.current === "reconciling" && (R.current = "idle"), b((ie) => ie + 1);
+      })) : w(!1));
+    }
+    if (R.current !== "idle" || !r) return;
+    const L = I.current.dequeueNext();
+    L && (R.current = "in-flight", ye.current = L, ee(`turn-${L.userMessage.id}`), o.appendUserMessageIfAbsent(L.userMessage), b((H) => H + 1), v(
+      { text: L.userMessage.content },
+      { body: Fe(L) }
+    ));
+  }, [
+    l,
+    r,
+    m,
+    v,
+    o,
+    e,
+    Fe,
+    Le,
+    ee
+  ]);
+  const ht = U(
+    (E) => {
+      const x = f.current, O = d.current.then(
+        async () => {
+          if (x !== f.current) return;
+          const L = R.current, F = pe.current === "streaming" && L !== "stopping" && L !== "reconciling" && I.current.size === 0, H = pe.current === "submitted" || pe.current === "streaming" || L !== "idle" || I.current.size > 0 ? nn(o.buildQueuedUserMessage(E)) : await o.stageUserTurn(E, { pending: !0 });
+          if (!H || x !== f.current) return;
+          const ne = { ...H, input: E };
+          if (F) {
+            o.appendUserMessageIfAbsent(ne.userMessage), o.notifySendAccepted(E), vt.current(ne);
+            return;
+          }
+          if (!I.current.enqueue(ne)) {
+            q.warn("agent chat queue full; rejecting newest send", {
+              rejectedMessageId: ne.userMessage.id
+            });
+            return;
+          }
+          b((ie) => ie + 1), o.notifySendAccepted(E);
+        }
+      );
+      return d.current = O.then(
+        () => {
+        },
+        () => {
+        }
+      ), O;
+    },
+    [o]
+  ), wr = U(() => {
+    const E = ye.current;
+    if (!E) return;
+    if (!I.current.enqueue({
+      ...E,
+      retryUuid: yt()
+    })) {
+      q.warn("agent chat queue full; retry not enqueued");
+      return;
+    }
+    A(), b((O) => O + 1);
+  }, [A]), Mr = U((E) => {
+    I.current.removeWhere(
+      (O) => O.userMessage.id === E
+    ) && b((O) => O + 1);
+  }, []), Tr = U(() => {
+    R.current = "stopping";
+    const E = f.current;
+    rn({ api: n, sessionId: r, chatStop: h }).catch((x) => {
+      q.error("agent chat stop failed", x);
+    }).then(() => {
+      if (E === f.current) {
+        if (!r) {
+          w(!1);
+          return;
+        }
+        return e.reconcileAfterStream(r).catch((x) => {
+          q.error("agent chat post-stop reconcile failed", x);
+        });
+      }
+    }).finally(() => {
+      E === f.current && (R.current = "idle", b((x) => x + 1));
+    });
+  }, [n, r, h, e]);
+  $(() => {
+    const E = { send: ht };
+    return o.registerAgentHandlers(E), () => o.unregisterAgentHandlers(E);
+  }, [o, ht]), $(() => {
+    if (!r || Je.current === r) return;
+    Je.current = r;
+    let E = !1;
+    return (async () => {
+      try {
+        const x = await n.getAgentTurnMessages(r);
+        if (!x || E) return;
+        se((O) => Gs({ existing: O, fetched: x }));
+      } catch (x) {
+        q.error("agent chat turn sources fetch failed", x);
+      }
+    })(), () => {
+      E = !0;
+    };
+  }, [r, n]);
+  const Ar = X(() => {
+    if (!g) return [];
+    const E = p.at(-1);
+    if (!E || E.role !== "assistant") return [];
+    const x = [];
+    for (const O of E.parts)
+      _e(O) && ws(O) === an && (O.state !== "input-available" && O.state !== "output-available" || x.push({
+        key: `${r ?? "pending"}:${O.toolCallId}`,
+        type: "highlight-element",
+        input: O.input
+      }));
+    return x;
+  }, [p, r, g]), ae = l === "submitted" || l === "streaming";
+  $(() => {
+    if (ae) return;
+    const E = Me.current;
+    if (E === null) return;
+    const x = p.at(-1);
+    x && x.role === "assistant" && Le(x, E);
+  }, [p, ae, Le]), $(() => {
+    const E = () => {
+      document.visibilityState === "visible" && r && (ae || T === void 0 && !y || _());
+    };
+    return document.addEventListener("visibilitychange", E), window.addEventListener("online", E), () => {
+      document.removeEventListener("visibilitychange", E), window.removeEventListener("online", E);
+    };
+  }, [r, ae, y, T, _]), $(() => {
+    if (!(ae || !y))
+      for (let E = a.length - 1; E >= 0; E -= 1) {
+        const x = a[E];
+        if (x) {
+          if (x.type === "USER") return;
+          if (!(x.type !== "AI" && x.type !== "AGENT")) {
+            w(!1), Y.current === Me.current && ee(null), Me.current = null;
+            return;
+          }
+        }
+      }
+  }, [ae, y, a, ee]);
+  const Cr = X(() => {
+    if (!ae && !y) return [];
+    const E = p.at(-1);
+    return !E || E.role !== "assistant" ? [] : ot(E.parts);
+  }, [p, ae, y]), xr = X(
+    () => I.current.items.map((E) => E.userMessage),
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- queueRef is mutable; queueVersion is the signal
+    [m]
+  );
+  return {
+    isStreaming: ae,
+    liveItems: Cr,
+    /** Finished turns' render sources — see `TurnRenderSource`. */
+    turnSources: j,
+    /** The live turn's node key (stable through the retained promotion). */
+    liveTurnKey: Be,
+    /** The last turn failed — the transcript renders a visible error row. */
+    turnFailed: T !== void 0,
+    retryFailedTurn: wr,
+    queuedUserMessages: xr,
+    removeQueued: Mr,
+    stop: Tr,
+    pageEffects: Ar
+  };
+}
+function nn(e) {
+  return e ? { ...e, initialMessages: [] } : null;
+}
+const vr = {
+  isStreaming: !1,
+  liveItems: [],
+  turnSources: [],
+  liveTurnKey: null,
+  turnFailed: !1,
+  retryFailedTurn: () => {
+  },
+  queuedUserMessages: [],
+  removeQueued: () => {
+  },
+  stop: () => {
+  },
+  pageEffects: [],
+  pendingClarification: null
+}, pt = Ue(null);
+function on() {
+  return qe(pt) ?? vr;
+}
+function ln({
+  children: e,
+  widgetCtx: t,
+  config: r
+}) {
+  var S, I;
+  const a = de(t.sessionCtx.sessionState), n = de(t.messageCtx.state), {
+    isStreaming: o,
+    liveItems: u,
+    turnSources: i,
+    liveTurnKey: g,
+    turnFailed: c,
+    retryFailedTurn: l,
+    queuedUserMessages: p,
+    removeQueued: v,
+    stop: h,
+    pageEffects: T
+  } = sn({
+    widgetCtx: t,
+    config: r,
+    sessionId: ((S = a.session) == null ? void 0 : S.id) ?? null,
+    persistedMessages: n.messages
+  }), A = ((I = n.messages.at(-1)) == null ? void 0 : I.type) === "USER", _ = X(
+    () => ({
+      isStreaming: o,
+      liveItems: u,
+      turnSources: i,
+      liveTurnKey: g,
+      turnFailed: c,
+      retryFailedTurn: l,
+      queuedUserMessages: p,
+      removeQueued: v,
+      stop: h,
+      pageEffects: T,
+      pendingClarification: qr({
+        turnSources: i,
+        liveItems: u,
+        isStreaming: o,
+        lastMessageIsFromUser: A
+      })
+    }),
+    [
+      o,
+      u,
+      i,
+      g,
+      c,
+      l,
+      p,
+      v,
+      h,
+      T,
+      A
+    ]
+  );
+  return /* @__PURE__ */ V.createElement(pt.Provider, { value: _ }, e);
+}
+function un({
+  children: e,
+  widgetCtx: t,
+  config: r
+}) {
+  return t.streaming ? /* @__PURE__ */ V.createElement(ln, { widgetCtx: t, config: r }, e) : /* @__PURE__ */ V.createElement(pt.Provider, { value: vr }, e);
+}
+const hr = Ue(null);
+function wn({
+  options: e,
+  children: t,
+  components: r,
+  storage: a,
+  loadingComponent: n,
+  errorComponent: o
+}) {
+  const u = D(null), i = D(null), [g, c] = Z({ status: "loading" }), l = X(
+    () => new Ur({
+      components: r
+    }),
+    [r]
   );
-  return C(() => {
-    l.current || (l.current = !0, T.initialize({ config: e, storage: o }).then(g).catch(console.error));
-  }, []), u ? /* @__PURE__ */ E.createElement(
-    U.Provider,
+  if ($(() => {
+    const v = i.current ?? (i.current = Nr.initialize({ config: e, storage: a }));
+    let h = !0;
+    return v.then(
+      (T) => {
+        h && c({ status: "ready", widgetCtx: T });
+      },
+      (T) => {
+        const A = T instanceof Error ? T : new Error("Widget initialization failed", { cause: T });
+        q.error("widget initialization failed", A), h && c({ status: "error", error: A });
+      }
+    ), () => {
+      h = !1;
+    };
+  }, []), g.status === "loading")
+    return n ? /* @__PURE__ */ V.createElement(V.Fragment, null, n) : null;
+  if (g.status === "error")
+    return o ? /* @__PURE__ */ V.createElement(V.Fragment, null, o(g.error)) : null;
+  const { widgetCtx: p } = g;
+  return /* @__PURE__ */ V.createElement(
+    hr.Provider,
     {
       value: {
-        widgetCtx: u,
+        widgetCtx: p,
         config: e,
-        components: n,
-        componentStore: c,
-        version: O,
-        contentIframeRef: i
+        components: r,
+        componentStore: l,
+        version: $r,
+        contentIframeRef: u
       }
     },
-    t
-  ) : a || null;
+    /* @__PURE__ */ V.createElement(un, { widgetCtx: p, config: e }, t)
+  );
 }
-function f() {
-  const e = F(U);
+function K() {
+  const e = qe(hr);
   if (!e)
     throw new Error("useWidget must be used within a WidgetProvider");
   return e;
 }
-function x() {
-  const { config: e } = f();
+function Mn() {
+  const { config: e, widgetCtx: t } = K(), { name: r, avatarUrl: a } = t.agent, n = e.bot;
+  return X(
+    () => ({
+      isAi: !0,
+      id: null,
+      name: (n == null ? void 0 : n.name) ?? r,
+      avatarUrl: (n == null ? void 0 : n.avatarUrl) ?? a,
+      avatar: n == null ? void 0 : n.avatar
+    }),
+    [n == null ? void 0 : n.name, n == null ? void 0 : n.avatarUrl, n == null ? void 0 : n.avatar, r, a]
+  );
+}
+function ze() {
+  const { config: e } = K();
   return e;
 }
-function w(e) {
-  return k(e.subscribe, e.get, e.get);
+function Tn() {
+  const { config: e } = K();
+  return e.displayMode ?? "popover";
 }
-function D() {
-  const { widgetCtx: e } = f();
+function An() {
+  const { widgetCtx: e } = K();
   return {
-    contactState: w(e.contactCtx.state),
+    contactState: de(e.contactCtx.state),
     createUnverifiedContact: e.contactCtx.createUnverifiedContact
   };
 }
-function I() {
-  const [e, t] = b("ltr");
-  return C(() => {
-    const n = () => {
+function cn() {
+  const [e, t] = Z("ltr");
+  return $(() => {
+    const r = () => {
       typeof document > "u" || t(
         window.getComputedStyle((window.top || window).document.body).direction
       );
     };
-    n();
-    const o = new MutationObserver(n);
-    return o.observe(document.documentElement, {
+    r();
+    const a = new MutationObserver(r);
+    return a.observe(document.documentElement, {
       attributes: !0,
       attributeFilter: ["dir"]
-    }), o.observe(document.body, {
+    }), a.observe(document.body, {
       attributes: !0,
       attributeFilter: ["dir"]
-    }), window.addEventListener("languagechange", n), () => {
-      o.disconnect(), window.removeEventListener("languagechange", n);
+    }), window.addEventListener("languagechange", r), () => {
+      a.disconnect(), window.removeEventListener("languagechange", r);
     };
   }, []), { dir: e };
 }
-function R() {
-  const { widgetCtx: e } = f();
-  return { messagesState: w(e.messageCtx.state), sendMessage: e.messageCtx.sendMessage };
+const dn = 500, Xe = "opencx:context-changed";
+function yr() {
+  if (typeof window > "u") return null;
+  try {
+    const e = window.top ?? window;
+    return e.location.href, e;
+  } catch {
+    return null;
+  }
+}
+function pn(e) {
+  const t = yr();
+  if (!t) return () => {
+  };
+  const r = (n) => {
+    (n == null ? void 0 : n.type) === Xe && (br += 1), e();
+  };
+  t.addEventListener("popstate", r), t.addEventListener("hashchange", r), t.addEventListener(Xe, r);
+  const a = t.setInterval(r, dn);
+  return () => {
+    t.removeEventListener("popstate", r), t.removeEventListener("hashchange", r), t.removeEventListener(Xe, r), t.clearInterval(a);
+  };
+}
+let br = 0;
+function fn() {
+  var e;
+  return `${br}|${((e = yr()) == null ? void 0 : e.location.href) ?? ""}`;
+}
+function Cn() {
+  return Oe(pn, fn, () => "");
+}
+function Er() {
+  const { widgetCtx: e } = K(), t = de(e.messageCtx.state), { isStreaming: r } = on();
+  return {
+    messagesState: r ? { ...t, isSendingMessage: !0, isSendingMessageToAI: !0 } : t,
+    sendMessage: e.messageCtx.sendMessage,
+    // Composer ↑/↓ recall. Owned by MessageCtx so it is scoped to this widget
+    // instance and cleared with the conversation.
+    rememberSentText: e.messageCtx.rememberSentText,
+    getSentTextHistory: e.messageCtx.getSentTextHistory
+  };
 }
-function A() {
-  const { widgetCtx: e } = f(), { oneOpenSessionAllowed: t } = x(), n = w(e.sessionCtx.sessionState), o = w(e.sessionCtx.sessionsState), { openSessions: a, closedSessions: i } = m(() => ({
-    openSessions: o.data.filter((u) => u.isOpened === !0),
-    closedSessions: o.data.filter((u) => u.isOpened === !1)
-  }), [o.data]), l = m(() => t ? a.length === 0 : !0, [t, a.length]);
+function Sr() {
+  const { widgetCtx: e } = K(), { oneOpenSessionAllowed: t } = ze(), r = de(e.sessionCtx.sessionState), a = de(e.sessionCtx.sessionsState), { openSessions: n, closedSessions: o } = X(() => ({
+    openSessions: a.data.filter((i) => i.isOpened === !0),
+    closedSessions: a.data.filter((i) => i.isOpened === !1)
+  }), [a.data]), u = X(() => t ? n.length === 0 : !0, [t, n.length]);
   return {
-    sessionState: n,
-    sessionsState: o,
+    sessionState: r,
+    sessionsState: a,
     loadMoreSessions: e.sessionCtx.loadMoreSessions,
     resolveSession: e.sessionCtx.resolveSession,
     createStateCheckpoint: e.sessionCtx.createStateCheckpoint,
-    openSessions: a,
-    closedSessions: i,
-    canCreateNewSession: l
+    openSessions: n,
+    closedSessions: o,
+    canCreateNewSession: u
   };
 }
-function z() {
-  var i, l, u;
-  const { sessionState: e } = A(), { messagesState: t } = R(), n = ((i = e.session) == null ? void 0 : i.assignee.kind) === "ai", o = ((u = (l = t.messages) == null ? void 0 : l.at(-1)) == null ? void 0 : u.type) === "USER";
-  return { isAwaitingBotReply: !!(t.isSendingMessageToAI || (n || e.isCreatingSession) && (t.isSendingMessage || o)) };
+function xn() {
+  var o, u, i;
+  const { sessionState: e } = Sr(), { messagesState: t } = Er(), r = ((o = e.session) == null ? void 0 : o.assignee.kind) === "ai", a = ((i = (u = t.messages) == null ? void 0 : u.at(-1)) == null ? void 0 : i.type) === "USER";
+  return { isAwaitingBotReply: !!(t.isSendingMessageToAI || (r || e.isCreatingSession) && (t.isSendingMessage || a)) };
 }
-function Y() {
-  const { widgetCtx: e } = f();
+function Rn() {
+  const { widgetCtx: e } = K();
   return {
-    routerState: w(e.routerCtx.state),
+    routerState: de(e.routerCtx.state),
     toSessionsScreen: e.routerCtx.toSessionsScreen,
     toChatScreen: e.routerCtx.toChatScreen
   };
 }
-const p = /* @__PURE__ */ new Map();
-function _() {
-  const [e, t] = b([]), {
-    widgetCtx: { api: n }
-  } = f();
-  function o(s) {
-    const r = s.map((d) => ({
-      file: d,
-      id: W(),
+const oe = /* @__PURE__ */ new Map();
+function On() {
+  const [e, t] = Z([]), {
+    widgetCtx: { api: r }
+  } = K();
+  function a(l) {
+    const p = l.map((v) => ({
+      file: v,
+      id: kr(),
       status: "pending",
       progress: 0
     }));
-    t((d) => [...d, ...r]), r.forEach(l);
+    t((v) => [...v, ...p]), p.forEach(u);
   }
-  function a(s, r) {
+  function n(l, p) {
     t(
-      (d) => d.map((S) => S.id === s ? { ...S, ...r } : S)
+      (v) => v.map((h) => h.id === l ? { ...h, ...p } : h)
     );
   }
-  function i(s) {
-    t((r) => r.filter((d) => d.id !== s));
+  function o(l) {
+    t((p) => p.filter((v) => v.id !== l));
   }
-  const l = async (s) => {
-    const r = new AbortController();
-    p.set(s.id, r);
+  const u = async (l) => {
+    const p = new AbortController();
+    oe.set(l.id, p);
     try {
       t(
-        (S) => S.map(
-          (h) => h.id === s.id ? { ...h, status: "uploading", progress: 0 } : h
+        (h) => h.map(
+          (T) => T.id === l.id ? { ...T, status: "uploading", progress: 0 } : T
         )
       );
-      const d = await n.uploadFile({
-        file: s.file,
-        abortSignal: r.signal,
-        onProgress: (S) => {
-          a(s.id, { progress: S });
+      const v = await r.uploadFile({
+        file: l.file,
+        abortSignal: p.signal,
+        onProgress: (h) => {
+          n(l.id, { progress: h });
         }
       });
-      a(s.id, {
+      n(l.id, {
         status: "success",
-        fileUrl: d.fileUrl,
+        fileUrl: v.fileUrl,
         progress: 100
       });
-    } catch (d) {
-      r.signal.aborted || a(s.id, {
+    } catch (v) {
+      p.signal.aborted || n(l.id, {
         status: "error",
-        error: d instanceof Error ? d.message : "Upload failed",
+        error: v instanceof Error ? v.message : "Upload failed",
         progress: 0
       });
     } finally {
-      p.delete(s.id);
+      oe.delete(l.id);
     }
-  }, u = (s) => {
-    const r = p.get(s);
-    r && (r.abort(), p.delete(s)), i(s);
-  }, g = m(() => e.filter((s) => s.status === "success" && s.fileUrl), [e]);
+  }, i = (l) => {
+    const p = oe.get(l);
+    p && (p.abort(), oe.delete(l)), o(l);
+  }, g = X(() => e.filter((l) => l.status === "success" && l.fileUrl), [e]);
   function c() {
-    p.forEach((s) => s.abort()), p.clear(), t([]);
+    oe.forEach((l) => l.abort()), oe.clear(), t([]);
   }
-  return C(() => () => {
-    p.forEach((s) => s.abort()), p.clear();
+  return $(() => () => {
+    oe.forEach((l) => l.abort()), oe.clear();
   }, []), {
     allFiles: e,
-    appendFiles: o,
-    handleCancelUpload: u,
+    appendFiles: a,
+    handleCancelUpload: i,
     successFiles: g,
     emptyTheFiles: c,
-    getFileById: (s) => e.find((r) => r.id === s),
-    getUploadProgress: (s) => {
-      var r;
-      return ((r = e.find((d) => d.id === s)) == null ? void 0 : r.progress) ?? 0;
+    getFileById: (l) => e.find((p) => p.id === l),
+    getUploadProgress: (l) => {
+      var p;
+      return ((p = e.find((v) => v.id === l)) == null ? void 0 : p.progress) ?? 0;
     },
-    getUploadStatus: (s) => {
-      var r;
-      return (r = e.find((d) => d.id === s)) == null ? void 0 : r.status;
+    getUploadStatus: (l) => {
+      var p;
+      return (p = e.find((v) => v.id === l)) == null ? void 0 : p.status;
     },
-    hasErrors: e.some((s) => s.status === "error"),
-    isUploading: e.some((s) => s.status === "uploading")
-  };
-}
-const M = v(null);
-function $({ children: e }) {
-  const t = x(), [n, o] = b(() => t.inline ? !0 : t.isOpen ?? !1);
-  return C(() => {
-    o((a) => t.isOpen ?? a);
-  }, [t.isOpen]), C(() => {
-    const a = t.openAfterNSeconds;
-    if (typeof a != "number" || isNaN(a))
+    hasErrors: e.some((l) => l.status === "error"),
+    isUploading: e.some((l) => l.status === "uploading")
+  };
+}
+const Ir = Ue(null);
+function Pn({ children: e }) {
+  const t = ze(), [r, a] = Z(() => t.inline ? !0 : t.isOpen ?? !1);
+  return $(() => {
+    a((n) => t.isOpen ?? n);
+  }, [t.isOpen]), $(() => {
+    const n = t.openAfterNSeconds;
+    if (typeof n != "number" || isNaN(n))
       return;
-    const i = setTimeout(() => o(!0), a * 1e3);
-    return () => clearTimeout(i);
-  }, [t.openAfterNSeconds]), /* @__PURE__ */ E.createElement(M.Provider, { value: { isOpen: n, setIsOpen: o } }, e);
+    const o = setTimeout(() => a(!0), n * 1e3);
+    return () => clearTimeout(o);
+  }, [t.openAfterNSeconds]), /* @__PURE__ */ V.createElement(Ir.Provider, { value: { isOpen: r, setIsOpen: a } }, e);
 }
-function j() {
-  const e = F(M);
+function Nn() {
+  const e = qe(Ir);
   if (!e)
     throw new Error(
       "useWidgetTrigger must be used within a WidgetTriggerProvider"
     );
   return e;
 }
-function G() {
-  var u, g;
-  const { widgetCtx: e } = f(), { modesComponents: t } = x(), { sessionState: n } = A(), o = e.modes, a = (u = n.session) == null ? void 0 : u.modeId, i = o.find((c) => c.id === a), l = (g = t == null ? void 0 : t.find(
+function mn(e) {
+  return e !== "fullscreen";
+}
+const _r = Ue(null);
+function jn({ children: e }) {
+  var n, o;
+  const { companion: t } = ze(), { dir: r } = cn(), { widgetCtx: a } = K();
+  return /* @__PURE__ */ V.createElement(
+    gn,
+    {
+      configuredDefaultLayout: t == null ? void 0 : t.defaultLayout,
+      configuredLayouts: t == null ? void 0 : t.layouts,
+      configuredSidebarSide: Dr((n = t == null ? void 0 : t.sidebar) == null ? void 0 : n.side, r),
+      configuredSidebarMode: jr((o = t == null ? void 0 : t.sidebar) == null ? void 0 : o.mode),
+      storage: a.storageCtx
+    },
+    e
+  );
+}
+function gn({
+  configuredDefaultLayout: e,
+  configuredLayouts: t,
+  configuredSidebarSide: r,
+  configuredSidebarMode: a,
+  storage: n,
+  children: o
+}) {
+  const u = Lr(t), i = Fr(
+    e,
+    u
+  ), g = u.join("|"), [c, l] = Z(i), [p, v] = Z({
+    defaultLayout: i,
+    allowedLayoutsKey: g
+  });
+  (p.defaultLayout !== i || p.allowedLayoutsKey !== g) && (v({ defaultLayout: i, allowedLayoutsKey: g }), (p.defaultLayout !== i || !u.includes(c)) && l(i));
+  const h = (y) => {
+    l((w) => {
+      const j = typeof y == "function" ? y(w) : y;
+      return u.includes(j) ? j : w;
+    });
+  }, T = D(u);
+  T.current = u;
+  const A = (y) => {
+    h(y), T.current.includes(y) && mn(y) && (n == null || n.setCompanionLayout(y).catch(() => {
+    }));
+  }, [_, S] = Z(r), [I, R] = Z(a), [d, f] = Z({
+    side: r,
+    mode: a
+  });
+  (d.side !== r || d.mode !== a) && (f({
+    side: r,
+    mode: a
+  }), d.side !== r && S(r), d.mode !== a && R(a)), $(() => {
+    if (!n) return;
+    let y = !1;
+    return n.getCompanionLayout().then((w) => {
+      y || !w || T.current.includes(w) && l(w);
+    }).catch(() => {
+    }), n.getCompanionSidebarSide().then((w) => {
+      !y && w && S(w);
+    }).catch(() => {
+    }), n.getCompanionSidebarMode().then((w) => {
+      !y && w && R(w);
+    }).catch(() => {
+    }), () => {
+      y = !0;
+    };
+  }, [n]);
+  const m = U(
+    (y) => {
+      S(y), n == null || n.setCompanionSidebarSide(y).catch(() => {
+      });
+    },
+    [n]
+  ), b = U(
+    (y) => {
+      R(y), n == null || n.setCompanionSidebarMode(y).catch(() => {
+      });
+    },
+    [n]
+  );
+  return /* @__PURE__ */ V.createElement(
+    _r.Provider,
+    {
+      value: {
+        layout: c,
+        setLayout: h,
+        setLayoutPreference: A,
+        allowedLayouts: u,
+        defaultLayout: i,
+        sidebarSide: _,
+        setSidebarSide: m,
+        sidebarMode: I,
+        setSidebarMode: b
+      }
+    },
+    o
+  );
+}
+function Dn() {
+  const e = qe(_r);
+  if (!e)
+    throw new Error(
+      "useWidgetLayout must be used within a WidgetLayoutProvider"
+    );
+  return e;
+}
+function Ln() {
+  var i, g;
+  const { widgetCtx: e } = K(), { modesComponents: t } = ze(), { sessionState: r } = Sr(), a = e.modes, n = (i = r.session) == null ? void 0 : i.modeId, o = a.find((c) => c.id === n), u = (g = t == null ? void 0 : t.find(
     (c) => {
-      var s, r;
+      var l, p;
       return [
-        (i == null ? void 0 : i.id) || "",
-        ((s = i == null ? void 0 : i.name) == null ? void 0 : s.toLowerCase()) || "",
-        ((r = i == null ? void 0 : i.slug) == null ? void 0 : r.toLowerCase()) || ""
+        (o == null ? void 0 : o.id) || "",
+        ((l = o == null ? void 0 : o.name) == null ? void 0 : l.toLowerCase()) || "",
+        ((p = o == null ? void 0 : o.slug) == null ? void 0 : p.toLowerCase()) || ""
       ].includes(c.key.toLowerCase());
     }
   )) == null ? void 0 : g.component;
   return {
-    modes: o,
+    modes: a,
     modesComponents: t,
-    activeModeId: a,
-    activeMode: i,
-    Component: l
+    activeModeId: n,
+    activeMode: o,
+    Component: u
   };
 }
-function H() {
-  const { widgetCtx: e } = f(), {
+function Fn() {
+  const { widgetCtx: e } = K(), {
     messagesState: { messages: t }
-  } = R(), {
-    csatRequestedMessage: n,
-    isCsatRequested: o,
-    csatSubmittedMessage: a,
-    isCsatSubmitted: i,
-    submittedScore: l,
-    submittedFeedback: u
-  } = m(() => {
+  } = Er(), {
+    csatRequestedMessage: r,
+    isCsatRequested: a,
+    csatSubmittedMessage: n,
+    isCsatSubmitted: o,
+    submittedScore: u,
+    submittedFeedback: i
+  } = X(() => {
     const g = t.find(
-      (s) => s.type === "SYSTEM" && s.subtype === "csat_requested"
+      (l) => l.type === "SYSTEM" && l.subtype === "csat_requested"
     ), c = t.findLast(
-      (s) => s.type === "SYSTEM" && s.subtype === "csat_submitted"
+      (l) => l.type === "SYSTEM" && l.subtype === "csat_submitted"
     );
     return {
       csatRequestedMessage: g,
@@ -280,29 +4802,66 @@ function H() {
   }, [t]);
   return {
     submitCsat: e.csatCtx.submitCsat,
-    csatRequestedMessage: n,
-    isCsatRequested: o,
-    csatSubmittedMessage: a,
-    isCsatSubmitted: i,
-    submittedScore: l,
-    submittedFeedback: u
+    csatRequestedMessage: r,
+    isCsatRequested: a,
+    csatSubmittedMessage: n,
+    isCsatSubmitted: o,
+    submittedScore: u,
+    submittedFeedback: i
+  };
+}
+function kn(e) {
+  const { widgetCtx: t } = K(), r = t.dictationCtx, a = de(r.state), n = D(e);
+  n.current = e;
+  const o = U(() => {
+    r.start({
+      getValue: () => n.current.getValue(),
+      setValue: (i) => n.current.setValue(i),
+      onSend: () => {
+        var i, g;
+        return (g = (i = n.current).onSend) == null ? void 0 : g.call(i);
+      }
+    });
+  }, [r]), u = U(() => {
+    r.isActive() ? r.stop() : o();
+  }, [r, o]);
+  return $(() => () => r.stop(), [r]), {
+    enabled: t.features.dictation,
+    status: a.status,
+    error: a.error,
+    isActive: a.status !== "idle",
+    /** 0..1 mic level — read inside a rAF loop, not a render. */
+    levelRef: r.levelRef,
+    start: o,
+    stop: r.stop,
+    toggle: u,
+    prewarm: r.prewarm
   };
 }
 export {
-  B as WidgetProvider,
-  $ as WidgetTriggerProvider,
-  x as useConfig,
-  D as useContact,
-  H as useCsat,
-  I as useDocumentDir,
-  z as useIsAwaitingBotReply,
-  R as useMessages,
-  G as useModes,
-  w as usePrimitiveState,
-  A as useSessions,
-  _ as useUploadFiles,
-  f as useWidget,
-  Y as useWidgetRouter,
-  j as useWidgetTrigger
+  Xe as HOST_CONTEXT_CHANGED_EVENT,
+  jn as WidgetLayoutProvider,
+  wn as WidgetProvider,
+  Pn as WidgetTriggerProvider,
+  _n as formatAskQuestionsAnswers,
+  on as useAgentChatUi,
+  Mn as useBot,
+  ze as useConfig,
+  An as useContact,
+  Fn as useCsat,
+  kn as useDictation,
+  Tn as useDisplayMode,
+  cn as useDocumentDir,
+  Cn as useHostLocation,
+  xn as useIsAwaitingBotReply,
+  Er as useMessages,
+  Ln as useModes,
+  de as usePrimitiveState,
+  Sr as useSessions,
+  On as useUploadFiles,
+  K as useWidget,
+  Dn as useWidgetLayout,
+  Rn as useWidgetRouter,
+  Nn as useWidgetTrigger
 };
 //# sourceMappingURL=index.js.map