@qfei-design/make-ai-assistant 0.2.13 → 0.2.15

package/dist/conversation-DuqMadaQ.js

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