@qfei-design/make-ai-assistant 0.1.0 → 0.1.2

package/dist/conversation-Dy2Sghjv.js

@@ -0,0 +1,684 @@
+const k = (t, e) => {
+  let r = 0;
+  for (const a of t)
+    if (r += 1, r > e) break;
+  return r;
+}, gt = "1.0", o = {
+  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
+}, g = {
+  artifactsPerRun: 50,
+  assistantMessagesPerRun: 20,
+  historyArtifacts: 500,
+  historyCharacters: 1e6,
+  historyMessages: 200,
+  identifierCharacters: 1e3,
+  messageCharacters: 1e5
+}, P = [
+  "metric",
+  "comparison",
+  "trend",
+  "ranking",
+  "record-list",
+  "notice"
+], $ = () => ({
+  success: !1,
+  issues: [{ path: "", message: "could not be safely inspected" }]
+}), V = /* @__PURE__ */ new Set(["navigate", "open-record", "open-list", "invoke"]), D = /* @__PURE__ */ new Set(["decimal", "currency", "percent"]);
+class v extends Array {
+  push(...e) {
+    const r = o.validationIssues - this.length;
+    return r > 0 ? super.push(...e.slice(0, r)) : this.length;
+  }
+}
+const c = (t) => (() => {
+  if (typeof t != "object" || t === null || Array.isArray(t))
+    return !1;
+  const e = Object.getPrototypeOf(t);
+  return e === Object.prototype || e === null;
+})(), M = (t) => typeof t == "string" && t.trim().length > 0, R = (t, e) => {
+  let r = 0;
+  for (const a of t)
+    if (r += 1, r > e) return r;
+  return r;
+}, u = (t) => typeof t == "string" && R(t, o.textCharacters) <= o.textCharacters, b = (t) => typeof t == "number" && Number.isFinite(t), q = (t) => t.length <= 120 ? t : `${t.slice(0, 117)}...`, m = (t, e, r) => {
+  M(t) ? u(t) || r.push({
+    path: e,
+    message: `must contain at most ${o.textCharacters} characters`
+  }) : r.push({ path: e, message: "must be a non-empty string" });
+}, I = (t, e, r) => {
+  t !== void 0 && typeof t != "string" ? r.push({ path: e, message: "must be a string" }) : typeof t == "string" && !u(t) && r.push({
+    path: e,
+    message: `must contain at most ${o.textCharacters} characters`
+  });
+}, d = (t, e, r, a) => {
+  for (const s in t)
+    if (Object.prototype.hasOwnProperty.call(t, s)) {
+      if (a.length >= o.validationIssues) break;
+      e.has(s) || a.push({
+        path: q(r ? `${r}.${s}` : s),
+        message: "is not supported"
+      });
+    }
+}, w = (t, e, r, a) => t.length > e ? (a.push({ path: r, message: `must contain at most ${e} items` }), !0) : !1, S = (t, e, r) => {
+  for (let a = 0; a < t.length; a += 1)
+    if (!Object.prototype.hasOwnProperty.call(t, a))
+      return r.push({ path: e, message: "must not contain empty array slots" }), !0;
+  return !1;
+}, E = (t, e, r, a) => {
+  const s = /* @__PURE__ */ new Set();
+  t.forEach((n, f) => {
+    if (!c(n) || typeof n[e] != "string") return;
+    const i = n[e];
+    s.has(i) ? a.push({
+      path: `${r}[${f}].${e}`,
+      message: "must be unique within the collection"
+    }) : s.add(i);
+  });
+}, L = /* @__PURE__ */ new Set([
+  "schemaVersion",
+  "id",
+  "kind",
+  "title",
+  "summary",
+  "presentation",
+  "actions",
+  "meta",
+  "data"
+]), F = /* @__PURE__ */ new Set(["template", "density"]), z = /* @__PURE__ */ new Set(["style", "currency", "precision", "unit"]), J = /* @__PURE__ */ new Set(["id", "label", "intent", "target", "appearance"]), U = /* @__PURE__ */ new Set(["value", "format", "delta", "context"]), B = /* @__PURE__ */ new Set(["value", "format", "direction", "label"]), K = /* @__PURE__ */ new Set(["items"]), W = /* @__PURE__ */ new Set(["id", "label", "value", "format", "hint"]), H = /* @__PURE__ */ new Set(["series"]), G = /* @__PURE__ */ new Set(["id", "label", "points", "format"]), Q = /* @__PURE__ */ new Set(["x", "y"]), X = /* @__PURE__ */ new Set([
+  "id",
+  "label",
+  "value",
+  "format",
+  "description"
+]), Z = /* @__PURE__ */ new Set(["entity", "columns", "records", "total"]), tt = /* @__PURE__ */ new Set(["key", "label"]), et = /* @__PURE__ */ new Set(["key", "label", "format"]), rt = /* @__PURE__ */ new Set(["id", "title", "values", "action"]), nt = /* @__PURE__ */ new Set(["tone", "body"]), A = (t, e, r) => c(t) ? (d(t, z, e, r), t.style !== void 0 && (typeof t.style != "string" || !D.has(t.style)) && r.push({ path: `${e}.style`, message: "is not supported" }), t.currency !== void 0 && m(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" }), I(t.unit, `${e}.unit`, r), !0) : (r.push({ path: e, message: "must be an object" }), !1), _ = (t) => {
+  const e = [{ kind: "visit", depth: 0, value: t }], r = /* @__PURE__ */ new WeakSet();
+  let a = 0, s = 0;
+  try {
+    for (; e.length > 0; ) {
+      const n = e.pop();
+      if (!n) break;
+      if (n.kind === "leave") {
+        r.delete(n.value);
+        continue;
+      }
+      if (s += 1, s > o.jsonNodes || n.depth > o.jsonDepth)
+        return !1;
+      if (n.value === null || typeof n.value == "boolean")
+        continue;
+      if (typeof n.value == "string") {
+        if (a += R(
+          n.value,
+          o.textCharacters
+        ), !u(n.value) || a > o.jsonCharacters) return !1;
+        continue;
+      }
+      if (typeof n.value == "number") {
+        if (!Number.isFinite(n.value)) return !1;
+        continue;
+      }
+      if (!Array.isArray(n.value) && !c(n.value) || r.has(n.value)) return !1;
+      r.add(n.value), e.push({ kind: "leave", value: n.value });
+      const f = o.jsonNodes - s;
+      if (Array.isArray(n.value)) {
+        if (n.value.length > f) return !1;
+        for (let i = n.value.length - 1; i >= 0; i -= 1)
+          e.push({
+            kind: "visit",
+            depth: n.depth + 1,
+            value: n.value[i]
+          });
+      } else {
+        const i = [];
+        for (const h in n.value)
+          if (Object.prototype.hasOwnProperty.call(n.value, h)) {
+            if (!u(h) || (a += R(
+              h,
+              o.textCharacters
+            ), a > o.jsonCharacters) || i.length >= f) return !1;
+            i.push(h);
+          }
+        for (let h = i.length - 1; h >= 0; h -= 1) {
+          const y = i[h];
+          e.push({
+            kind: "visit",
+            depth: n.depth + 1,
+            value: n.value[y]
+          });
+        }
+      }
+    }
+    return !0;
+  } catch {
+    return !1;
+  }
+}, at = (t) => t === null || typeof t == "boolean" || u(t) || b(t), x = (t, e, r) => c(t) ? (d(t, J, e, r), m(t.id, `${e}.id`, r), m(t.label, `${e}.label`, r), (typeof t.intent != "string" || !V.has(t.intent)) && r.push({ path: `${e}.intent`, message: "is not supported" }), (!c(t.target) || !_(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), st = (t, e) => {
+  if (d(t, L, "", e), t.schemaVersion !== "1.0" && e.push({ path: "schemaVersion", message: "must equal 1.0" }), m(t.id, "id", e), P.includes(t.kind) || e.push({ path: "kind", message: "is not a supported Artifact kind" }), I(t.title, "title", e), I(t.summary, "summary", e), t.presentation !== void 0 && (c(t.presentation) ? (d(t.presentation, F, "presentation", e), t.presentation.template !== void 0 && !M(t.presentation.template) ? e.push({ path: "presentation.template", message: "must be a non-empty string" }) : t.presentation.template !== void 0 && !u(t.presentation.template) && e.push({
+    path: "presentation.template",
+    message: `must contain at most ${o.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 (!w(
+      t.actions,
+      o.actions,
+      "actions",
+      e
+    )) {
+      if (S(t.actions, "actions", e)) return;
+      E(t.actions, "id", "actions", e), t.actions.forEach(
+        (a, s) => x(a, `actions[${s}]`, e)
+      );
+    }
+  }
+  t.meta !== void 0 && (!c(t.meta) || !_(t.meta)) && e.push({ path: "meta", message: "must be a JSON object" });
+}, ot = (t, e) => {
+  d(t, U, "data", e), !b(t.value) && !u(t.value) && e.push({ path: "data.value", message: "must be a finite number or string" }), t.format !== void 0 && A(t.format, "data.format", e), t.delta !== void 0 && (c(t.delta) ? (d(
+    t.delta,
+    B,
+    "data.delta",
+    e
+  ), b(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" }), I(t.delta.label, "data.delta.label", e)) : e.push({ path: "data.delta", message: "must be an object" })), I(t.context, "data.context", e);
+}, it = (t, e) => {
+  if (d(t, K, "data", e), !Array.isArray(t.items) || t.items.length === 0) {
+    e.push({ path: "data.items", message: "must be a non-empty array" });
+    return;
+  }
+  w(
+    t.items,
+    o.comparisonItems,
+    "data.items",
+    e
+  ) || S(t.items, "data.items", e) || (E(t.items, "id", "data.items", e), t.items.forEach((r, a) => {
+    const s = `data.items[${a}]`;
+    if (!c(r)) {
+      e.push({ path: s, message: "must be an object" });
+      return;
+    }
+    d(
+      r,
+      W,
+      s,
+      e
+    ), m(r.id, `${s}.id`, e), m(r.label, `${s}.label`, e), !b(r.value) && !u(r.value) && e.push({ path: `${s}.value`, message: "must be a finite number or string" }), r.format !== void 0 && A(r.format, `${s}.format`, e), I(r.hint, `${s}.hint`, e);
+  }));
+}, ct = (t, e) => {
+  if (d(t, H, "data", e), !Array.isArray(t.series) || t.series.length === 0) {
+    e.push({ path: "data.series", message: "must be a non-empty array" });
+    return;
+  }
+  w(
+    t.series,
+    o.trendSeries,
+    "data.series",
+    e
+  ) || S(t.series, "data.series", e) || (E(t.series, "id", "data.series", e), t.series.forEach((r, a) => {
+    const s = `data.series[${a}]`;
+    if (!c(r)) {
+      e.push({ path: s, message: "must be an object" });
+      return;
+    }
+    if (d(
+      r,
+      G,
+      s,
+      e
+    ), m(r.id, `${s}.id`, e), m(r.label, `${s}.label`, e), r.format !== void 0 && A(r.format, `${s}.format`, e), !Array.isArray(r.points) || r.points.length === 0) {
+      e.push({ path: `${s}.points`, message: "must be a non-empty array" });
+      return;
+    }
+    w(
+      r.points,
+      o.trendPointsPerSeries,
+      `${s}.points`,
+      e
+    ) || S(r.points, `${s}.points`, e) || r.points.forEach((n, f) => {
+      const i = `${s}.points[${f}]`;
+      if (!c(n)) {
+        e.push({ path: i, message: "must be an object" });
+        return;
+      }
+      d(n, Q, i, e), !b(n.x) && !u(n.x) && e.push({ path: `${i}.x`, message: "must be a finite number or string" }), b(n.y) || e.push({ path: `${i}.y`, message: "must be a finite number" });
+    });
+  }));
+}, dt = (t, e) => {
+  if (d(t, K, "data", e), !Array.isArray(t.items) || t.items.length === 0) {
+    e.push({ path: "data.items", message: "must be a non-empty array" });
+    return;
+  }
+  w(
+    t.items,
+    o.rankingItems,
+    "data.items",
+    e
+  ) || S(t.items, "data.items", e) || (E(t.items, "id", "data.items", e), t.items.forEach((r, a) => {
+    const s = `data.items[${a}]`;
+    if (!c(r)) {
+      e.push({ path: s, message: "must be an object" });
+      return;
+    }
+    d(
+      r,
+      X,
+      s,
+      e
+    ), m(r.id, `${s}.id`, e), m(r.label, `${s}.label`, e), b(r.value) || e.push({ path: `${s}.value`, message: "must be a finite number" }), r.format !== void 0 && A(r.format, `${s}.format`, e), I(r.description, `${s}.description`, e);
+  }));
+}, pt = (t, e) => {
+  if (d(
+    t,
+    Z,
+    "data",
+    e
+  ), c(t.entity) ? (d(t.entity, tt, "data.entity", e), m(t.entity.key, "data.entity.key", e), I(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 (!w(
+    t.columns,
+    o.recordColumns,
+    "data.columns",
+    e
+  )) {
+    if (S(t.columns, "data.columns", e)) return;
+    E(t.columns, "key", "data.columns", e), t.columns.forEach((a, s) => {
+      const n = `data.columns[${s}]`;
+      if (!c(a)) {
+        e.push({ path: n, message: "must be an object" });
+        return;
+      }
+      d(
+        a,
+        et,
+        n,
+        e
+      ), m(a.key, `${n}.key`, e), m(a.label, `${n}.label`, e), a.format !== void 0 && A(a.format, `${n}.format`, e);
+    });
+  }
+  if (!Array.isArray(t.records))
+    e.push({ path: "data.records", message: "must be an array" });
+  else if (!w(
+    t.records,
+    o.recordListRecords,
+    "data.records",
+    e
+  )) {
+    if (S(t.records, "data.records", e)) return;
+    E(t.records, "id", "data.records", e), t.records.forEach((a, s) => {
+      const n = `data.records[${s}]`;
+      if (!c(a)) {
+        e.push({ path: n, message: "must be an object" });
+        return;
+      }
+      if (d(
+        a,
+        rt,
+        n,
+        e
+      ), m(a.id, `${n}.id`, e), I(a.title, `${n}.title`, e), !c(a.values))
+        e.push({
+          path: `${n}.values`,
+          message: "must contain only JSON primitive display values"
+        });
+      else {
+        const f = a.values;
+        let i = !1, h = 0;
+        for (const y in f)
+          if (Object.prototype.hasOwnProperty.call(f, y)) {
+            if (h += 1, h > o.recordValues) break;
+            i ||= !u(y) || !at(f[y]);
+          }
+        h > o.recordValues ? e.push({
+          path: `${n}.values`,
+          message: `must contain at most ${o.recordValues} values`
+        }) : i && e.push({
+          path: `${n}.values`,
+          message: "must contain only JSON primitive display values"
+        });
+      }
+      a.action !== void 0 && x(a.action, `${n}.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" });
+}, mt = (t, e) => {
+  d(t, nt, "data", e), (typeof t.tone != "string" || !["info", "success", "warning", "danger"].includes(t.tone)) && e.push({ path: "data.tone", message: "is not supported" }), m(t.body, "data.body", e);
+}, j = (t, e) => {
+  if (st(t, e), !c(t.data)) {
+    e.push({ path: "data", message: "must be an object" });
+    return;
+  }
+  switch (t.kind) {
+    case "metric":
+      ot(t.data, e);
+      break;
+    case "comparison":
+      it(t.data, e);
+      break;
+    case "trend":
+      ct(t.data, e);
+      break;
+    case "ranking":
+      dt(t.data, e);
+      break;
+    case "record-list":
+      pt(t.data, e);
+      break;
+    case "notice":
+      mt(t.data, e);
+      break;
+  }
+}, ft = (t) => {
+  const e = new v();
+  try {
+    if (!c(t))
+      return { success: !1, issues: [{ path: "", message: "must be an object" }] };
+    j(t, e);
+  } catch {
+    return $();
+  }
+  if (e.length > 0) return { success: !1, issues: e };
+  if (!_(t))
+    return {
+      success: !1,
+      issues: [{ path: "", message: "exceeds the Artifact resource budget" }]
+    };
+  let r;
+  try {
+    r = structuredClone(t);
+  } catch {
+    return $();
+  }
+  const a = new v();
+  try {
+    if (!c(r)) return $();
+    j(r, a);
+  } catch {
+    return $();
+  }
+  return a.length === 0 && !_(r) && a.push({
+    path: "",
+    message: "exceeds the Artifact resource budget"
+  }), a.length === 0 ? { success: !0, artifact: r } : { success: !1, issues: a };
+}, Y = (t) => {
+  const e = ft(t);
+  if (e.success) return e.artifact;
+  const r = e.issues.map((a) => `${a.path || "artifact"} ${a.message}`).join(", ");
+  throw new Error(`Invalid Make AI Artifact: ${r}`);
+}, N = (t) => typeof t == "object" && t !== null && !Array.isArray(t), l = (t, e) => {
+  if (Object.keys(t).some((r) => !e.has(r)))
+    throw new Error("Invalid assistant event: unsupported field");
+}, p = (t, e, r = g.identifierCharacters) => {
+  const a = typeof t == "string" ? k(t, r) : 0;
+  if (typeof t != "string" || !t.trim() || a > r)
+    throw new Error(`Invalid assistant event: ${e}`);
+  return t;
+}, ht = (t) => {
+  if (!N(t) || typeof t.type != "string")
+    throw new Error("Invalid assistant event: data");
+  switch (t.type) {
+    case "message.start":
+      return l(t, /* @__PURE__ */ new Set(["type", "runId", "messageId"])), {
+        type: t.type,
+        runId: p(t.runId, "runId"),
+        messageId: p(t.messageId, "messageId")
+      };
+    case "message.delta":
+      if (l(t, /* @__PURE__ */ new Set(["type", "messageId", "delta"])), typeof t.delta != "string")
+        throw new Error("Invalid assistant event: delta");
+      return {
+        type: t.type,
+        messageId: p(t.messageId, "messageId"),
+        delta: t.delta
+      };
+    case "message.replace":
+      return l(t, /* @__PURE__ */ new Set(["type", "messageId", "content"])), {
+        type: t.type,
+        messageId: p(t.messageId, "messageId"),
+        content: p(
+          t.content,
+          "content",
+          g.messageCharacters
+        )
+      };
+    case "message.complete":
+      return l(t, /* @__PURE__ */ new Set(["type", "messageId"])), {
+        type: t.type,
+        messageId: p(t.messageId, "messageId")
+      };
+    case "artifact":
+      return l(t, /* @__PURE__ */ new Set(["type", "messageId", "artifact"])), {
+        type: t.type,
+        messageId: p(t.messageId, "messageId"),
+        artifact: Y(t.artifact)
+      };
+    case "run.progress":
+      return l(t, /* @__PURE__ */ new Set(["type", "runId", "message"])), {
+        type: t.type,
+        runId: p(t.runId, "runId"),
+        message: p(
+          t.message,
+          "message",
+          g.messageCharacters
+        )
+      };
+    case "error":
+      if (l(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: p(t.code, "code"),
+        message: p(
+          t.message,
+          "message",
+          g.messageCharacters
+        ),
+        retryable: t.retryable,
+        requestId: t.requestId === void 0 ? void 0 : p(t.requestId, "requestId")
+      };
+    case "run.cancelled":
+      return l(t, /* @__PURE__ */ new Set(["type", "runId"])), {
+        type: t.type,
+        runId: t.runId === void 0 ? void 0 : p(t.runId, "runId")
+      };
+    case "run.complete":
+      return l(t, /* @__PURE__ */ new Set(["type", "runId", "threadId"])), {
+        type: t.type,
+        runId: p(t.runId, "runId"),
+        threadId: p(t.threadId, "threadId")
+      };
+    default:
+      throw new Error("Invalid assistant event: unsupported type");
+  }
+}, ut = (t) => {
+  try {
+    return ht(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");
+  }
+}, lt = (t) => {
+  if (!N(t))
+    throw new Error("Invalid assistant conversation snapshot: data");
+  if (l(t, /* @__PURE__ */ new Set(["threadId", "messages"])), !Array.isArray(t.messages) || t.messages.length > g.historyMessages)
+    throw new Error("Invalid assistant conversation snapshot: messages");
+  const e = /* @__PURE__ */ new Set();
+  let r = 0, a = 0;
+  return {
+    messages: t.messages.map((n) => {
+      if (!N(n))
+        throw new Error("Invalid assistant conversation snapshot: message");
+      l(n, /* @__PURE__ */ new Set(["id", "role", "content", "artifacts"]));
+      const f = p(n.id, "messageId");
+      if (e.has(f))
+        throw new Error("Invalid assistant conversation snapshot: duplicate message id");
+      if (e.add(f), n.role !== "assistant" && n.role !== "user")
+        throw new Error("Invalid assistant conversation snapshot: role");
+      const i = n.role, h = typeof n.content == "string" ? k(
+        n.content,
+        g.messageCharacters
+      ) : 0;
+      if (typeof n.content != "string" || h > g.messageCharacters)
+        throw new Error("Invalid assistant conversation snapshot: content");
+      if (r += k(
+        n.content,
+        g.historyCharacters - r
+      ), r > g.historyCharacters)
+        throw new Error("Invalid assistant conversation snapshot: content budget");
+      if (n.artifacts !== void 0 && (!Array.isArray(n.artifacts) || n.artifacts.length > g.artifactsPerRun))
+        throw new Error("Invalid assistant conversation snapshot: artifacts");
+      const y = (n.artifacts ?? []).map(Y), T = /* @__PURE__ */ new Set();
+      for (const O of y) {
+        if (T.has(O.id))
+          throw new Error(
+            "Invalid assistant conversation snapshot: duplicate artifact id"
+          );
+        T.add(O.id);
+      }
+      if (a += y.length, a > g.historyArtifacts)
+        throw new Error("Invalid assistant conversation snapshot: artifact budget");
+      return {
+        id: f,
+        role: i,
+        content: n.content,
+        artifacts: y,
+        status: "complete"
+      };
+    }),
+    status: "idle",
+    threadId: t.threadId === void 0 ? void 0 : p(t.threadId, "threadId")
+  };
+}, yt = (t) => t === void 0 ? { messages: [], status: "idle" } : lt(t), It = (t, e) => ({
+  ...t,
+  error: void 0,
+  progress: void 0,
+  status: "streaming",
+  messages: [
+    ...t.messages,
+    {
+      id: e.id,
+      role: "user",
+      content: e.content,
+      artifacts: [],
+      status: "complete"
+    }
+  ]
+}), C = (t, e, r) => ({
+  ...t,
+  messages: t.messages.map(
+    (a) => a.id === e ? r(a) : a
+  )
+}), bt = (t, e) => {
+  switch (e.type) {
+    case "message.start":
+      return {
+        ...t,
+        activeRunId: e.runId,
+        error: void 0,
+        progress: void 0,
+        status: "streaming",
+        messages: [
+          ...t.messages,
+          {
+            id: e.messageId,
+            role: "assistant",
+            content: "",
+            artifacts: [],
+            status: "streaming"
+          }
+        ]
+      };
+    case "message.delta":
+      return C(t, e.messageId, (r) => ({
+        ...r,
+        content: `${r.content}${e.delta}`
+      }));
+    case "message.replace":
+      return C(t, e.messageId, (r) => ({
+        ...r,
+        content: e.content
+      }));
+    case "artifact":
+      return C(t, e.messageId, (r) => ({
+        ...r,
+        artifacts: [...r.artifacts, e.artifact]
+      }));
+    case "message.complete":
+      return C(t, e.messageId, (r) => ({
+        ...r,
+        status: "complete"
+      }));
+    case "run.progress":
+      return {
+        ...t,
+        progress: {
+          runId: e.runId,
+          message: e.message
+        }
+      };
+    case "error":
+      return {
+        ...t,
+        activeRunId: void 0,
+        error: {
+          code: e.code,
+          message: e.message,
+          retryable: e.retryable,
+          requestId: e.requestId
+        },
+        progress: void 0,
+        messages: t.messages.map(
+          (r) => r.status === "streaming" ? { ...r, status: "complete" } : r
+        ),
+        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
+      };
+  }
+};
+export {
+  g as M,
+  yt as a,
+  It as b,
+  k as c,
+  P as d,
+  o as e,
+  gt as f,
+  Y as g,
+  ut as p,
+  bt as r,
+  ft as v
+};