@scalar/agent-chat 0.2.1 → 0.2.2

package/dist/node_modules/.pnpm/ai@6.0.33_zod@4.3.5/node_modules/ai/dist/index.js

@@ -0,0 +1,1768 @@
+import { parseJsonEventStream as de, generateId as ue, resolve as P, normalizeHeaders as j, withUserAgentSuffix as z, getRuntimeEnvironmentUserAgent as K, validateTypes as H, safeParseJSON as F, createIdGenerator as Y, lazySchema as ce, asSchema as k, safeValidateTypes as W, zodSchema as me } from "../../../../@ai-sdk_provider-utils@4.0.5_zod@4.3.5/node_modules/@ai-sdk/provider-utils/dist/index.js";
+import { jsonSchema as at } from "../../../../@ai-sdk_provider-utils@4.0.5_zod@4.3.5/node_modules/@ai-sdk/provider-utils/dist/index.js";
+import { TypeValidationError as ee, AISDKError as Q } from "../../../../@ai-sdk_provider@3.0.2/node_modules/@ai-sdk/provider/dist/index.js";
+import { JSONParseError as rt } from "../../../../@ai-sdk_provider@3.0.2/node_modules/@ai-sdk/provider/dist/index.js";
+import { union as C, string as o, instanceof as J, custom as te, lazy as ve, record as L, object as y, literal as v, boolean as w, unknown as O, discriminatedUnion as he, array as B, null as fe, number as ge, strictObject as b, enum as ye } from "../../../../zod@4.3.5/node_modules/zod/v4/classic/schemas.js";
+var Ie = Object.defineProperty, Ee = (s, t) => {
+  for (var n in t)
+    Ie(s, n, { get: t[n], enumerable: !0 });
+}, ae = "AI_NoObjectGeneratedError", se = `vercel.ai.error.${ae}`, be = Symbol.for(se), re, D = class extends Q {
+  constructor({
+    message: s = "No object generated.",
+    cause: t,
+    text: n,
+    response: p,
+    usage: i,
+    finishReason: l
+  }) {
+    super({ name: ae, message: s, cause: t }), this[re] = !0, this.text = n, this.response = p, this.usage = i, this.finishReason = l;
+  }
+  static isInstance(s) {
+    return Q.hasMarker(s, se);
+  }
+};
+re = be;
+var X = "6.0.33", oe = C([
+  o(),
+  J(Uint8Array),
+  J(ArrayBuffer),
+  te(
+    // Buffer might not be available in some environments such as CloudFlare:
+    (s) => {
+      var t, n;
+      return (n = (t = globalThis.Buffer) == null ? void 0 : t.isBuffer(s)) != null ? n : !1;
+    },
+    { message: "Must be a Buffer" }
+  )
+]), U = ve(
+  () => C([
+    fe(),
+    o(),
+    ge(),
+    w(),
+    L(o(), U.optional()),
+    B(U)
+  ])
+), f = L(
+  o(),
+  L(o(), U.optional())
+), ie = y({
+  type: v("text"),
+  text: o(),
+  providerOptions: f.optional()
+}), Re = y({
+  type: v("image"),
+  image: C([oe, J(URL)]),
+  mediaType: o().optional(),
+  providerOptions: f.optional()
+}), le = y({
+  type: v("file"),
+  data: C([oe, J(URL)]),
+  filename: o().optional(),
+  mediaType: o(),
+  providerOptions: f.optional()
+}), Te = y({
+  type: v("reasoning"),
+  text: o(),
+  providerOptions: f.optional()
+}), _e = y({
+  type: v("tool-call"),
+  toolCallId: o(),
+  toolName: o(),
+  input: O(),
+  providerOptions: f.optional(),
+  providerExecuted: w().optional()
+}), Se = he(
+  "type",
+  [
+    y({
+      type: v("text"),
+      value: o(),
+      providerOptions: f.optional()
+    }),
+    y({
+      type: v("json"),
+      value: U,
+      providerOptions: f.optional()
+    }),
+    y({
+      type: v("execution-denied"),
+      reason: o().optional(),
+      providerOptions: f.optional()
+    }),
+    y({
+      type: v("error-text"),
+      value: o(),
+      providerOptions: f.optional()
+    }),
+    y({
+      type: v("error-json"),
+      value: U,
+      providerOptions: f.optional()
+    }),
+    y({
+      type: v("content"),
+      value: B(
+        C([
+          y({
+            type: v("text"),
+            text: o(),
+            providerOptions: f.optional()
+          }),
+          y({
+            type: v("media"),
+            data: o(),
+            mediaType: o()
+          }),
+          y({
+            type: v("file-data"),
+            data: o(),
+            mediaType: o(),
+            filename: o().optional(),
+            providerOptions: f.optional()
+          }),
+          y({
+            type: v("file-url"),
+            url: o(),
+            providerOptions: f.optional()
+          }),
+          y({
+            type: v("file-id"),
+            fileId: C([o(), L(o(), o())]),
+            providerOptions: f.optional()
+          }),
+          y({
+            type: v("image-data"),
+            data: o(),
+            mediaType: o(),
+            providerOptions: f.optional()
+          }),
+          y({
+            type: v("image-url"),
+            url: o(),
+            providerOptions: f.optional()
+          }),
+          y({
+            type: v("image-file-id"),
+            fileId: C([o(), L(o(), o())]),
+            providerOptions: f.optional()
+          }),
+          y({
+            type: v("custom"),
+            providerOptions: f.optional()
+          })
+        ])
+      )
+    })
+  ]
+), ne = y({
+  type: v("tool-result"),
+  toolCallId: o(),
+  toolName: o(),
+  output: Se,
+  providerOptions: f.optional()
+}), xe = y({
+  type: v("tool-approval-request"),
+  approvalId: o(),
+  toolCallId: o()
+}), Me = y({
+  type: v("tool-approval-response"),
+  approvalId: o(),
+  approved: w(),
+  reason: o().optional()
+}), Ae = y(
+  {
+    role: v("system"),
+    content: o(),
+    providerOptions: f.optional()
+  }
+), we = y({
+  role: v("user"),
+  content: C([
+    o(),
+    B(C([ie, Re, le]))
+  ]),
+  providerOptions: f.optional()
+}), Ce = y({
+  role: v("assistant"),
+  content: C([
+    o(),
+    B(
+      C([
+        ie,
+        le,
+        Te,
+        _e,
+        ne,
+        xe
+      ])
+    )
+  ]),
+  providerOptions: f.optional()
+}), Ne = y({
+  role: v("tool"),
+  content: B(C([ne, Me])),
+  providerOptions: f.optional()
+});
+C([
+  Ae,
+  we,
+  Ce,
+  Ne
+]);
+function pe(s, t) {
+  if (s === void 0 && t === void 0)
+    return;
+  if (s === void 0)
+    return t;
+  if (t === void 0)
+    return s;
+  const n = { ...s };
+  for (const p in t)
+    if (Object.prototype.hasOwnProperty.call(t, p)) {
+      const i = t[p];
+      if (i === void 0)
+        continue;
+      const l = p in s ? s[p] : void 0, d = i !== null && typeof i == "object" && !Array.isArray(i) && !(i instanceof Date) && !(i instanceof RegExp), e = l != null && typeof l == "object" && !Array.isArray(l) && !(l instanceof Date) && !(l instanceof RegExp);
+      d && e ? n[p] = pe(
+        l,
+        i
+      ) : n[p] = i;
+    }
+  return n;
+}
+var Oe = {};
+Ee(Oe, {
+  array: () => Fe,
+  choice: () => Le,
+  json: () => Ue,
+  object: () => je,
+  text: () => De
+});
+function Pe(s) {
+  const t = ["ROOT"];
+  let n = -1, p = null;
+  function i(c, r, u) {
+    switch (c) {
+      case '"': {
+        n = r, t.pop(), t.push(u), t.push("INSIDE_STRING");
+        break;
+      }
+      case "f":
+      case "t":
+      case "n": {
+        n = r, p = r, t.pop(), t.push(u), t.push("INSIDE_LITERAL");
+        break;
+      }
+      case "-": {
+        t.pop(), t.push(u), 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": {
+        n = r, t.pop(), t.push(u), t.push("INSIDE_NUMBER");
+        break;
+      }
+      case "{": {
+        n = r, t.pop(), t.push(u), t.push("INSIDE_OBJECT_START");
+        break;
+      }
+      case "[": {
+        n = r, t.pop(), t.push(u), t.push("INSIDE_ARRAY_START");
+        break;
+      }
+    }
+  }
+  function l(c, r) {
+    switch (c) {
+      case ",": {
+        t.pop(), t.push("INSIDE_OBJECT_AFTER_COMMA");
+        break;
+      }
+      case "}": {
+        n = r, t.pop();
+        break;
+      }
+    }
+  }
+  function d(c, r) {
+    switch (c) {
+      case ",": {
+        t.pop(), t.push("INSIDE_ARRAY_AFTER_COMMA");
+        break;
+      }
+      case "]": {
+        n = r, t.pop();
+        break;
+      }
+    }
+  }
+  for (let c = 0; c < s.length; c++) {
+    const r = s[c];
+    switch (t[t.length - 1]) {
+      case "ROOT":
+        i(r, c, "FINISH");
+        break;
+      case "INSIDE_OBJECT_START": {
+        switch (r) {
+          case '"': {
+            t.pop(), t.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+          case "}": {
+            n = c, t.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_COMMA": {
+        switch (r) {
+          case '"': {
+            t.pop(), t.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_KEY": {
+        switch (r) {
+          case '"': {
+            t.pop(), t.push("INSIDE_OBJECT_AFTER_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_KEY": {
+        switch (r) {
+          case ":": {
+            t.pop(), t.push("INSIDE_OBJECT_BEFORE_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_BEFORE_VALUE": {
+        i(r, c, "INSIDE_OBJECT_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        l(r, c);
+        break;
+      }
+      case "INSIDE_STRING": {
+        switch (r) {
+          case '"': {
+            t.pop(), n = c;
+            break;
+          }
+          case "\\": {
+            t.push("INSIDE_STRING_ESCAPE");
+            break;
+          }
+          default:
+            n = c;
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_START": {
+        switch (r) {
+          case "]": {
+            n = c, t.pop();
+            break;
+          }
+          default: {
+            n = c, i(r, c, "INSIDE_ARRAY_AFTER_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        switch (r) {
+          case ",": {
+            t.pop(), t.push("INSIDE_ARRAY_AFTER_COMMA");
+            break;
+          }
+          case "]": {
+            n = c, t.pop();
+            break;
+          }
+          default: {
+            n = c;
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_COMMA": {
+        i(r, c, "INSIDE_ARRAY_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_STRING_ESCAPE": {
+        t.pop(), n = c;
+        break;
+      }
+      case "INSIDE_NUMBER": {
+        switch (r) {
+          case "0":
+          case "1":
+          case "2":
+          case "3":
+          case "4":
+          case "5":
+          case "6":
+          case "7":
+          case "8":
+          case "9": {
+            n = c;
+            break;
+          }
+          case "e":
+          case "E":
+          case "-":
+          case ".":
+            break;
+          case ",": {
+            t.pop(), t[t.length - 1] === "INSIDE_ARRAY_AFTER_VALUE" && d(r, c), t[t.length - 1] === "INSIDE_OBJECT_AFTER_VALUE" && l(r, c);
+            break;
+          }
+          case "}": {
+            t.pop(), t[t.length - 1] === "INSIDE_OBJECT_AFTER_VALUE" && l(r, c);
+            break;
+          }
+          case "]": {
+            t.pop(), t[t.length - 1] === "INSIDE_ARRAY_AFTER_VALUE" && d(r, c);
+            break;
+          }
+          default: {
+            t.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const m = s.substring(p, c + 1);
+        !"false".startsWith(m) && !"true".startsWith(m) && !"null".startsWith(m) ? (t.pop(), t[t.length - 1] === "INSIDE_OBJECT_AFTER_VALUE" ? l(r, c) : t[t.length - 1] === "INSIDE_ARRAY_AFTER_VALUE" && d(r, c)) : n = c;
+        break;
+      }
+    }
+  }
+  let e = s.slice(0, n + 1);
+  for (let c = t.length - 1; c >= 0; c--)
+    switch (t[c]) {
+      case "INSIDE_STRING": {
+        e += '"';
+        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": {
+        e += "}";
+        break;
+      }
+      case "INSIDE_ARRAY_START":
+      case "INSIDE_ARRAY_AFTER_COMMA":
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        e += "]";
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const u = s.substring(p, s.length);
+        "true".startsWith(u) ? e += "true".slice(u.length) : "false".startsWith(u) ? e += "false".slice(u.length) : "null".startsWith(u) && (e += "null".slice(u.length));
+      }
+    }
+  return e;
+}
+async function q(s) {
+  if (s === void 0)
+    return { value: void 0, state: "undefined-input" };
+  let t = await F({ text: s });
+  return t.success ? { value: t.value, state: "successful-parse" } : (t = await F({ text: Pe(s) }), t.success ? { value: t.value, state: "repaired-parse" } : { value: void 0, state: "failed-parse" });
+}
+var De = () => ({
+  name: "text",
+  responseFormat: Promise.resolve({ type: "text" }),
+  async parseCompleteOutput({ text: s }) {
+    return s;
+  },
+  async parsePartialOutput({ text: s }) {
+    return { partial: s };
+  },
+  createElementStreamTransform() {
+  }
+}), je = ({
+  schema: s,
+  name: t,
+  description: n
+}) => {
+  const p = k(s);
+  return {
+    name: "object",
+    responseFormat: P(p.jsonSchema).then((i) => ({
+      type: "json",
+      schema: i,
+      ...t != null && { name: t },
+      ...n != null && { description: n }
+    })),
+    async parseCompleteOutput({ text: i }, l) {
+      const d = await F({ text: i });
+      if (!d.success)
+        throw new D({
+          message: "No object generated: could not parse the response.",
+          cause: d.error,
+          text: i,
+          response: l.response,
+          usage: l.usage,
+          finishReason: l.finishReason
+        });
+      const e = await W({
+        value: d.value,
+        schema: p
+      });
+      if (!e.success)
+        throw new D({
+          message: "No object generated: response did not match schema.",
+          cause: e.error,
+          text: i,
+          response: l.response,
+          usage: l.usage,
+          finishReason: l.finishReason
+        });
+      return e.value;
+    },
+    async parsePartialOutput({ text: i }) {
+      const l = await q(i);
+      switch (l.state) {
+        case "failed-parse":
+        case "undefined-input":
+          return;
+        case "repaired-parse":
+        case "successful-parse":
+          return {
+            // Note: currently no validation of partial results:
+            partial: l.value
+          };
+      }
+    },
+    createElementStreamTransform() {
+    }
+  };
+}, Fe = ({
+  element: s,
+  name: t,
+  description: n
+}) => {
+  const p = k(s);
+  return {
+    name: "array",
+    // JSON schema that describes an array of elements:
+    responseFormat: P(p.jsonSchema).then((i) => {
+      const { $schema: l, ...d } = i;
+      return {
+        type: "json",
+        schema: {
+          $schema: "http://json-schema.org/draft-07/schema#",
+          type: "object",
+          properties: {
+            elements: { type: "array", items: d }
+          },
+          required: ["elements"],
+          additionalProperties: !1
+        },
+        ...t != null && { name: t },
+        ...n != null && { description: n }
+      };
+    }),
+    async parseCompleteOutput({ text: i }, l) {
+      const d = await F({ text: i });
+      if (!d.success)
+        throw new D({
+          message: "No object generated: could not parse the response.",
+          cause: d.error,
+          text: i,
+          response: l.response,
+          usage: l.usage,
+          finishReason: l.finishReason
+        });
+      const e = d.value;
+      if (e == null || typeof e != "object" || !("elements" in e) || !Array.isArray(e.elements))
+        throw new D({
+          message: "No object generated: response did not match schema.",
+          cause: new ee({
+            value: e,
+            cause: "response must be an object with an elements array"
+          }),
+          text: i,
+          response: l.response,
+          usage: l.usage,
+          finishReason: l.finishReason
+        });
+      for (const c of e.elements) {
+        const r = await W({
+          value: c,
+          schema: p
+        });
+        if (!r.success)
+          throw new D({
+            message: "No object generated: response did not match schema.",
+            cause: r.error,
+            text: i,
+            response: l.response,
+            usage: l.usage,
+            finishReason: l.finishReason
+          });
+      }
+      return e.elements;
+    },
+    async parsePartialOutput({ text: i }) {
+      const l = await q(i);
+      switch (l.state) {
+        case "failed-parse":
+        case "undefined-input":
+          return;
+        case "repaired-parse":
+        case "successful-parse": {
+          const d = l.value;
+          if (d == null || typeof d != "object" || !("elements" in d) || !Array.isArray(d.elements))
+            return;
+          const e = l.state === "repaired-parse" && d.elements.length > 0 ? d.elements.slice(0, -1) : d.elements, c = [];
+          for (const r of e) {
+            const u = await W({
+              value: r,
+              schema: p
+            });
+            u.success && c.push(u.value);
+          }
+          return { partial: c };
+        }
+      }
+    },
+    createElementStreamTransform() {
+      let i = 0;
+      return new TransformStream({
+        transform({ partialOutput: l }, d) {
+          if (l != null)
+            for (; i < l.length; i++)
+              d.enqueue(l[i]);
+        }
+      });
+    }
+  };
+}, Le = ({
+  options: s,
+  name: t,
+  description: n
+}) => ({
+  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: s }
+      },
+      required: ["result"],
+      additionalProperties: !1
+    },
+    ...t != null && { name: t },
+    ...n != null && { description: n }
+  }),
+  async parseCompleteOutput({ text: p }, i) {
+    const l = await F({ text: p });
+    if (!l.success)
+      throw new D({
+        message: "No object generated: could not parse the response.",
+        cause: l.error,
+        text: p,
+        response: i.response,
+        usage: i.usage,
+        finishReason: i.finishReason
+      });
+    const d = l.value;
+    if (d == null || typeof d != "object" || !("result" in d) || typeof d.result != "string" || !s.includes(d.result))
+      throw new D({
+        message: "No object generated: response did not match schema.",
+        cause: new ee({
+          value: d,
+          cause: "response must be an object that contains a choice value."
+        }),
+        text: p,
+        response: i.response,
+        usage: i.usage,
+        finishReason: i.finishReason
+      });
+    return d.result;
+  },
+  async parsePartialOutput({ text: p }) {
+    const i = await q(p);
+    switch (i.state) {
+      case "failed-parse":
+      case "undefined-input":
+        return;
+      case "repaired-parse":
+      case "successful-parse": {
+        const l = i.value;
+        if (l == null || typeof l != "object" || !("result" in l) || typeof l.result != "string")
+          return;
+        const d = s.filter(
+          (e) => e.startsWith(l.result)
+        );
+        return i.state === "successful-parse" ? d.includes(l.result) ? { partial: l.result } : void 0 : d.length === 1 ? { partial: d[0] } : void 0;
+      }
+    }
+  },
+  createElementStreamTransform() {
+  }
+}), Ue = ({
+  name: s,
+  description: t
+} = {}) => ({
+  name: "json",
+  responseFormat: Promise.resolve({
+    type: "json",
+    ...s != null && { name: s },
+    ...t != null && { description: t }
+  }),
+  async parseCompleteOutput({ text: n }, p) {
+    const i = await F({ text: n });
+    if (!i.success)
+      throw new D({
+        message: "No object generated: could not parse the response.",
+        cause: i.error,
+        text: n,
+        response: p.response,
+        usage: p.usage,
+        finishReason: p.finishReason
+      });
+    return i.value;
+  },
+  async parsePartialOutput({ text: n }) {
+    const p = await q(n);
+    switch (p.state) {
+      case "failed-parse":
+      case "undefined-input":
+        return;
+      case "repaired-parse":
+      case "successful-parse":
+        return p.value === void 0 ? void 0 : { partial: p.value };
+    }
+  },
+  createElementStreamTransform() {
+  }
+});
+Y({
+  prefix: "aitxt",
+  size: 24
+});
+var Be = ce(
+  () => me(
+    C([
+      b({
+        type: v("text-start"),
+        id: o(),
+        providerMetadata: f.optional()
+      }),
+      b({
+        type: v("text-delta"),
+        id: o(),
+        delta: o(),
+        providerMetadata: f.optional()
+      }),
+      b({
+        type: v("text-end"),
+        id: o(),
+        providerMetadata: f.optional()
+      }),
+      b({
+        type: v("error"),
+        errorText: o()
+      }),
+      b({
+        type: v("tool-input-start"),
+        toolCallId: o(),
+        toolName: o(),
+        providerExecuted: w().optional(),
+        dynamic: w().optional(),
+        title: o().optional()
+      }),
+      b({
+        type: v("tool-input-delta"),
+        toolCallId: o(),
+        inputTextDelta: o()
+      }),
+      b({
+        type: v("tool-input-available"),
+        toolCallId: o(),
+        toolName: o(),
+        input: O(),
+        providerExecuted: w().optional(),
+        providerMetadata: f.optional(),
+        dynamic: w().optional(),
+        title: o().optional()
+      }),
+      b({
+        type: v("tool-input-error"),
+        toolCallId: o(),
+        toolName: o(),
+        input: O(),
+        providerExecuted: w().optional(),
+        providerMetadata: f.optional(),
+        dynamic: w().optional(),
+        errorText: o(),
+        title: o().optional()
+      }),
+      b({
+        type: v("tool-approval-request"),
+        approvalId: o(),
+        toolCallId: o()
+      }),
+      b({
+        type: v("tool-output-available"),
+        toolCallId: o(),
+        output: O(),
+        providerExecuted: w().optional(),
+        dynamic: w().optional(),
+        preliminary: w().optional()
+      }),
+      b({
+        type: v("tool-output-error"),
+        toolCallId: o(),
+        errorText: o(),
+        providerExecuted: w().optional(),
+        dynamic: w().optional()
+      }),
+      b({
+        type: v("tool-output-denied"),
+        toolCallId: o()
+      }),
+      b({
+        type: v("reasoning-start"),
+        id: o(),
+        providerMetadata: f.optional()
+      }),
+      b({
+        type: v("reasoning-delta"),
+        id: o(),
+        delta: o(),
+        providerMetadata: f.optional()
+      }),
+      b({
+        type: v("reasoning-end"),
+        id: o(),
+        providerMetadata: f.optional()
+      }),
+      b({
+        type: v("source-url"),
+        sourceId: o(),
+        url: o(),
+        title: o().optional(),
+        providerMetadata: f.optional()
+      }),
+      b({
+        type: v("source-document"),
+        sourceId: o(),
+        mediaType: o(),
+        title: o(),
+        filename: o().optional(),
+        providerMetadata: f.optional()
+      }),
+      b({
+        type: v("file"),
+        url: o(),
+        mediaType: o(),
+        providerMetadata: f.optional()
+      }),
+      b({
+        type: te(
+          (s) => typeof s == "string" && s.startsWith("data-"),
+          { message: 'Type must start with "data-"' }
+        ),
+        id: o().optional(),
+        data: O(),
+        transient: w().optional()
+      }),
+      b({
+        type: v("start-step")
+      }),
+      b({
+        type: v("finish-step")
+      }),
+      b({
+        type: v("start"),
+        messageId: o().optional(),
+        messageMetadata: O().optional()
+      }),
+      b({
+        type: v("finish"),
+        finishReason: ye([
+          "stop",
+          "length",
+          "content-filter",
+          "tool-calls",
+          "error",
+          "other"
+        ]).optional(),
+        messageMetadata: O().optional()
+      }),
+      b({
+        type: v("abort"),
+        reason: o().optional()
+      }),
+      b({
+        type: v("message-metadata"),
+        messageMetadata: O()
+      })
+    ])
+  )
+);
+function qe(s) {
+  return s.type.startsWith("data-");
+}
+function $(s) {
+  return s.type.startsWith("tool-");
+}
+function Je(s) {
+  return s.type === "dynamic-tool";
+}
+function V(s) {
+  return $(s) || Je(s);
+}
+function Z(s) {
+  return s.type.split("-").slice(1).join("-");
+}
+function Ve({
+  lastMessage: s,
+  messageId: t
+}) {
+  return {
+    message: s?.role === "assistant" ? s : {
+      id: t,
+      metadata: void 0,
+      role: "assistant",
+      parts: []
+    },
+    activeTextParts: {},
+    activeReasoningParts: {},
+    partialToolCalls: {}
+  };
+}
+function Ye({
+  stream: s,
+  messageMetadataSchema: t,
+  dataPartSchemas: n,
+  runUpdateMessageJob: p,
+  onError: i,
+  onToolCall: l,
+  onData: d
+}) {
+  return s.pipeThrough(
+    new TransformStream({
+      async transform(e, c) {
+        await p(async ({ state: r, write: u }) => {
+          var m, x, h, S;
+          function T(a) {
+            const _ = r.message.parts.filter(V).find(
+              (E) => E.toolCallId === a
+            );
+            if (_ == null)
+              throw new Error(
+                `no tool invocation found for tool call ${a}`
+              );
+            return _;
+          }
+          function I(a) {
+            var M;
+            const _ = r.message.parts.find(
+              (N) => $(N) && N.toolCallId === a.toolCallId
+            ), E = a, R = _;
+            _ != null ? (_.state = a.state, R.input = E.input, R.output = E.output, R.errorText = E.errorText, R.rawInput = E.rawInput, R.preliminary = E.preliminary, a.title !== void 0 && (R.title = a.title), R.providerExecuted = (M = E.providerExecuted) != null ? M : _.providerExecuted, E.providerMetadata != null && _.state === "input-available" && (_.callProviderMetadata = E.providerMetadata)) : r.message.parts.push({
+              type: `tool-${a.toolName}`,
+              toolCallId: a.toolCallId,
+              state: a.state,
+              title: a.title,
+              input: E.input,
+              output: E.output,
+              rawInput: E.rawInput,
+              errorText: E.errorText,
+              providerExecuted: E.providerExecuted,
+              preliminary: E.preliminary,
+              ...E.providerMetadata != null ? { callProviderMetadata: E.providerMetadata } : {}
+            });
+          }
+          function g(a) {
+            var M, _;
+            const E = r.message.parts.find(
+              (G) => G.type === "dynamic-tool" && G.toolCallId === a.toolCallId
+            ), R = a, N = E;
+            E != null ? (E.state = a.state, N.toolName = a.toolName, N.input = R.input, N.output = R.output, N.errorText = R.errorText, N.rawInput = (M = R.rawInput) != null ? M : N.rawInput, N.preliminary = R.preliminary, a.title !== void 0 && (N.title = a.title), N.providerExecuted = (_ = R.providerExecuted) != null ? _ : E.providerExecuted, R.providerMetadata != null && E.state === "input-available" && (E.callProviderMetadata = R.providerMetadata)) : r.message.parts.push({
+              type: "dynamic-tool",
+              toolName: a.toolName,
+              toolCallId: a.toolCallId,
+              state: a.state,
+              input: R.input,
+              output: R.output,
+              errorText: R.errorText,
+              preliminary: R.preliminary,
+              providerExecuted: R.providerExecuted,
+              title: a.title,
+              ...R.providerMetadata != null ? { callProviderMetadata: R.providerMetadata } : {}
+            });
+          }
+          async function A(a) {
+            if (a != null) {
+              const M = r.message.metadata != null ? pe(r.message.metadata, a) : a;
+              t != null && await H({
+                value: M,
+                schema: t
+              }), r.message.metadata = M;
+            }
+          }
+          switch (e.type) {
+            case "text-start": {
+              const a = {
+                type: "text",
+                text: "",
+                providerMetadata: e.providerMetadata,
+                state: "streaming"
+              };
+              r.activeTextParts[e.id] = a, r.message.parts.push(a), u();
+              break;
+            }
+            case "text-delta": {
+              const a = r.activeTextParts[e.id];
+              a.text += e.delta, a.providerMetadata = (m = e.providerMetadata) != null ? m : a.providerMetadata, u();
+              break;
+            }
+            case "text-end": {
+              const a = r.activeTextParts[e.id];
+              a.state = "done", a.providerMetadata = (x = e.providerMetadata) != null ? x : a.providerMetadata, delete r.activeTextParts[e.id], u();
+              break;
+            }
+            case "reasoning-start": {
+              const a = {
+                type: "reasoning",
+                text: "",
+                providerMetadata: e.providerMetadata,
+                state: "streaming"
+              };
+              r.activeReasoningParts[e.id] = a, r.message.parts.push(a), u();
+              break;
+            }
+            case "reasoning-delta": {
+              const a = r.activeReasoningParts[e.id];
+              a.text += e.delta, a.providerMetadata = (h = e.providerMetadata) != null ? h : a.providerMetadata, u();
+              break;
+            }
+            case "reasoning-end": {
+              const a = r.activeReasoningParts[e.id];
+              a.providerMetadata = (S = e.providerMetadata) != null ? S : a.providerMetadata, a.state = "done", delete r.activeReasoningParts[e.id], u();
+              break;
+            }
+            case "file": {
+              r.message.parts.push({
+                type: "file",
+                mediaType: e.mediaType,
+                url: e.url
+              }), u();
+              break;
+            }
+            case "source-url": {
+              r.message.parts.push({
+                type: "source-url",
+                sourceId: e.sourceId,
+                url: e.url,
+                title: e.title,
+                providerMetadata: e.providerMetadata
+              }), u();
+              break;
+            }
+            case "source-document": {
+              r.message.parts.push({
+                type: "source-document",
+                sourceId: e.sourceId,
+                mediaType: e.mediaType,
+                title: e.title,
+                filename: e.filename,
+                providerMetadata: e.providerMetadata
+              }), u();
+              break;
+            }
+            case "tool-input-start": {
+              const a = r.message.parts.filter($);
+              r.partialToolCalls[e.toolCallId] = {
+                text: "",
+                toolName: e.toolName,
+                index: a.length,
+                dynamic: e.dynamic,
+                title: e.title
+              }, e.dynamic ? g({
+                toolCallId: e.toolCallId,
+                toolName: e.toolName,
+                state: "input-streaming",
+                input: void 0,
+                providerExecuted: e.providerExecuted,
+                title: e.title
+              }) : I({
+                toolCallId: e.toolCallId,
+                toolName: e.toolName,
+                state: "input-streaming",
+                input: void 0,
+                providerExecuted: e.providerExecuted,
+                title: e.title
+              }), u();
+              break;
+            }
+            case "tool-input-delta": {
+              const a = r.partialToolCalls[e.toolCallId];
+              a.text += e.inputTextDelta;
+              const { value: M } = await q(
+                a.text
+              );
+              a.dynamic ? g({
+                toolCallId: e.toolCallId,
+                toolName: a.toolName,
+                state: "input-streaming",
+                input: M,
+                title: a.title
+              }) : I({
+                toolCallId: e.toolCallId,
+                toolName: a.toolName,
+                state: "input-streaming",
+                input: M,
+                title: a.title
+              }), u();
+              break;
+            }
+            case "tool-input-available": {
+              e.dynamic ? g({
+                toolCallId: e.toolCallId,
+                toolName: e.toolName,
+                state: "input-available",
+                input: e.input,
+                providerExecuted: e.providerExecuted,
+                providerMetadata: e.providerMetadata,
+                title: e.title
+              }) : I({
+                toolCallId: e.toolCallId,
+                toolName: e.toolName,
+                state: "input-available",
+                input: e.input,
+                providerExecuted: e.providerExecuted,
+                providerMetadata: e.providerMetadata,
+                title: e.title
+              }), u(), l && !e.providerExecuted && await l({
+                toolCall: e
+              });
+              break;
+            }
+            case "tool-input-error": {
+              e.dynamic ? g({
+                toolCallId: e.toolCallId,
+                toolName: e.toolName,
+                state: "output-error",
+                input: e.input,
+                errorText: e.errorText,
+                providerExecuted: e.providerExecuted,
+                providerMetadata: e.providerMetadata
+              }) : I({
+                toolCallId: e.toolCallId,
+                toolName: e.toolName,
+                state: "output-error",
+                input: void 0,
+                rawInput: e.input,
+                errorText: e.errorText,
+                providerExecuted: e.providerExecuted,
+                providerMetadata: e.providerMetadata
+              }), u();
+              break;
+            }
+            case "tool-approval-request": {
+              const a = T(e.toolCallId);
+              a.state = "approval-requested", a.approval = { id: e.approvalId }, u();
+              break;
+            }
+            case "tool-output-denied": {
+              const a = T(e.toolCallId);
+              a.state = "output-denied", u();
+              break;
+            }
+            case "tool-output-available": {
+              const a = T(e.toolCallId);
+              a.type === "dynamic-tool" ? g({
+                toolCallId: e.toolCallId,
+                toolName: a.toolName,
+                state: "output-available",
+                input: a.input,
+                output: e.output,
+                preliminary: e.preliminary,
+                providerExecuted: e.providerExecuted,
+                title: a.title
+              }) : I({
+                toolCallId: e.toolCallId,
+                toolName: Z(a),
+                state: "output-available",
+                input: a.input,
+                output: e.output,
+                providerExecuted: e.providerExecuted,
+                preliminary: e.preliminary,
+                title: a.title
+              }), u();
+              break;
+            }
+            case "tool-output-error": {
+              const a = T(e.toolCallId);
+              a.type === "dynamic-tool" ? g({
+                toolCallId: e.toolCallId,
+                toolName: a.toolName,
+                state: "output-error",
+                input: a.input,
+                errorText: e.errorText,
+                providerExecuted: e.providerExecuted,
+                title: a.title
+              }) : I({
+                toolCallId: e.toolCallId,
+                toolName: Z(a),
+                state: "output-error",
+                input: a.input,
+                rawInput: a.rawInput,
+                errorText: e.errorText,
+                providerExecuted: e.providerExecuted,
+                title: a.title
+              }), u();
+              break;
+            }
+            case "start-step": {
+              r.message.parts.push({ type: "step-start" });
+              break;
+            }
+            case "finish-step": {
+              r.activeTextParts = {}, r.activeReasoningParts = {};
+              break;
+            }
+            case "start": {
+              e.messageId != null && (r.message.id = e.messageId), await A(e.messageMetadata), (e.messageId != null || e.messageMetadata != null) && u();
+              break;
+            }
+            case "finish": {
+              e.finishReason != null && (r.finishReason = e.finishReason), await A(e.messageMetadata), e.messageMetadata != null && u();
+              break;
+            }
+            case "message-metadata": {
+              await A(e.messageMetadata), e.messageMetadata != null && u();
+              break;
+            }
+            case "error": {
+              i?.(new Error(e.errorText));
+              break;
+            }
+            default:
+              if (qe(e)) {
+                n?.[e.type] != null && await H({
+                  value: e.data,
+                  schema: n[e.type]
+                });
+                const a = e;
+                if (a.transient) {
+                  d?.(a);
+                  break;
+                }
+                const M = a.id != null ? r.message.parts.find(
+                  (_) => a.type === _.type && a.id === _.id
+                ) : void 0;
+                M != null ? M.data = a.data : r.message.parts.push(a), d?.(a), u();
+              }
+          }
+          c.enqueue(e);
+        });
+      }
+    })
+  );
+}
+async function We({
+  stream: s,
+  onError: t
+}) {
+  const n = s.getReader();
+  try {
+    for (; ; ) {
+      const { done: p } = await n.read();
+      if (p)
+        break;
+    }
+  } catch (p) {
+    t?.(p);
+  } finally {
+    n.releaseLock();
+  }
+}
+Y({
+  prefix: "aitxt",
+  size: 24
+});
+Y({ prefix: "aiobj", size: 24 });
+var $e = 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(s) {
+    return new Promise((t, n) => {
+      this.queue.push(async () => {
+        try {
+          await s(), t();
+        } catch (p) {
+          n(p);
+        }
+      }), this.processQueue();
+    });
+  }
+};
+Y({ prefix: "aiobj", size: 24 });
+async function Ge(s) {
+  if (s == null)
+    return [];
+  if (!globalThis.FileList || !(s instanceof globalThis.FileList))
+    throw new Error("FileList is not supported in the current environment");
+  return Promise.all(
+    Array.from(s).map(async (t) => {
+      const { name: n, type: p } = t, i = await new Promise((l, d) => {
+        const e = new FileReader();
+        e.onload = (c) => {
+          var r;
+          l((r = c.target) == null ? void 0 : r.result);
+        }, e.onerror = (c) => d(c), e.readAsDataURL(t);
+      });
+      return {
+        type: "file",
+        mediaType: p,
+        filename: n,
+        url: i
+      };
+    })
+  );
+}
+var ze = class {
+  constructor({
+    api: s = "/api/chat",
+    credentials: t,
+    headers: n,
+    body: p,
+    fetch: i,
+    prepareSendMessagesRequest: l,
+    prepareReconnectToStreamRequest: d
+  }) {
+    this.api = s, this.credentials = t, this.headers = n, this.body = p, this.fetch = i, this.prepareSendMessagesRequest = l, this.prepareReconnectToStreamRequest = d;
+  }
+  async sendMessages({
+    abortSignal: s,
+    ...t
+  }) {
+    var n, p, i, l, d;
+    const e = await P(this.body), c = await P(this.headers), r = await P(this.credentials), u = {
+      ...j(c),
+      ...j(t.headers)
+    }, m = await ((n = this.prepareSendMessagesRequest) == null ? void 0 : n.call(this, {
+      api: this.api,
+      id: t.chatId,
+      messages: t.messages,
+      body: { ...e, ...t.body },
+      headers: u,
+      credentials: r,
+      requestMetadata: t.metadata,
+      trigger: t.trigger,
+      messageId: t.messageId
+    })), x = (p = m?.api) != null ? p : this.api, h = m?.headers !== void 0 ? j(m.headers) : u, S = m?.body !== void 0 ? m.body : {
+      ...e,
+      ...t.body,
+      id: t.chatId,
+      messages: t.messages,
+      trigger: t.trigger,
+      messageId: t.messageId
+    }, T = (i = m?.credentials) != null ? i : r, g = await ((l = this.fetch) != null ? l : globalThis.fetch)(x, {
+      method: "POST",
+      headers: z(
+        {
+          "Content-Type": "application/json",
+          ...h
+        },
+        `ai-sdk/${X}`,
+        K()
+      ),
+      body: JSON.stringify(S),
+      credentials: T,
+      signal: s
+    });
+    if (!g.ok)
+      throw new Error(
+        (d = await g.text()) != null ? d : "Failed to fetch the chat response."
+      );
+    if (!g.body)
+      throw new Error("The response body is empty.");
+    return this.processResponseStream(g.body);
+  }
+  async reconnectToStream(s) {
+    var t, n, p, i, l;
+    const d = await P(this.body), e = await P(this.headers), c = await P(this.credentials), r = {
+      ...j(e),
+      ...j(s.headers)
+    }, u = await ((t = this.prepareReconnectToStreamRequest) == null ? void 0 : t.call(this, {
+      api: this.api,
+      id: s.chatId,
+      body: { ...d, ...s.body },
+      headers: r,
+      credentials: c,
+      requestMetadata: s.metadata
+    })), m = (n = u?.api) != null ? n : `${this.api}/${s.chatId}/stream`, x = u?.headers !== void 0 ? j(u.headers) : r, h = (p = u?.credentials) != null ? p : c, T = await ((i = this.fetch) != null ? i : globalThis.fetch)(m, {
+      method: "GET",
+      headers: z(
+        x,
+        `ai-sdk/${X}`,
+        K()
+      ),
+      credentials: h
+    });
+    if (T.status === 204)
+      return null;
+    if (!T.ok)
+      throw new Error(
+        (l = await T.text()) != null ? l : "Failed to fetch the chat response."
+      );
+    if (!T.body)
+      throw new Error("The response body is empty.");
+    return this.processResponseStream(T.body);
+  }
+}, Ke = class extends ze {
+  constructor(s = {}) {
+    super(s);
+  }
+  processResponseStream(s) {
+    return de({
+      stream: s,
+      schema: Be
+    }).pipeThrough(
+      new TransformStream({
+        async transform(t, n) {
+          if (!t.success)
+            throw t.error;
+          n.enqueue(t.value);
+        }
+      })
+    );
+  }
+}, Ze = class {
+  constructor({
+    generateId: s = ue,
+    id: t = s(),
+    transport: n = new Ke(),
+    messageMetadataSchema: p,
+    dataPartSchemas: i,
+    state: l,
+    onError: d,
+    onToolCall: e,
+    onFinish: c,
+    onData: r,
+    sendAutomaticallyWhen: u
+  }) {
+    this.activeResponse = void 0, this.jobExecutor = new $e(), this.sendMessage = async (m, x) => {
+      var h, S, T, I;
+      if (m == null) {
+        await this.makeRequest({
+          trigger: "submit-message",
+          messageId: (h = this.lastMessage) == null ? void 0 : h.id,
+          ...x
+        });
+        return;
+      }
+      let g;
+      if ("text" in m || "files" in m ? g = {
+        parts: [
+          ...Array.isArray(m.files) ? m.files : await Ge(m.files),
+          ..."text" in m && m.text != null ? [{ type: "text", text: m.text }] : []
+        ]
+      } : g = m, m.messageId != null) {
+        const A = this.state.messages.findIndex(
+          (a) => a.id === m.messageId
+        );
+        if (A === -1)
+          throw new Error(`message with id ${m.messageId} not found`);
+        if (this.state.messages[A].role !== "user")
+          throw new Error(
+            `message with id ${m.messageId} is not a user message`
+          );
+        this.state.messages = this.state.messages.slice(0, A + 1), this.state.replaceMessage(A, {
+          ...g,
+          id: m.messageId,
+          role: (S = g.role) != null ? S : "user",
+          metadata: m.metadata
+        });
+      } else
+        this.state.pushMessage({
+          ...g,
+          id: (T = g.id) != null ? T : this.generateId(),
+          role: (I = g.role) != null ? I : "user",
+          metadata: m.metadata
+        });
+      await this.makeRequest({
+        trigger: "submit-message",
+        messageId: m.messageId,
+        ...x
+      });
+    }, this.regenerate = async ({
+      messageId: m,
+      ...x
+    } = {}) => {
+      const h = m == null ? this.state.messages.length - 1 : this.state.messages.findIndex((S) => S.id === m);
+      if (h === -1)
+        throw new Error(`message ${m} 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: m,
+        ...x
+      });
+    }, this.resumeStream = async (m = {}) => {
+      await this.makeRequest({ trigger: "resume-stream", ...m });
+    }, this.clearError = () => {
+      this.status === "error" && (this.state.error = void 0, this.setStatus({ status: "ready" }));
+    }, this.addToolApprovalResponse = async ({
+      id: m,
+      approved: x,
+      reason: h
+    }) => this.jobExecutor.run(async () => {
+      var S, T;
+      const I = this.state.messages, g = I[I.length - 1], A = (a) => V(a) && a.state === "approval-requested" && a.approval.id === m ? {
+        ...a,
+        state: "approval-responded",
+        approval: { id: m, approved: x, reason: h }
+      } : a;
+      this.state.replaceMessage(I.length - 1, {
+        ...g,
+        parts: g.parts.map(A)
+      }), this.activeResponse && (this.activeResponse.state.message.parts = this.activeResponse.state.message.parts.map(A)), this.status !== "streaming" && this.status !== "submitted" && ((S = this.sendAutomaticallyWhen) != null && S.call(this, { messages: this.state.messages })) && this.makeRequest({
+        trigger: "submit-message",
+        messageId: (T = this.lastMessage) == null ? void 0 : T.id
+      });
+    }), this.addToolOutput = async ({
+      state: m = "output-available",
+      tool: x,
+      toolCallId: h,
+      output: S,
+      errorText: T
+    }) => this.jobExecutor.run(async () => {
+      var I, g;
+      const A = this.state.messages, a = A[A.length - 1], M = (_) => V(_) && _.toolCallId === h ? { ..._, state: m, output: S, errorText: T } : _;
+      this.state.replaceMessage(A.length - 1, {
+        ...a,
+        parts: a.parts.map(M)
+      }), this.activeResponse && (this.activeResponse.state.message.parts = this.activeResponse.state.message.parts.map(M)), this.status !== "streaming" && this.status !== "submitted" && ((I = this.sendAutomaticallyWhen) != null && I.call(this, { messages: this.state.messages })) && this.makeRequest({
+        trigger: "submit-message",
+        messageId: (g = this.lastMessage) == null ? void 0 : g.id
+      });
+    }), this.addToolResult = this.addToolOutput, this.stop = async () => {
+      var m;
+      this.status !== "streaming" && this.status !== "submitted" || (m = this.activeResponse) != null && m.abortController && this.activeResponse.abortController.abort();
+    }, this.id = t, this.transport = n, this.generateId = s, this.messageMetadataSchema = p, this.dataPartSchemas = i, this.state = l, this.onError = d, this.onToolCall = e, this.onFinish = c, this.onData = r, this.sendAutomaticallyWhen = u;
+  }
+  /**
+   * 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: s,
+    error: t
+  }) {
+    this.status !== s && (this.state.status = s, 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(s) {
+    this.state.messages = s;
+  }
+  async makeRequest({
+    trigger: s,
+    metadata: t,
+    headers: n,
+    body: p,
+    messageId: i
+  }) {
+    var l, d, e, c;
+    this.setStatus({ status: "submitted", error: void 0 });
+    const r = this.lastMessage;
+    let u = !1, m = !1, x = !1;
+    try {
+      const h = {
+        state: Ve({
+          lastMessage: this.state.snapshot(r),
+          messageId: this.generateId()
+        }),
+        abortController: new AbortController()
+      };
+      h.abortController.signal.addEventListener("abort", () => {
+        u = !0;
+      }), this.activeResponse = h;
+      let S;
+      if (s === "resume-stream") {
+        const I = await this.transport.reconnectToStream({
+          chatId: this.id,
+          metadata: t,
+          headers: n,
+          body: p
+        });
+        if (I == null) {
+          this.setStatus({ status: "ready" });
+          return;
+        }
+        S = I;
+      } else
+        S = await this.transport.sendMessages({
+          chatId: this.id,
+          messages: this.state.messages,
+          abortSignal: h.abortController.signal,
+          metadata: t,
+          headers: n,
+          body: p,
+          trigger: s,
+          messageId: i
+        });
+      const T = (I) => (
+        // serialize the job execution to avoid race conditions:
+        this.jobExecutor.run(
+          () => I({
+            state: h.state,
+            write: () => {
+              var g;
+              this.setStatus({ status: "streaming" }), h.state.message.id === ((g = this.lastMessage) == null ? void 0 : g.id) ? this.state.replaceMessage(
+                this.state.messages.length - 1,
+                h.state.message
+              ) : this.state.pushMessage(h.state.message);
+            }
+          })
+        )
+      );
+      await We({
+        stream: Ye({
+          stream: S,
+          onToolCall: this.onToolCall,
+          onData: this.onData,
+          messageMetadataSchema: this.messageMetadataSchema,
+          dataPartSchemas: this.dataPartSchemas,
+          runUpdateMessageJob: T,
+          onError: (I) => {
+            throw I;
+          }
+        }),
+        onError: (I) => {
+          throw I;
+        }
+      }), this.setStatus({ status: "ready" });
+    } catch (h) {
+      if (u || h.name === "AbortError")
+        return u = !0, this.setStatus({ status: "ready" }), null;
+      x = !0, h instanceof TypeError && (h.message.toLowerCase().includes("fetch") || h.message.toLowerCase().includes("network")) && (m = !0), this.onError && h instanceof Error && this.onError(h), this.setStatus({ status: "error", error: h });
+    } finally {
+      try {
+        (d = this.onFinish) == null || d.call(this, {
+          message: this.activeResponse.state.message,
+          messages: this.state.messages,
+          isAbort: u,
+          isDisconnect: m,
+          isError: x,
+          finishReason: (l = this.activeResponse) == null ? void 0 : l.state.finishReason
+        });
+      } catch (h) {
+        console.error(h);
+      }
+      this.activeResponse = void 0;
+    }
+    (e = this.sendAutomaticallyWhen) != null && e.call(this, { messages: this.state.messages }) && !x && await this.makeRequest({
+      trigger: "submit-message",
+      messageId: (c = this.lastMessage) == null ? void 0 : c.id,
+      metadata: t,
+      headers: n,
+      body: p
+    });
+  }
+};
+function ke({
+  messages: s
+}) {
+  const t = s[s.length - 1];
+  if (!t || t.role !== "assistant")
+    return !1;
+  const n = t.parts.reduce((i, l, d) => l.type === "step-start" ? d : i, -1), p = t.parts.slice(n + 1).filter(V).filter((i) => !i.providerExecuted);
+  return (
+    // has at least one tool approval response
+    p.filter((i) => i.state === "approval-responded").length > 0 && // all tool approvals must have a response
+    p.every(
+      (i) => i.state === "output-available" || i.state === "output-error" || i.state === "approval-responded"
+    )
+  );
+}
+export {
+  Q as AISDKError,
+  Ze as AbstractChat,
+  Ke as DefaultChatTransport,
+  ze as HttpChatTransport,
+  rt as JSONParseError,
+  D as NoObjectGeneratedError,
+  Oe as Output,
+  $e as SerialJobExecutor,
+  ee as TypeValidationError,
+  k as asSchema,
+  Ce as assistantModelMessageSchema,
+  We as consumeStream,
+  Ge as convertFileListToFileUIParts,
+  Y as createIdGenerator,
+  ue as generateId,
+  Z as getStaticToolName,
+  $ as isStaticToolUIPart,
+  V as isToolUIPart,
+  at as jsonSchema,
+  ke as lastAssistantMessageIsCompleteWithApprovalResponses,
+  de as parseJsonEventStream,
+  q as parsePartialJson,
+  Ae as systemModelMessageSchema,
+  Ne as toolModelMessageSchema,
+  Be as uiMessageChunkSchema,
+  we as userModelMessageSchema,
+  me as zodSchema
+};