@qfei-design/make-ai-assistant 0.2.8 → 0.2.10

package/dist/conversation-CZfbgCXd.js

@@ -0,0 +1,1111 @@
+const j = (t, e) => {
+  let s = 0;
+  for (const n of t)
+    if (s += 1, s > e) break;
+  return s;
+}, Pt = "1.0", m = {
+  actions: 10,
+  comparisonItems: 24,
+  jsonCharacters: 1e6,
+  jsonDepth: 64,
+  jsonNodes: 1e4,
+  rankingItems: 50,
+  recordColumns: 20,
+  recordListRecords: 100,
+  recordValues: 100,
+  textCharacters: 2e4,
+  trendPointsPerSeries: 120,
+  trendSeries: 8,
+  validationIssues: 100
+}, f = {
+  artifactsPerRun: 50,
+  assistantMessagesPerRun: 20,
+  historyArtifacts: 500,
+  historyCharacters: 1e6,
+  historyMessages: 200,
+  identifierCharacters: 1e3,
+  messageCharacters: 1e5,
+  progressCharactersPerRun: 2e4,
+  progressStepsPerRun: 50
+}, Z = [
+  "metric",
+  "comparison",
+  "trend",
+  "ranking",
+  "record-list",
+  "notice"
+], M = () => ({
+  success: !1,
+  issues: [{ path: "", message: "could not be safely inspected" }]
+}), tt = /* @__PURE__ */ new Set(["navigate", "open-record", "open-list", "invoke"]), et = /* @__PURE__ */ new Set(["decimal", "currency", "percent"]);
+class z extends Array {
+  push(...e) {
+    const s = m.validationIssues - this.length;
+    return s > 0 ? super.push(...e.slice(0, s)) : this.length;
+  }
+}
+const u = (t) => (() => {
+  if (typeof t != "object" || t === null || Array.isArray(t))
+    return !1;
+  const e = Object.getPrototypeOf(t);
+  return e === Object.prototype || e === null;
+})(), U = (t) => typeof t == "string" && t.trim().length > 0, Y = (t, e) => {
+  let s = 0;
+  for (const n of t)
+    if (s += 1, s > e) return s;
+  return s;
+}, A = (t) => typeof t == "string" && Y(t, m.textCharacters) <= m.textCharacters, R = (t) => typeof t == "number" && Number.isFinite(t), st = (t) => t.length <= 120 ? t : `${t.slice(0, 117)}...`, b = (t, e, s) => {
+  U(t) ? A(t) || s.push({
+    path: e,
+    message: `must contain at most ${m.textCharacters} characters`
+  }) : s.push({ path: e, message: "must be a non-empty string" });
+}, C = (t, e, s) => {
+  t !== void 0 && typeof t != "string" ? s.push({ path: e, message: "must be a string" }) : typeof t == "string" && !A(t) && s.push({
+    path: e,
+    message: `must contain at most ${m.textCharacters} characters`
+  });
+}, I = (t, e, s, n) => {
+  for (const a in t)
+    if (Object.prototype.hasOwnProperty.call(t, a)) {
+      if (n.length >= m.validationIssues) break;
+      e.has(a) || n.push({
+        path: st(s ? `${s}.${a}` : a),
+        message: "is not supported"
+      });
+    }
+}, $ = (t, e, s, n) => t.length > e ? (n.push({ path: s, message: `must contain at most ${e} items` }), !0) : !1, _ = (t, e, s) => {
+  for (let n = 0; n < t.length; n += 1)
+    if (!Object.prototype.hasOwnProperty.call(t, n))
+      return s.push({ path: e, message: "must not contain empty array slots" }), !0;
+  return !1;
+}, T = (t, e, s, n) => {
+  const a = /* @__PURE__ */ new Set();
+  t.forEach((r, o) => {
+    if (!u(r) || typeof r[e] != "string") return;
+    const d = r[e];
+    a.has(d) ? n.push({
+      path: `${s}[${o}].${e}`,
+      message: "must be unique within the collection"
+    }) : a.add(d);
+  });
+}, rt = /* @__PURE__ */ new Set([
+  "schemaVersion",
+  "id",
+  "kind",
+  "title",
+  "summary",
+  "presentation",
+  "actions",
+  "meta",
+  "data"
+]), nt = /* @__PURE__ */ new Set(["template", "density"]), at = /* @__PURE__ */ new Set(["style", "currency", "precision", "unit"]), ot = /* @__PURE__ */ new Set(["id", "label", "intent", "target", "appearance"]), it = /* @__PURE__ */ new Set(["value", "format", "delta", "context"]), ct = /* @__PURE__ */ new Set(["value", "format", "direction", "label"]), W = /* @__PURE__ */ new Set(["items"]), dt = /* @__PURE__ */ new Set(["id", "label", "value", "format", "hint"]), pt = /* @__PURE__ */ new Set(["series"]), mt = /* @__PURE__ */ new Set(["id", "label", "points", "format"]), lt = /* @__PURE__ */ new Set(["x", "y"]), ft = /* @__PURE__ */ new Set([
+  "id",
+  "label",
+  "value",
+  "format",
+  "description"
+]), ut = /* @__PURE__ */ new Set(["entity", "columns", "records", "total"]), ht = /* @__PURE__ */ new Set(["key", "label"]), It = /* @__PURE__ */ new Set(["key", "label", "format"]), gt = /* @__PURE__ */ new Set(["id", "title", "values", "action"]), yt = /* @__PURE__ */ new Set(["tone", "body"]), v = (t, e, s) => u(t) ? (I(t, at, e, s), t.style !== void 0 && (typeof t.style != "string" || !et.has(t.style)) && s.push({ path: `${e}.style`, message: "is not supported" }), t.currency !== void 0 && b(t.currency, `${e}.currency`, s), t.precision !== void 0 && (!Number.isInteger(t.precision) || Number(t.precision) < 0 || Number(t.precision) > 20) && s.push({ path: `${e}.precision`, message: "must be an integer between 0 and 20" }), C(t.unit, `${e}.unit`, s), !0) : (s.push({ path: e, message: "must be an object" }), !1), P = (t) => {
+  const e = [{ kind: "visit", depth: 0, value: t }], s = /* @__PURE__ */ new WeakSet();
+  let n = 0, a = 0;
+  try {
+    for (; e.length > 0; ) {
+      const r = e.pop();
+      if (!r) break;
+      if (r.kind === "leave") {
+        s.delete(r.value);
+        continue;
+      }
+      if (a += 1, a > m.jsonNodes || r.depth > m.jsonDepth)
+        return !1;
+      if (r.value === null || typeof r.value == "boolean")
+        continue;
+      if (typeof r.value == "string") {
+        if (n += Y(
+          r.value,
+          m.textCharacters
+        ), !A(r.value) || n > m.jsonCharacters) return !1;
+        continue;
+      }
+      if (typeof r.value == "number") {
+        if (!Number.isFinite(r.value)) return !1;
+        continue;
+      }
+      if (!Array.isArray(r.value) && !u(r.value) || s.has(r.value)) return !1;
+      s.add(r.value), e.push({ kind: "leave", value: r.value });
+      const o = m.jsonNodes - a;
+      if (Array.isArray(r.value)) {
+        if (r.value.length > o) return !1;
+        for (let d = r.value.length - 1; d >= 0; d -= 1)
+          e.push({
+            kind: "visit",
+            depth: r.depth + 1,
+            value: r.value[d]
+          });
+      } else {
+        const d = [];
+        for (const p in r.value)
+          if (Object.prototype.hasOwnProperty.call(r.value, p)) {
+            if (!A(p) || (n += Y(
+              p,
+              m.textCharacters
+            ), n > m.jsonCharacters) || d.length >= o) return !1;
+            d.push(p);
+          }
+        for (let p = d.length - 1; p >= 0; p -= 1) {
+          const i = d[p];
+          e.push({
+            kind: "visit",
+            depth: r.depth + 1,
+            value: r.value[i]
+          });
+        }
+      }
+    }
+    return !0;
+  } catch {
+    return !1;
+  }
+}, bt = (t) => t === null || typeof t == "boolean" || A(t) || R(t), G = (t, e, s) => u(t) ? (I(t, ot, e, s), b(t.id, `${e}.id`, s), b(t.label, `${e}.label`, s), (typeof t.intent != "string" || !tt.has(t.intent)) && s.push({ path: `${e}.intent`, message: "is not supported" }), (!u(t.target) || !P(t.target)) && s.push({ path: `${e}.target`, message: "must be a JSON object" }), t.appearance !== void 0 && (typeof t.appearance != "string" || !["primary", "secondary", "link"].includes(t.appearance)) && s.push({ path: `${e}.appearance`, message: "is not supported" }), !0) : (s.push({ path: e, message: "must be an object" }), !1), wt = (t, e) => {
+  if (I(t, rt, "", e), t.schemaVersion !== "1.0" && e.push({ path: "schemaVersion", message: "must equal 1.0" }), b(t.id, "id", e), Z.includes(t.kind) || e.push({ path: "kind", message: "is not a supported Artifact kind" }), C(t.title, "title", e), C(t.summary, "summary", e), t.presentation !== void 0 && (u(t.presentation) ? (I(t.presentation, nt, "presentation", e), t.presentation.template !== void 0 && !U(t.presentation.template) ? e.push({ path: "presentation.template", message: "must be a non-empty string" }) : t.presentation.template !== void 0 && !A(t.presentation.template) && e.push({
+    path: "presentation.template",
+    message: `must contain at most ${m.textCharacters} characters`
+  }), t.presentation.density !== void 0 && (typeof t.presentation.density != "string" || !["compact", "comfortable"].includes(t.presentation.density)) && e.push({ path: "presentation.density", message: "is not supported" })) : e.push({ path: "presentation", message: "must be an object" })), t.actions !== void 0) {
+    if (!Array.isArray(t.actions))
+      e.push({ path: "actions", message: "must be an array" });
+    else if (!$(
+      t.actions,
+      m.actions,
+      "actions",
+      e
+    )) {
+      if (_(t.actions, "actions", e)) return;
+      T(t.actions, "id", "actions", e), t.actions.forEach(
+        (n, a) => G(n, `actions[${a}]`, e)
+      );
+    }
+  }
+  t.meta !== void 0 && (!u(t.meta) || !P(t.meta)) && e.push({ path: "meta", message: "must be a JSON object" });
+}, St = (t, e) => {
+  I(t, it, "data", e), !R(t.value) && !A(t.value) && e.push({ path: "data.value", message: "must be a finite number or string" }), t.format !== void 0 && v(t.format, "data.format", e), t.delta !== void 0 && (u(t.delta) ? (I(
+    t.delta,
+    ct,
+    "data.delta",
+    e
+  ), R(t.delta.value) || e.push({ path: "data.delta.value", message: "must be a finite number" }), t.delta.direction !== void 0 && (typeof t.delta.direction != "string" || !["up", "down", "flat"].includes(t.delta.direction)) && e.push({ path: "data.delta.direction", message: "is not supported" }), t.delta.format !== void 0 && (typeof t.delta.format != "string" || !["decimal", "percent"].includes(t.delta.format)) && e.push({ path: "data.delta.format", message: "is not supported" }), C(t.delta.label, "data.delta.label", e)) : e.push({ path: "data.delta", message: "must be an object" })), C(t.context, "data.context", e);
+}, Et = (t, e) => {
+  if (I(t, W, "data", e), !Array.isArray(t.items) || t.items.length === 0) {
+    e.push({ path: "data.items", message: "must be a non-empty array" });
+    return;
+  }
+  $(
+    t.items,
+    m.comparisonItems,
+    "data.items",
+    e
+  ) || _(t.items, "data.items", e) || (T(t.items, "id", "data.items", e), t.items.forEach((s, n) => {
+    const a = `data.items[${n}]`;
+    if (!u(s)) {
+      e.push({ path: a, message: "must be an object" });
+      return;
+    }
+    I(
+      s,
+      dt,
+      a,
+      e
+    ), b(s.id, `${a}.id`, e), b(s.label, `${a}.label`, e), !R(s.value) && !A(s.value) && e.push({ path: `${a}.value`, message: "must be a finite number or string" }), s.format !== void 0 && v(s.format, `${a}.format`, e), C(s.hint, `${a}.hint`, e);
+  }));
+}, At = (t, e) => {
+  if (I(t, pt, "data", e), !Array.isArray(t.series) || t.series.length === 0) {
+    e.push({ path: "data.series", message: "must be a non-empty array" });
+    return;
+  }
+  $(
+    t.series,
+    m.trendSeries,
+    "data.series",
+    e
+  ) || _(t.series, "data.series", e) || (T(t.series, "id", "data.series", e), t.series.forEach((s, n) => {
+    const a = `data.series[${n}]`;
+    if (!u(s)) {
+      e.push({ path: a, message: "must be an object" });
+      return;
+    }
+    if (I(
+      s,
+      mt,
+      a,
+      e
+    ), b(s.id, `${a}.id`, e), b(s.label, `${a}.label`, e), s.format !== void 0 && v(s.format, `${a}.format`, e), !Array.isArray(s.points) || s.points.length === 0) {
+      e.push({ path: `${a}.points`, message: "must be a non-empty array" });
+      return;
+    }
+    $(
+      s.points,
+      m.trendPointsPerSeries,
+      `${a}.points`,
+      e
+    ) || _(s.points, `${a}.points`, e) || s.points.forEach((r, o) => {
+      const d = `${a}.points[${o}]`;
+      if (!u(r)) {
+        e.push({ path: d, message: "must be an object" });
+        return;
+      }
+      I(r, lt, d, e), !R(r.x) && !A(r.x) && e.push({ path: `${d}.x`, message: "must be a finite number or string" }), R(r.y) || e.push({ path: `${d}.y`, message: "must be a finite number" });
+    });
+  }));
+}, kt = (t, e) => {
+  if (I(t, W, "data", e), !Array.isArray(t.items) || t.items.length === 0) {
+    e.push({ path: "data.items", message: "must be a non-empty array" });
+    return;
+  }
+  $(
+    t.items,
+    m.rankingItems,
+    "data.items",
+    e
+  ) || _(t.items, "data.items", e) || (T(t.items, "id", "data.items", e), t.items.forEach((s, n) => {
+    const a = `data.items[${n}]`;
+    if (!u(s)) {
+      e.push({ path: a, message: "must be an object" });
+      return;
+    }
+    I(
+      s,
+      ft,
+      a,
+      e
+    ), b(s.id, `${a}.id`, e), b(s.label, `${a}.label`, e), R(s.value) || e.push({ path: `${a}.value`, message: "must be a finite number" }), s.format !== void 0 && v(s.format, `${a}.format`, e), C(s.description, `${a}.description`, e);
+  }));
+}, Ct = (t, e) => {
+  if (I(
+    t,
+    ut,
+    "data",
+    e
+  ), u(t.entity) ? (I(t.entity, ht, "data.entity", e), b(t.entity.key, "data.entity.key", e), C(t.entity.label, "data.entity.label", e)) : e.push({ path: "data.entity", message: "must be an object" }), !Array.isArray(t.columns) || t.columns.length === 0)
+    e.push({ path: "data.columns", message: "must be a non-empty array" });
+  else if (!$(
+    t.columns,
+    m.recordColumns,
+    "data.columns",
+    e
+  )) {
+    if (_(t.columns, "data.columns", e)) return;
+    T(t.columns, "key", "data.columns", e), t.columns.forEach((n, a) => {
+      const r = `data.columns[${a}]`;
+      if (!u(n)) {
+        e.push({ path: r, message: "must be an object" });
+        return;
+      }
+      I(
+        n,
+        It,
+        r,
+        e
+      ), b(n.key, `${r}.key`, e), b(n.label, `${r}.label`, e), n.format !== void 0 && v(n.format, `${r}.format`, e);
+    });
+  }
+  if (!Array.isArray(t.records))
+    e.push({ path: "data.records", message: "must be an array" });
+  else if (!$(
+    t.records,
+    m.recordListRecords,
+    "data.records",
+    e
+  )) {
+    if (_(t.records, "data.records", e)) return;
+    T(t.records, "id", "data.records", e), t.records.forEach((n, a) => {
+      const r = `data.records[${a}]`;
+      if (!u(n)) {
+        e.push({ path: r, message: "must be an object" });
+        return;
+      }
+      if (I(
+        n,
+        gt,
+        r,
+        e
+      ), b(n.id, `${r}.id`, e), C(n.title, `${r}.title`, e), !u(n.values))
+        e.push({
+          path: `${r}.values`,
+          message: "must contain only JSON primitive display values"
+        });
+      else {
+        const o = n.values;
+        let d = !1, p = 0;
+        for (const i in o)
+          if (Object.prototype.hasOwnProperty.call(o, i)) {
+            if (p += 1, p > m.recordValues) break;
+            d ||= !A(i) || !bt(o[i]);
+          }
+        p > m.recordValues ? e.push({
+          path: `${r}.values`,
+          message: `must contain at most ${m.recordValues} values`
+        }) : d && e.push({
+          path: `${r}.values`,
+          message: "must contain only JSON primitive display values"
+        });
+      }
+      n.action !== void 0 && G(n.action, `${r}.action`, e);
+    });
+  }
+  t.total !== void 0 && (!Number.isInteger(t.total) || Number(t.total) < 0) && e.push({ path: "data.total", message: "must be a non-negative integer" });
+}, Rt = (t, e) => {
+  I(t, yt, "data", e), (typeof t.tone != "string" || !["info", "success", "warning", "danger"].includes(t.tone)) && e.push({ path: "data.tone", message: "is not supported" }), b(t.body, "data.body", e);
+}, B = (t, e) => {
+  if (wt(t, e), !u(t.data)) {
+    e.push({ path: "data", message: "must be an object" });
+    return;
+  }
+  switch (t.kind) {
+    case "metric":
+      St(t.data, e);
+      break;
+    case "comparison":
+      Et(t.data, e);
+      break;
+    case "trend":
+      At(t.data, e);
+      break;
+    case "ranking":
+      kt(t.data, e);
+      break;
+    case "record-list":
+      Ct(t.data, e);
+      break;
+    case "notice":
+      Rt(t.data, e);
+      break;
+  }
+}, $t = (t) => {
+  const e = new z();
+  try {
+    if (!u(t))
+      return { success: !1, issues: [{ path: "", message: "must be an object" }] };
+    B(t, e);
+  } catch {
+    return M();
+  }
+  if (e.length > 0) return { success: !1, issues: e };
+  if (!P(t))
+    return {
+      success: !1,
+      issues: [{ path: "", message: "exceeds the Artifact resource budget" }]
+    };
+  let s;
+  try {
+    s = structuredClone(t);
+  } catch {
+    return M();
+  }
+  const n = new z();
+  try {
+    if (!u(s)) return M();
+    B(s, n);
+  } catch {
+    return M();
+  }
+  return n.length === 0 && !P(s) && n.push({
+    path: "",
+    message: "exceeds the Artifact resource budget"
+  }), n.length === 0 ? { success: !0, artifact: s } : { success: !1, issues: n };
+}, H = (t) => {
+  const e = $t(t);
+  if (e.success) return e.artifact;
+  const s = e.issues.map((n) => `${n.path || "artifact"} ${n.message}`).join(", ");
+  throw new Error(`Invalid Make AI Artifact: ${s}`);
+}, k = (t) => t === "completed" || t === "failed" || t === "cancelled", x = (t) => {
+  if (!t || typeof t != "object" || Array.isArray(t))
+    throw new Error("Invalid assistant data: object");
+  return t;
+}, S = (t, e = 256, s = !1) => {
+  if (typeof t != "string" || t.length > e * 2 || !s && !t.trim() || t.includes("\0") || [...t].length > e)
+    throw new Error("Invalid assistant data: text");
+  return t;
+}, h = (t) => {
+  const e = S(t);
+  if (["__proto__", "constructor", "prototype"].includes(e))
+    throw new Error("Invalid assistant data: identifier");
+  return e;
+}, N = (t, e = 0, s = Number.MAX_SAFE_INTEGER) => {
+  if (!Number.isSafeInteger(t) || Number(t) < e || Number(t) > s)
+    throw new Error("Invalid assistant data: integer");
+  return t;
+}, q = (t) => {
+  if (typeof t != "boolean")
+    throw new Error("Invalid assistant data: boolean");
+  return t;
+}, F = (t, e) => {
+  if (!Array.isArray(t) || t.length > e)
+    throw new Error("Invalid assistant data: array");
+  return t;
+}, y = (t, e) => {
+  if (Object.keys(t).some((s) => !e.includes(s)))
+    throw new Error("Invalid assistant data: unknown field");
+}, V = (t) => {
+  if (![
+    "queued",
+    "dispatched",
+    "running",
+    "completed",
+    "failed",
+    "cancelled"
+  ].includes(String(t)))
+    throw new Error("Invalid assistant data: status");
+  return t;
+}, L = (t) => F(t, 32).map((e) => {
+  const s = x(e), n = s.id === void 0 ? {} : { id: h(s.id) };
+  if (s.kind === "text")
+    return y(s, ["id", "kind", "text"]), {
+      ...n,
+      kind: "text",
+      text: S(s.text, 1e5, !0)
+    };
+  if (!["image", "file", "audio", "video"].includes(String(s.kind)))
+    throw new Error("Invalid assistant data: part kind");
+  y(s, ["id", "kind", "name", "media"]);
+  const a = x(s.media);
+  y(a, [
+    "contentRef",
+    "contentType",
+    "sizeBytes",
+    "digestSha256"
+  ]);
+  const r = S(a.digestSha256, 64);
+  if (!/^[0-9a-f]{64}$/.test(r))
+    throw new Error("Invalid assistant data: digest");
+  return {
+    ...n,
+    kind: s.kind,
+    ...s.name === void 0 ? {} : { name: S(s.name, 512, !0) },
+    media: {
+      contentRef: h(a.contentRef),
+      contentType: S(a.contentType, 256),
+      sizeBytes: N(a.sizeBytes, 0, 64 << 20),
+      digestSha256: r
+    }
+  };
+}), X = (t) => {
+  const e = x(t);
+  if (y(e, ["id", "rating", "revision", "reason", "comment"]), !["like", "dislike", "none"].includes(String(e.rating)))
+    throw new Error("Invalid assistant data: rating");
+  return {
+    id: h(e.id),
+    rating: e.rating,
+    revision: N(e.revision, 1),
+    ...e.reason === void 0 ? {} : { reason: S(e.reason, 128, !0) },
+    ...e.comment === void 0 ? {} : { comment: S(e.comment, 4e3, !0) }
+  };
+}, _t = (t) => {
+  const e = x(t);
+  return y(e, [
+    "itemId",
+    "partId",
+    "text",
+    "final",
+    "revision",
+    "parts"
+  ]), {
+    itemId: h(e.itemId),
+    partId: h(e.partId),
+    text: S(e.text, 1e5, !0),
+    final: q(e.final),
+    revision: N(e.revision, 1),
+    ...e.parts === void 0 ? {} : { parts: L(e.parts) }
+  };
+}, xt = (t) => {
+  const e = x(t);
+  y(e, [
+    "chatId",
+    "responseId",
+    "status",
+    "items",
+    "cancelRequested"
+  ]);
+  const s = F(e.items, 20).map(_t);
+  if (new Set(s.map((n) => n.itemId)).size !== s.length || s.reduce((n, a) => n + [...a.text].length, 0) > 1e5)
+    throw new Error("Invalid assistant data: output budget or identity");
+  return {
+    chatId: h(e.chatId),
+    responseId: h(e.responseId),
+    status: V(e.status),
+    items: s,
+    ...e.cancelRequested === void 0 ? {} : { cancelRequested: q(e.cancelRequested) }
+  };
+}, Nt = (t) => {
+  const e = x(t);
+  if (y(e, [
+    "id",
+    "role",
+    "content",
+    "persistent",
+    "responseId",
+    "cursor",
+    "createdAt",
+    "parts",
+    "feedback"
+  ]), e.role !== "assistant" && e.role !== "user" || e.persistent !== !0)
+    throw new Error("Invalid assistant data: persisted message");
+  return {
+    id: h(e.id),
+    role: e.role,
+    content: S(e.content, 1e5, !0),
+    persistent: !0,
+    cursor: N(e.cursor),
+    createdAt: S(e.createdAt, 64),
+    ...e.responseId === void 0 ? {} : { responseId: h(e.responseId) },
+    ...e.parts === void 0 ? {} : { parts: L(e.parts) },
+    ...e.feedback === void 0 ? {} : { feedback: X(e.feedback) }
+  };
+}, Ot = (t) => {
+  const e = x(t), s = e.type;
+  if (s === "response.snapshot")
+    return y(e, ["type", "snapshot"]), { type: s, snapshot: xt(e.snapshot) };
+  const n = h(e.responseId);
+  if (s === "response.accepted")
+    return y(e, [
+      "type",
+      "chatId",
+      "responseId",
+      "messageId",
+      "acceptedCursor"
+    ]), {
+      type: s,
+      responseId: n,
+      chatId: h(e.chatId),
+      messageId: h(e.messageId),
+      acceptedCursor: N(e.acceptedCursor)
+    };
+  if (s === "response.state")
+    return y(e, ["type", "chatId", "responseId", "status"]), {
+      type: s,
+      responseId: n,
+      chatId: h(e.chatId),
+      status: V(e.status)
+    };
+  if (s === "response.terminal") {
+    y(e, ["type", "chatId", "responseId", "status", "code"]);
+    const p = V(e.status);
+    if (!k(p))
+      throw new Error("Invalid assistant data: terminal");
+    return {
+      type: s,
+      responseId: n,
+      chatId: h(e.chatId),
+      status: p,
+      ...e.code === void 0 ? {} : { code: h(e.code) }
+    };
+  }
+  if (s === "response.reconciled") {
+    y(e, ["type", "chatId", "responseId", "messages"]);
+    const p = F(e.messages, 200).map(Nt);
+    if (p.some((i) => i.responseId !== n) || new Set(p.map((i) => i.id)).size !== p.length || p.reduce((i, c) => i + [...c.content].length, 0) > 1e6)
+      throw new Error("Invalid assistant data: response history");
+    return { type: s, responseId: n, chatId: h(e.chatId), messages: p };
+  }
+  const a = h(e.itemId), r = h(e.partId), o = N(e.sequence, 1), d = ["type", "responseId", "itemId", "partId", "sequence"];
+  if (s === "response.output_item.added")
+    return y(e, d), { type: s, responseId: n, itemId: a, partId: r, sequence: o };
+  if (s === "response.output_text.delta")
+    return y(e, [...d, "delta"]), {
+      type: s,
+      responseId: n,
+      itemId: a,
+      partId: r,
+      sequence: o,
+      delta: S(e.delta, 1e5, !0)
+    };
+  if (s === "response.output_item.done")
+    return y(e, [...d, "text", "final"]), {
+      type: s,
+      responseId: n,
+      itemId: a,
+      partId: r,
+      sequence: o,
+      text: S(e.text, 1e5, !0),
+      final: q(e.final)
+    };
+  throw new Error("Invalid assistant data: event type");
+}, O = (t, e, s = t.messages) => {
+  const n = { ...t.responses, [e.responseId]: e };
+  let a = s;
+  if (s.length > f.historyMessages || s.reduce((i, c) => i + c.content.length, 0) > f.historyCharacters) {
+    a = [];
+    let i = 0;
+    for (let c = s.length - 1; c >= 0 && a.length < f.historyMessages; c -= 1) {
+      const g = s[c];
+      if (i += j(
+        g.content,
+        f.historyCharacters - i
+      ), i > f.historyCharacters) break;
+      a.unshift(g);
+    }
+  }
+  const r = new Set(a.map((i) => i.responseId)), o = new Set(
+    Object.values(n).filter((i) => k(i.status)).slice(-20).map((i) => i.responseId)
+  ), d = Object.fromEntries(
+    Object.entries(n).filter(
+      ([i, c]) => !k(c.status) || r.has(i) || o.has(i)
+    )
+  ), p = Object.values(d).filter(
+    (i) => !k(i.status)
+  );
+  return {
+    ...t,
+    threadId: e.chatId,
+    messages: a,
+    responses: d,
+    ...a.length < s.length ? { historyTruncated: !0 } : {},
+    activeRunId: p.at(-1)?.responseId,
+    status: p.length ? "streaming" : "idle"
+  };
+}, Tt = (t, e) => ({
+  id: e.itemId,
+  role: "assistant",
+  content: e.text,
+  artifacts: [],
+  responseId: t.responseId,
+  partId: e.partId,
+  parts: e.parts,
+  persistent: !1,
+  intermediate: !!t.completedItems[e.itemId] && !e.final,
+  status: t.completedItems[e.itemId] || k(t.status) ? "complete" : "streaming"
+}), J = (t, e) => {
+  const s = t.findIndex(
+    (o) => o.responseId === e.responseId && !o.persistent
+  ), n = t.filter(
+    (o) => o.responseId !== e.responseId || o.persistent
+  );
+  if (e.reconciled) return n;
+  const a = e.items.map(
+    (o) => Tt(e, o)
+  ), r = s < 0 ? n.length : Math.min(s, n.length);
+  return [...n.slice(0, r), ...a, ...n.slice(r)];
+}, jt = (t, e) => {
+  const s = e.type === "response.snapshot" ? e.snapshot.responseId : e.responseId, n = t.responses && Object.hasOwn(t.responses, s) ? t.responses[s] : void 0, a = e.type === "response.snapshot" ? e.snapshot.chatId : "chatId" in e ? e.chatId : n?.chatId;
+  if (!a || t.threadId && t.threadId !== a)
+    throw new Error("Invalid assistant response: conversation mismatch");
+  const r = n ?? {
+    chatId: a,
+    responseId: s,
+    status: "queued",
+    items: [],
+    lastSequence: 0,
+    completedItems: {}
+  };
+  if (e.type === "response.accepted")
+    return O(
+      t,
+      r,
+      t.messages.map(
+        (c) => c.id === e.messageId ? { ...c, responseId: s, cursor: e.acceptedCursor, persistent: !0 } : c
+      )
+    );
+  if (e.type === "response.reconciled") {
+    const c = t.messages.filter(
+      (w) => w.responseId !== s || w.persistent
+    ), g = new Map(c.map((w) => [w.id, w]));
+    for (const w of e.messages)
+      g.set(w.id, { ...w, artifacts: [], status: "complete" });
+    return O(t, { ...r, reconciled: !0 }, [
+      ...g.values()
+    ]);
+  }
+  if (e.type === "response.snapshot") {
+    if (k(r.status) && r.status !== e.snapshot.status)
+      return t;
+    const c = {
+      ...r,
+      ...e.snapshot,
+      completedItems: Object.fromEntries(
+        e.snapshot.items.map((g) => [g.itemId, !0])
+      )
+    };
+    return O(t, c, J(t.messages, c));
+  }
+  if (e.type === "response.state")
+    return k(r.status) ? t : O(t, { ...r, status: e.status });
+  if (e.type === "response.terminal") {
+    if (k(r.status) && r.status !== e.status)
+      return t;
+    const c = { ...r, status: e.status }, g = t.messages.map(
+      (w) => w.responseId !== s ? w : {
+        ...w,
+        status: "complete",
+        ...e.status === "failed" ? {
+          error: {
+            code: e.code ?? "AI_RUN_FAILED",
+            message: "本次处理失败，请重试",
+            retryable: !0
+          }
+        } : {}
+      }
+    );
+    return O(t, c, g);
+  }
+  if (k(r.status) || e.sequence <= r.lastSequence)
+    return t;
+  const o = r.items.findIndex((c) => c.itemId === e.itemId);
+  let d;
+  if (e.type === "response.output_item.added") {
+    if (o >= 0 || r.items.length >= 20)
+      throw new Error(
+        "Invalid assistant response: duplicate item or item budget"
+      );
+    d = {
+      itemId: e.itemId,
+      partId: e.partId,
+      text: "",
+      final: !1,
+      revision: 1
+    };
+  } else {
+    const c = r.items[o];
+    if (!c || c.partId !== e.partId || r.completedItems[e.itemId])
+      throw new Error("Invalid assistant response: item order");
+    d = e.type === "response.output_text.delta" ? { ...c, text: c.text + e.delta } : { ...c, text: e.text, final: e.final };
+  }
+  const p = o < 0 ? [...r.items, d] : r.items.map((c, g) => g === o ? d : c);
+  if (p.reduce((c, g) => c + [...g.text].length, 0) > 1e5)
+    throw new Error("Invalid assistant response: text budget");
+  const i = {
+    ...r,
+    status: "running",
+    lastSequence: e.sequence,
+    items: p,
+    completedItems: e.type === "response.output_item.done" ? { ...r.completedItems, [e.itemId]: !0 } : r.completedItems
+  };
+  return O(t, i, J(t.messages, i));
+}, D = (t) => typeof t == "object" && t !== null && !Array.isArray(t), E = (t, e) => {
+  if (Object.keys(t).some((s) => !e.has(s)))
+    throw new Error("Invalid assistant event: unsupported field");
+}, l = (t, e, s = f.identifierCharacters) => {
+  const n = typeof t == "string" ? j(t, s) : 0;
+  if (typeof t != "string" || !t.trim() || n > s)
+    throw new Error(`Invalid assistant event: ${e}`);
+  return t;
+}, vt = (t) => {
+  if (!D(t) || typeof t.type != "string")
+    throw new Error("Invalid assistant event: data");
+  if (t.type.startsWith("response.")) return Ot(t);
+  switch (t.type) {
+    case "message.start":
+      return E(t, /* @__PURE__ */ new Set(["type", "runId", "messageId"])), {
+        type: t.type,
+        runId: l(t.runId, "runId"),
+        messageId: l(t.messageId, "messageId")
+      };
+    case "message.delta":
+      if (E(t, /* @__PURE__ */ new Set(["type", "messageId", "delta"])), typeof t.delta != "string")
+        throw new Error("Invalid assistant event: delta");
+      return {
+        type: t.type,
+        messageId: l(t.messageId, "messageId"),
+        delta: t.delta
+      };
+    case "message.replace":
+      return E(t, /* @__PURE__ */ new Set(["type", "messageId", "content"])), {
+        type: t.type,
+        messageId: l(t.messageId, "messageId"),
+        content: l(
+          t.content,
+          "content",
+          f.messageCharacters
+        )
+      };
+    case "message.complete":
+      return E(t, /* @__PURE__ */ new Set(["type", "messageId"])), {
+        type: t.type,
+        messageId: l(t.messageId, "messageId")
+      };
+    case "artifact":
+      return E(t, /* @__PURE__ */ new Set(["type", "messageId", "artifact"])), {
+        type: t.type,
+        messageId: l(t.messageId, "messageId"),
+        artifact: H(t.artifact)
+      };
+    case "run.progress":
+      return E(t, /* @__PURE__ */ new Set(["type", "runId", "message"])), {
+        type: t.type,
+        runId: l(t.runId, "runId"),
+        message: l(
+          t.message,
+          "message",
+          f.messageCharacters
+        )
+      };
+    case "error":
+      if (E(t, /* @__PURE__ */ new Set([
+        "type",
+        "code",
+        "message",
+        "retryable",
+        "requestId"
+      ])), typeof t.retryable != "boolean")
+        throw new Error("Invalid assistant event: retryable");
+      return {
+        type: t.type,
+        code: l(t.code, "code"),
+        message: l(
+          t.message,
+          "message",
+          f.messageCharacters
+        ),
+        retryable: t.retryable,
+        requestId: t.requestId === void 0 ? void 0 : l(t.requestId, "requestId")
+      };
+    case "run.cancelled":
+      return E(t, /* @__PURE__ */ new Set(["type", "runId"])), {
+        type: t.type,
+        runId: t.runId === void 0 ? void 0 : l(t.runId, "runId")
+      };
+    case "run.complete":
+      return E(t, /* @__PURE__ */ new Set(["type", "runId", "threadId"])), {
+        type: t.type,
+        runId: l(t.runId, "runId"),
+        threadId: l(t.threadId, "threadId")
+      };
+    default:
+      throw new Error("Invalid assistant event: unsupported type");
+  }
+}, qt = (t) => {
+  try {
+    return vt(t);
+  } catch (e) {
+    throw e instanceof Error && (e.message.startsWith("Invalid assistant event:") || e.message.startsWith("Invalid Make AI Artifact:")) ? e : new Error("Invalid assistant event: data");
+  }
+}, Mt = (t) => {
+  if (!D(t))
+    throw new Error("Invalid assistant conversation snapshot: data");
+  if (E(t, /* @__PURE__ */ new Set(["threadId", "messages", "nextCursor", "hasMore"])), !Array.isArray(t.messages) || t.messages.length > f.historyMessages)
+    throw new Error("Invalid assistant conversation snapshot: messages");
+  const e = /* @__PURE__ */ new Set();
+  let s = 0, n = 0;
+  return {
+    messages: t.messages.map((r) => {
+      if (!D(r))
+        throw new Error("Invalid assistant conversation snapshot: message");
+      E(r, /* @__PURE__ */ new Set(["id", "role", "content", "artifacts", "responseId", "parts", "persistent", "cursor", "createdAt", "feedback"]));
+      const o = l(r.id, "messageId");
+      if (e.has(o))
+        throw new Error("Invalid assistant conversation snapshot: duplicate message id");
+      if (e.add(o), r.role !== "assistant" && r.role !== "user")
+        throw new Error("Invalid assistant conversation snapshot: role");
+      const d = r.role, p = typeof r.content == "string" ? j(
+        r.content,
+        f.messageCharacters
+      ) : 0;
+      if (typeof r.content != "string" || p > f.messageCharacters)
+        throw new Error("Invalid assistant conversation snapshot: content");
+      if (s += j(
+        r.content,
+        f.historyCharacters - s
+      ), s > f.historyCharacters)
+        throw new Error("Invalid assistant conversation snapshot: content budget");
+      if (r.artifacts !== void 0 && (!Array.isArray(r.artifacts) || r.artifacts.length > f.artifactsPerRun))
+        throw new Error("Invalid assistant conversation snapshot: artifacts");
+      const i = (r.artifacts ?? []).map(H), c = /* @__PURE__ */ new Set();
+      for (const g of i) {
+        if (c.has(g.id))
+          throw new Error(
+            "Invalid assistant conversation snapshot: duplicate artifact id"
+          );
+        c.add(g.id);
+      }
+      if (n += i.length, n > f.historyArtifacts)
+        throw new Error("Invalid assistant conversation snapshot: artifact budget");
+      return {
+        id: o,
+        role: d,
+        content: r.content,
+        artifacts: i,
+        status: "complete",
+        ...r.responseId === void 0 ? {} : { responseId: l(r.responseId, "responseId") },
+        ...r.parts === void 0 ? {} : { parts: L(r.parts) },
+        ...r.feedback === void 0 ? {} : { feedback: X(r.feedback) },
+        ...r.persistent === void 0 ? {} : { persistent: q(r.persistent) },
+        ...r.cursor === void 0 ? {} : { cursor: N(r.cursor) },
+        ...r.createdAt === void 0 ? {} : { createdAt: l(r.createdAt, "createdAt") }
+      };
+    }),
+    status: "idle",
+    threadId: t.threadId === void 0 ? void 0 : l(t.threadId, "threadId")
+  };
+}, Yt = (t) => t === void 0 ? { messages: [], status: "idle" } : Mt(t), Vt = (t, e) => ({
+  ...t,
+  error: void 0,
+  progress: void 0,
+  status: "streaming",
+  messages: [
+    ...t.messages,
+    {
+      id: e.id,
+      role: "user",
+      content: e.content,
+      ...e.parts === void 0 ? {} : { parts: e.parts },
+      artifacts: [],
+      status: "complete"
+    }
+  ]
+}), K = (t, e, s) => ({
+  ...t,
+  messages: t.messages.map(
+    (n) => n.id === e ? s(n) : n
+  )
+}), Q = (t) => {
+  const e = t.slice(-f.progressStepsPerRun), s = [];
+  let n = 0;
+  for (let a = e.length - 1; a >= 0; a -= 1) {
+    const r = e[a], o = j(
+      r,
+      f.progressCharactersPerRun - n
+    );
+    if (n + o > f.progressCharactersPerRun) break;
+    n += o, s.unshift(r);
+  }
+  return s;
+}, Kt = (t, e) => {
+  let s = -1;
+  for (let n = t.length - 1; n >= 0; n -= 1) {
+    const a = t[n];
+    if (a.role === "assistant" && a.status === "streaming") {
+      s = n;
+      break;
+    }
+  }
+  return s < 0 ? t : t.map(
+    (n, a) => a === s ? {
+      ...n,
+      progressSteps: Q([...n.progressSteps ?? [], e])
+    } : n
+  );
+}, Dt = (t, e) => {
+  if (e.type.startsWith("response.")) return jt(t, e);
+  switch (e.type) {
+    case "message.start": {
+      const s = t.progress?.runId === e.runId ? t.progress.steps : void 0;
+      return {
+        ...t,
+        activeRunId: e.runId,
+        error: void 0,
+        progress: t.progress?.runId === e.runId ? t.progress : void 0,
+        status: "streaming",
+        messages: [
+          ...t.messages,
+          {
+            id: e.messageId,
+            role: "assistant",
+            content: "",
+            artifacts: [],
+            progressSteps: s,
+            status: "streaming"
+          }
+        ]
+      };
+    }
+    case "message.delta":
+      return K(t, e.messageId, (s) => ({
+        ...s,
+        content: `${s.content}${e.delta}`
+      }));
+    case "message.replace":
+      return K(t, e.messageId, (s) => ({
+        ...s,
+        content: e.content
+      }));
+    case "artifact":
+      return K(t, e.messageId, (s) => ({
+        ...s,
+        artifacts: [...s.artifacts, e.artifact]
+      }));
+    case "message.complete":
+      return K(t, e.messageId, (s) => ({
+        ...s,
+        status: "complete"
+      }));
+    case "run.progress": {
+      const s = Q(
+        t.progress?.runId === e.runId ? [...t.progress.steps, e.message] : [e.message]
+      );
+      return {
+        ...t,
+        messages: Kt(
+          t.messages,
+          e.message
+        ),
+        progress: {
+          runId: e.runId,
+          message: e.message,
+          steps: s
+        }
+      };
+    }
+    case "error": {
+      const s = {
+        code: e.code,
+        message: e.message,
+        retryable: e.retryable,
+        requestId: e.requestId
+      };
+      return {
+        ...t,
+        activeRunId: void 0,
+        error: s,
+        progress: void 0,
+        messages: t.messages.map(
+          (n) => n.status === "streaming" ? { ...n, error: s, status: "complete" } : n
+        ),
+        status: "error"
+      };
+    }
+    case "run.cancelled":
+      return {
+        ...t,
+        activeRunId: void 0,
+        progress: void 0,
+        status: "idle",
+        messages: t.messages.map(
+          (s) => s.status === "streaming" ? { ...s, status: "complete" } : s
+        )
+      };
+    case "run.complete":
+      return {
+        ...t,
+        activeRunId: void 0,
+        error: void 0,
+        progress: void 0,
+        messages: t.messages.map(
+          (s) => s.status === "streaming" ? { ...s, status: "complete" } : s
+        ),
+        status: "idle",
+        threadId: e.threadId
+      };
+  }
+  return t;
+};
+export {
+  f as M,
+  L as a,
+  S as b,
+  j as c,
+  x as d,
+  N as e,
+  F as f,
+  xt as g,
+  y as h,
+  q as i,
+  X as j,
+  k,
+  qt as l,
+  Nt as m,
+  Yt as n,
+  Vt as o,
+  h as p,
+  Z as q,
+  Dt as r,
+  m as s,
+  Pt as t,
+  H as u,
+  $t as v
+};