@qfei-design/make-ai-assistant 0.2.12 → 0.2.14

package/dist/client.mjs

@@ -0,0 +1,1154 @@
+import { b as _e, c as be, a as xe, p as ke, d as Se, e as Pe } from "./conversation-management-DZROhXyK.js";
+const A = _e, g = ke, f = be, p = xe, G = Se, K = Pe;
+function E(o, a) {
+  if (Object.keys(o).some((n) => !a.includes(n)))
+    throw new Error("Invalid request: unknown field");
+}
+function X(o) {
+  const a = f(o, 36);
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    a
+  ))
+    throw new Error("Invalid request: UUID");
+  return a;
+}
+function W(o, a = !1) {
+  return f(o, 8192, a);
+}
+const te = (o) => {
+  const a = f(o, 64);
+  if (!Number.isFinite(Date.parse(a)))
+    throw new Error("Invalid response: timestamp");
+  return a;
+};
+function me(o) {
+  const a = W(o.nextCursor, !0), n = G(o.hasMore);
+  if (n !== !!a)
+    throw new Error("Invalid response: page cursor");
+  return { nextCursor: a, hasMore: n };
+}
+function ne(o, a, n, l) {
+  const i = A(o);
+  if (i.appKey !== a || n && i.agentId !== n || l && i.chatId !== l || !["active", "deleted"].includes(String(i.status)))
+    throw new Error("Invalid response: chat scope");
+  return {
+    chatId: g(i.chatId),
+    appKey: a,
+    agentId: g(i.agentId),
+    title: f(i.title, 255, !0),
+    titlePending: i.titlePending === void 0 ? !1 : G(i.titlePending),
+    status: i.status,
+    revision: p(i.revision, 1),
+    pinned: G(i.pinned),
+    pinnedAt: i.pinnedAt == null ? null : te(i.pinnedAt),
+    createdAt: te(i.createdAt),
+    lastActivityAt: te(i.lastActivityAt)
+  };
+}
+function Me(o, a, n) {
+  const l = A(o), i = K(l.chats, 100).map((m) => ne(m, a, n));
+  if (new Set(i.map((m) => m.chatId)).size !== i.length)
+    throw new Error("Invalid response: duplicate chat");
+  return { chats: i, ...me(l) };
+}
+function Ce(o, a) {
+  const n = A(o);
+  return { agents: K(n.agents, 100).map((i) => {
+    const m = A(i);
+    if (m.appKey !== a) throw new Error("Invalid response: agent scope");
+    return { agentId: g(m.agentId), appKey: a, name: f(m.name, 255) };
+  }), ...me(n) };
+}
+function ge(o) {
+  const a = A(o), n = f(a.digestSha256, 64);
+  if (!/^[0-9a-f]{64}$/.test(n))
+    throw new Error("Invalid response: digest");
+  return {
+    contentRef: g(a.contentRef),
+    contentType: f(a.contentType, 256),
+    sizeBytes: p(a.sizeBytes),
+    digestSha256: n
+  };
+}
+function ve(o) {
+  return K(o, 32).map((a) => {
+    const n = A(a), l = f(n.kind, 128), i = n.id === void 0 ? {} : { id: g(n.id) };
+    return l === "text" ? { ...i, kind: l, text: f(n.text, 1e5, !0) } : ["image", "file", "audio", "video"].includes(l) ? {
+      ...i,
+      kind: l,
+      ...n.name === void 0 ? {} : { name: f(n.name, 512, !0) },
+      media: ge(n.media)
+    } : {
+      ...i,
+      kind: "unknown",
+      originalKind: l,
+      ...n.textFallback === void 0 ? {} : { textFallback: f(n.textFallback, 1e5, !0) }
+    };
+  });
+}
+function Ee(o) {
+  const a = A(o);
+  if (!["like", "dislike", "none"].includes(String(a.rating)))
+    throw new Error("Invalid response: feedback");
+  return {
+    id: g(a.id),
+    rating: a.rating,
+    revision: p(a.revision, 1),
+    ...a.reason === void 0 ? {} : { reason: f(a.reason, 128, !0) },
+    ...a.comment === void 0 ? {} : { comment: f(a.comment, 4e3, !0) }
+  };
+}
+function Le(o) {
+  const a = A(o);
+  let n = 0;
+  const l = K(a.messages, 200).map((i) => {
+    const m = A(i);
+    if (m.role !== "user" && m.role !== "assistant")
+      throw new Error("Invalid response: history role");
+    const P = f(m.text, 1e5, !0);
+    return n += [...P].length, {
+      messageId: g(m.messageId),
+      role: m.role,
+      cursor: W(m.cursor),
+      createdAt: te(m.createdAt),
+      text: P,
+      ...m.responseId === void 0 ? {} : { responseId: g(m.responseId) },
+      ...m.parts === void 0 ? {} : { parts: ve(m.parts) },
+      ...m.feedback === void 0 ? {} : { feedback: Ee(m.feedback) }
+    };
+  });
+  if (n > 1e6 || new Set(l.map((i) => i.messageId)).size !== l.length)
+    throw new Error("Invalid response: history budget or duplicate identity");
+  return { messages: l, ...me(a) };
+}
+function le(o, a, n) {
+  const l = A(o);
+  if (l.chatId !== a || l.responseId !== n)
+    throw new Error("Invalid response: response scope");
+  const i = f(l.status, 64), m = G(l.terminal);
+  if (["completed", "failed", "cancelled"].includes(i) && !m || ["queued", "dispatched", "running"].includes(i) && m)
+    throw new Error("Invalid response: contradictory terminal");
+  const P = K(l.items, 20).map((k) => {
+    const _ = A(k);
+    return {
+      itemId: g(_.itemId),
+      partId: g(_.partId),
+      text: f(_.text, 1e5, !0),
+      final: G(_.final),
+      revision: p(_.revision, 1),
+      ..._.parts === void 0 ? {} : { parts: ve(_.parts) }
+    };
+  });
+  if (P.reduce((k, _) => k + [..._.text].length, 0) > 1e5 || new Set(P.map((k) => k.itemId)).size !== P.length)
+    throw new Error("Invalid response: output budget or identity");
+  return {
+    chatId: a,
+    responseId: n,
+    status: i,
+    terminal: m,
+    snapshotRevision: p(l.snapshotRevision, 1),
+    items: P,
+    ...l.cancelRequested === void 0 ? {} : { cancelRequested: G(l.cancelRequested) }
+  };
+}
+function ue(o, a) {
+  const n = A(o), l = g(n.id), i = f(n.status, 64), m = p(n.sizeBytes), P = p(n.partSize, 1);
+  if (a && l !== a)
+    throw new Error("Invalid response: upload identity");
+  const k = K(n.completedParts, 65536).map(
+    (M) => p(M, 0, Math.max(0, Math.ceil(m / P) - 1))
+  );
+  if (new Set(k).size !== k.length)
+    throw new Error("Invalid response: upload receipt");
+  const _ = {
+    id: l,
+    status: i,
+    name: f(n.name, 512),
+    contentType: f(n.contentType, 256),
+    sizeBytes: m,
+    partSize: P,
+    completedParts: k,
+    ...n.expiresAt === void 0 ? {} : { expiresAt: te(n.expiresAt) }
+  };
+  if (i === "ready") {
+    const M = A(n.content);
+    if (M.kind !== "reference" || M.sizeBytes !== m || !/^[0-9a-f]{64}$/.test(String(M.digestSha256)))
+      throw new Error("Invalid response: upload content");
+    return {
+      ..._,
+      content: {
+        kind: "reference",
+        contentRef: g(M.contentRef),
+        sizeBytes: m,
+        digestSha256: String(M.digestSha256)
+      }
+    };
+  }
+  if (i === "uploading" && !_.expiresAt)
+    throw new Error("Invalid response: upload expiry");
+  return _;
+}
+function Be(o, a, n) {
+  const l = A(o), i = A(l.limits);
+  if (l.apiVersion !== "v1" || l.appKey !== a || l.agentId !== n)
+    throw new Error("Invalid response: capability scope");
+  return {
+    apiVersion: "v1",
+    appKey: a,
+    agentId: n,
+    features: K(l.features, 256).map((m) => f(m, 128)),
+    modelInputKinds: K(l.modelInputKinds, 64).map((m) => f(m, 64)),
+    limits: {
+      maxInputTextBytes: p(i.maxInputTextBytes, 1),
+      maxMessageBytes: p(i.maxMessageBytes, 1),
+      maxInputParts: p(i.maxInputParts, 1),
+      maxUploadBytes: p(i.maxUploadBytes, 1),
+      uploadPartBytes: p(i.uploadPartBytes, 1),
+      maxConcurrentUploads: p(i.maxConcurrentUploads, 1),
+      maxSseEventBytes: p(i.maxSseEventBytes, 1)
+    }
+  };
+}
+class h extends Error {
+  status;
+  code;
+  requestId;
+  retryAfterMs;
+  outcome;
+  lastCursor;
+  constructor(a, n = {}) {
+    super(a), this.name = "ApiError", this.code = a, this.status = n.status, this.requestId = n.requestId, this.retryAfterMs = n.retryAfterMs, this.outcome = n.outcome ?? "known", this.lastCursor = n.lastCursor;
+  }
+}
+const Z = new TextEncoder(), q = (o, a) => Object.entries(o.headers).find(
+  ([n]) => n.toLowerCase() === a.toLowerCase()
+)?.[1], H = (o) => new URLSearchParams(
+  Object.entries(o).filter(([, a]) => a !== void 0).map(([a, n]) => [a, String(n)])
+).toString(), J = (o) => encodeURIComponent(g(o));
+function ee(o, a) {
+  return new Promise((n, l) => {
+    const i = () => l(new h("AI_CLIENT_ABORTED"));
+    if (a.aborted) {
+      o.catch(() => {
+      }), i();
+      return;
+    }
+    a.addEventListener("abort", i, { once: !0 }), o.then(n, l).finally(() => a.removeEventListener("abort", i));
+  });
+}
+async function* he(o, a) {
+  const n = o.body?.[Symbol.asyncIterator]();
+  if (n)
+    try {
+      for (; ; ) {
+        const l = await ee(n.next(), a);
+        if (l.done) return;
+        yield l.value;
+      }
+    } finally {
+      n.return?.().catch(() => {
+      });
+    }
+}
+function De(o) {
+  const a = o.apiVersion ?? "v1";
+  if (a !== "v1")
+    throw new h("AI_API_VERSION_UNSUPPORTED", { outcome: "notSent" });
+  if (!["sdk", "transport"].includes(o.transport.retryOwner))
+    throw new h("AI_BAD_REQUEST", { outcome: "notSent" });
+  const n = Object.freeze({
+    appKey: g(o.scope.appKey),
+    identityKey: f(o.scope.identityKey, 8192)
+  }), l = o.basePath ?? "/api/make/app/ai";
+  if (!/^\/(?!\/)[A-Za-z0-9/_-]+$/.test(l) || /\/v\d+\/?$/.test(l))
+    throw new Error("Invalid request: basePath");
+  if (o.transport.retryOwner === "transport" && o.retry)
+    throw new Error("Invalid request: multiple retry owners");
+  const i = p(o.retry?.maxAttempts ?? 3, 1, 5), m = p(
+    o.maxJsonBytes ?? 8 * 1024 * 1024,
+    1,
+    32 * 1024 * 1024
+  ), P = p(
+    o.maxEventBytes ?? 1024 * 1024,
+    1,
+    4 * 1024 * 1024
+  ), k = /* @__PURE__ */ new Set();
+  let _ = !1;
+  const M = (e, s, r, t) => {
+    try {
+      o.onDiagnostic?.({ operation: e, code: s, requestId: r, attempts: t });
+    } catch {
+    }
+  }, Y = (e, s) => {
+    if (_ || e?.signal?.aborted)
+      throw new h("AI_CLIENT_ABORTED", { outcome: "notSent" });
+    const r = p(
+      e?.timeoutMs ?? s,
+      1,
+      1440 * 60 * 1e3
+    ), t = new AbortController();
+    k.add(t);
+    const c = () => t.abort();
+    e?.signal?.addEventListener("abort", c, { once: !0 });
+    let u = !1;
+    const d = setTimeout(() => {
+      u = !0, c();
+    }, r);
+    return {
+      controller: t,
+      deadline: Date.now() + r,
+      failure: (I = "known") => new h(u ? "AI_CLIENT_TIMEOUT" : "AI_CLIENT_ABORTED", {
+        outcome: I
+      }),
+      close: () => {
+        clearTimeout(d), e?.signal?.removeEventListener("abort", c), k.delete(t), t.abort();
+      }
+    };
+  }, se = async (e, s) => {
+    if (s.aborted) throw new h("AI_CLIENT_ABORTED");
+    await new Promise((r, t) => {
+      const u = setTimeout(() => {
+        s.removeEventListener("abort", d), r();
+      }, e), d = () => {
+        clearTimeout(u), s.removeEventListener("abort", d), t(new h("AI_CLIENT_ABORTED"));
+      };
+      s.addEventListener("abort", d, { once: !0 });
+    });
+  }, Ie = async (e, s, r) => {
+    let t = 0;
+    const c = [];
+    for await (const I of he(e, r)) {
+      if (t += I.byteLength, t > s)
+        throw new h("AI_RESPONSE_TOO_LARGE", {
+          status: e.status
+        });
+      c.push(I);
+    }
+    const u = new Uint8Array(t);
+    let d = 0;
+    for (const I of c)
+      u.set(I, d), d += I.length;
+    return u;
+  }, ae = async (e, s) => {
+    let r = "AI_HTTP_ERROR";
+    try {
+      const u = A(
+        JSON.parse(
+          new TextDecoder("utf-8", { fatal: !0 }).decode(
+            await Ie(e, m, s)
+          )
+        )
+      );
+      typeof u.code == "string" && u.code.length < 128 && (r = u.code);
+    } catch {
+    }
+    const t = q(e, "retry-after"), c = t === void 0 ? void 0 : /^\d+$/.test(t) ? Number(t) * 1e3 : Math.max(0, Date.parse(t) - Date.now());
+    return new h(r, {
+      status: e.status,
+      requestId: q(e, "x-request-id"),
+      retryAfterMs: Number.isFinite(c) ? c : void 0
+    });
+  }, O = (e, s, r, t) => ({
+    method: e,
+    path: l.replace(/\/$/, "") + "/" + a + s,
+    headers: {
+      accept: "application/json",
+      ...r === void 0 && t === void 0 ? {} : {
+        "content-type": t ? "application/octet-stream" : "application/json"
+      }
+    },
+    ...t === void 0 ? r === void 0 ? {} : { body: Z.encode(JSON.stringify(r)) } : { body: new Uint8Array(t) }
+  });
+  async function b(e, s, r, t, c = !0, u = [200]) {
+    const d = Y(t, o.timeoutMs ?? 3e4), I = c && o.transport.retryOwner === "sdk" ? i : 1;
+    let y = !1;
+    M(e), console.info("[make-ai-assistant] client operation start", { operation: e });
+    try {
+      for (let R = 1; R <= I; R++)
+        try {
+          if (d.controller.signal.aborted || Date.now() >= d.deadline)
+            throw new h("AI_CLIENT_TIMEOUT", {
+              outcome: y ? "unknown" : "notSent"
+            });
+          y = !0;
+          const w = await ee(
+            o.transport.request(s, {
+              signal: d.controller.signal,
+              timeoutMs: Math.max(1, d.deadline - Date.now())
+            }),
+            d.controller.signal
+          );
+          if (w.status < 200 || w.status >= 300)
+            throw await ae(w, d.controller.signal);
+          if (q(w, "make-ai-api-version") !== a || !u.includes(w.status))
+            throw new h("AI_PROTOCOL_ERROR", {
+              status: w.status
+            });
+          let v;
+          if (w.status !== 204) {
+            if (!q(w, "content-type")?.toLowerCase().includes("application/json"))
+              throw new h("AI_PROTOCOL_ERROR", {
+                status: w.status
+              });
+            try {
+              v = JSON.parse(
+                new TextDecoder("utf-8", { fatal: !0 }).decode(
+                  await Ie(
+                    w,
+                    m,
+                    d.controller.signal
+                  )
+                )
+              );
+            } catch (S) {
+              throw S instanceof h ? S : new h("AI_PROTOCOL_ERROR", {
+                status: w.status
+              });
+            }
+          }
+          try {
+            const S = r(v);
+            return M(
+              e,
+              void 0,
+              q(w, "x-request-id"),
+              R
+            ), S;
+          } catch {
+            throw new h("AI_PROTOCOL_ERROR", {
+              status: w.status,
+              requestId: q(w, "x-request-id")
+            });
+          }
+        } catch (w) {
+          if (d.controller.signal.aborted)
+            throw d.failure(y ? "unknown" : "notSent");
+          let v = w instanceof h ? w : new h("AI_TRANSPORT_ERROR", {
+            outcome: y ? "unknown" : "notSent"
+          });
+          s.method !== "GET" && y && ((v.status ?? 0) >= 500 || v.status === 408 || ["AI_PROTOCOL_ERROR", "AI_RESPONSE_TOO_LARGE"].includes(
+            v.code
+          )) && (v = new h(v.code, {
+            ...v,
+            outcome: "unknown"
+          }));
+          const S = v.code === "AI_TRANSPORT_ERROR" || [429, 502, 503, 504].includes(v.status ?? 0) && v.code !== "AI_QUOTA_EXCEEDED", T = v.retryAfterMs ?? Math.min(
+            o.retry?.maxDelayMs ?? 5e3,
+            100 * 2 ** (R - 1) * (0.5 + Math.random())
+          );
+          if (!S || R === I || d.controller.signal.aborted || Date.now() + T >= d.deadline)
+            throw v;
+          await se(T, d.controller.signal);
+        }
+      throw new h("AI_TRANSPORT_ERROR", { outcome: "unknown" });
+    } catch (R) {
+      throw M(
+        e,
+        R instanceof h ? R.code : "AI_CLIENT_ERROR"
+      ), console.warn("[make-ai-assistant] client operation failed", {
+        operation: e
+      }), R;
+    } finally {
+      d.close();
+    }
+  }
+  const C = (e) => "/chats/" + J(e), fe = (e) => C(e.chatId) + "/responses/" + J(e.responseId), oe = (e, s) => ({
+    ...e.cursor === void 0 ? {} : { cursor: W(e.cursor) },
+    ...e.limit === void 0 ? {} : { limit: p(e.limit, 1, s) }
+  }), Re = (e) => {
+    if (E(e, ["chatId", "messageId", "text", "parts"]), g(e.chatId), X(e.messageId), e.text === void 0 == (e.parts === void 0))
+      throw new Error("Invalid request: text and parts are exclusive");
+    let s = e.text ?? "";
+    if (e.parts !== void 0) {
+      const c = /* @__PURE__ */ new Set();
+      for (const u of K(e.parts, 32)) {
+        const d = A(u), I = X(d.id);
+        if (c.has(I))
+          throw new Error("Invalid request: duplicate part");
+        if (c.add(I), d.kind === "text")
+          E(d, ["id", "kind", "text"]), s += f(d.text, 8192, !0);
+        else {
+          if (E(d, ["id", "kind", "name", "media"]), !["image", "file", "audio", "video"].includes(String(d.kind)))
+            throw new Error("Invalid request: part kind");
+          E(A(d.media), [
+            "contentRef",
+            "contentType",
+            "sizeBytes",
+            "digestSha256"
+          ]);
+          const y = ge(d.media);
+          if (d.name !== void 0 && /[\r\n/\\]/.test(f(d.name, 512)))
+            throw new h("AI_BAD_REQUEST", { outcome: "notSent" });
+          if (!/^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/.test(
+            y.contentType
+          ) || d.kind !== "file" && (!y.contentType.startsWith(String(d.kind) + "/") || y.contentType === "image/svg+xml"))
+            throw new h("AI_BAD_REQUEST", { outcome: "notSent" });
+        }
+      }
+      if (!e.parts.length || !s.trim() && e.parts.every((u) => u.kind === "text"))
+        throw new Error("Invalid request: empty message");
+    } else f(e.text, 8192);
+    if (Z.encode(s).length > 8192)
+      throw new Error("Invalid request: text exceeds 8 KiB");
+    const { chatId: r, ...t } = e;
+    if (Z.encode(JSON.stringify(t)).length > 65536)
+      throw new Error("Invalid request: message too large");
+    return t;
+  }, ie = /* @__PURE__ */ new Map();
+  async function* pe(e, s, r, t) {
+    p(r, 1, 1e4), p(t, 1);
+    const c = /* @__PURE__ */ new Set();
+    let u = s, d = 0;
+    for (let I = 0; I < r; I++) {
+      const y = await e(u);
+      for (const R of y.values) {
+        if (++d > t)
+          throw new h("AI_ITERATION_LIMIT", { lastCursor: u });
+        yield R;
+      }
+      if (!y.hasMore) return;
+      if (y.nextCursor === u || c.has(y.nextCursor))
+        throw new h("AI_PROTOCOL_ERROR");
+      c.add(y.nextCursor), u = y.nextCursor;
+    }
+    throw new h("AI_ITERATION_LIMIT", { lastCursor: u });
+  }
+  const N = {
+    apiVersion: a,
+    scope: n,
+    capabilities: {
+      async get(e, s) {
+        E(e, ["agentId"]);
+        const r = g(e.agentId), t = ie.get(r);
+        if (!_ && !s?.signal?.aborted && t && t.expires > Date.now())
+          return t.value;
+        const c = await b(
+          "capabilities.get",
+          O(
+            "GET",
+            "/capabilities?" + H({ appKey: n.appKey, agentId: r })
+          ),
+          (u) => Be(u, n.appKey, r),
+          s
+        );
+        return ie.set(r, {
+          value: c,
+          expires: Date.now() + 6e4
+        }), c;
+      }
+    },
+    agents: {
+      async list(e = {}, s) {
+        return E(e, ["cursor", "limit"]), b(
+          "agents.list",
+          O(
+            "GET",
+            "/agents?" + H({ appKey: n.appKey, ...oe(e, 100) })
+          ),
+          (r) => Ce(r, n.appKey),
+          s
+        );
+      }
+    },
+    chats: {
+      async create(e, s) {
+        E(e, ["agentId", "requestId", "title"]);
+        const r = g(e.agentId);
+        return X(e.requestId), e.title !== void 0 && f(e.title, 255), b(
+          "chats.create",
+          O("POST", "/chats", { appKey: n.appKey, ...e }),
+          (t) => ne(t, n.appKey, r),
+          s,
+          !0,
+          [201]
+        );
+      },
+      async list(e, s) {
+        E(e, ["agentId", "cursor", "limit"]);
+        const r = g(e.agentId);
+        return b(
+          "chats.list",
+          O(
+            "GET",
+            "/chats?" + H({
+              appKey: n.appKey,
+              agentId: r,
+              ...oe(e, 100)
+            })
+          ),
+          (t) => Me(t, n.appKey, r),
+          s
+        );
+      },
+      async get(e, s) {
+        return E(e, ["chatId"]), b(
+          "chats.get",
+          O("GET", C(e.chatId)),
+          (r) => ne(r, n.appKey, void 0, e.chatId),
+          s
+        );
+      },
+      async update(e, s) {
+        if (E(e, [
+          "chatId",
+          "expectedRevision",
+          "title",
+          "pinned"
+        ]), p(e.expectedRevision, 1), e.title === void 0 && e.pinned === void 0)
+          throw new Error("Invalid request: empty patch");
+        e.title !== void 0 && f(e.title, 255), e.pinned !== void 0 && G(e.pinned);
+        const { chatId: r, ...t } = e;
+        return b(
+          "chats.update",
+          O("PATCH", C(r), t),
+          (c) => ne(c, n.appKey, void 0, r),
+          s,
+          !1
+        );
+      },
+      async delete(e, s) {
+        E(e, ["chatId", "expectedRevision"]), p(e.expectedRevision, 1), await b(
+          "chats.delete",
+          O(
+            "DELETE",
+            C(e.chatId) + "?" + H({ expectedRevision: e.expectedRevision })
+          ),
+          () => {
+          },
+          s,
+          !1,
+          [204]
+        );
+      },
+      iterate(e, s) {
+        return pe(
+          async (r) => {
+            const t = await N.chats.list({ ...e, cursor: r }, s);
+            return { ...t, values: t.chats };
+          },
+          e.cursor,
+          s.maxPages,
+          s.maxItems
+        );
+      }
+    },
+    messages: {
+      async send(e, s) {
+        const r = Re(e);
+        return b(
+          "messages.send",
+          O("POST", C(e.chatId) + "/messages", r),
+          (t) => {
+            const c = A(t);
+            if (c.chatId !== e.chatId || c.messageId !== e.messageId)
+              throw new Error("Invalid response: accepted scope");
+            return {
+              chatId: e.chatId,
+              messageId: e.messageId,
+              responseId: g(c.responseId),
+              ...c.acceptedCursor === void 0 ? {} : { acceptedCursor: W(c.acceptedCursor) }
+            };
+          },
+          s,
+          !0,
+          [202]
+        );
+      },
+      async list(e, s) {
+        E(e, ["chatId", "cursor", "limit"]);
+        const r = H(oe(e, 200));
+        return b(
+          "messages.list",
+          O(
+            "GET",
+            C(e.chatId) + "/messages" + (r ? "?" + r : "")
+          ),
+          Le,
+          s
+        );
+      },
+      iterate(e, s) {
+        return pe(
+          async (r) => {
+            const t = await N.messages.list({ ...e, cursor: r }, s);
+            return { ...t, values: t.messages };
+          },
+          e.cursor,
+          s.maxPages,
+          s.maxItems
+        );
+      },
+      async sendAndWatch(e, s) {
+        const r = Date.now(), t = await N.messages.send(e, s), c = (s?.timeoutMs ?? o.stream?.maxDurationMs ?? 6e5) - (Date.now() - r);
+        if (c <= 0)
+          throw new h("AI_CLIENT_TIMEOUT", { outcome: "known" });
+        return {
+          accepted: t,
+          events: N.responses.subscribe(
+            { chatId: t.chatId, responseId: t.responseId },
+            { ...s, timeoutMs: c }
+          )
+        };
+      }
+    },
+    responses: {
+      async get(e, s) {
+        return E(e, ["chatId", "responseId"]), b(
+          "responses.get",
+          O("GET", fe(e)),
+          (r) => le(r, e.chatId, e.responseId),
+          s
+        );
+      },
+      subscribe(e, s) {
+        return Te(e, s);
+      },
+      async cancel(e, s) {
+        return E(e, ["chatId", "responseId"]), b(
+          "responses.cancel",
+          O("POST", fe(e) + "/cancel", {}),
+          (r) => le(r, e.chatId, e.responseId),
+          s,
+          !0,
+          [200, 202]
+        );
+      },
+      async waitForTerminal(e, s) {
+        const r = Y(s, s.timeoutMs);
+        try {
+          for (; !r.controller.signal.aborted; ) {
+            const t = await N.responses.get(e, {
+              signal: r.controller.signal,
+              timeoutMs: Math.max(1, r.deadline - Date.now())
+            });
+            if (t.terminal) return t;
+            await se(s.pollIntervalMs ?? 1e3, r.controller.signal);
+          }
+          throw new h("AI_CLIENT_TIMEOUT");
+        } finally {
+          r.close();
+        }
+      }
+    },
+    feedback: {
+      async set(e, s) {
+        if (E(e, [
+          "chatId",
+          "messageId",
+          "requestId",
+          "rating",
+          "reason",
+          "comment"
+        ]), X(e.requestId), !["like", "dislike", "none"].includes(e.rating))
+          throw new Error("Invalid request: rating");
+        e.reason !== void 0 && f(e.reason, 128, !0), e.comment !== void 0 && f(e.comment, 4e3, !0);
+        const { chatId: r, messageId: t, ...c } = e;
+        return b(
+          "feedback.set",
+          O(
+            "PUT",
+            C(r) + "/messages/" + J(t) + "/feedback",
+            c
+          ),
+          Ee,
+          s
+        );
+      }
+    },
+    uploads: {
+      async start(e, s) {
+        E(e, [
+          "chatId",
+          "fileId",
+          "name",
+          "contentType",
+          "sizeBytes",
+          "digestSha256"
+        ]), X(e.fileId), f(e.name, 512), f(e.contentType, 256), p(e.sizeBytes, 1);
+        const { chatId: r, ...t } = e;
+        return b(
+          "uploads.start",
+          O("POST", C(r) + "/uploads", t),
+          (c) => ue(c),
+          s
+        );
+      },
+      async get(e, s) {
+        return E(e, ["chatId", "uploadId"]), b(
+          "uploads.get",
+          O(
+            "GET",
+            C(e.chatId) + "/uploads/" + J(e.uploadId)
+          ),
+          (r) => ue(r, e.uploadId),
+          s
+        );
+      },
+      async putPart(e, s) {
+        if (E(e, ["chatId", "uploadId", "part", "bytes"]), p(e.part), !(e.bytes instanceof Uint8Array) || e.bytes.length > m)
+          throw new Error("Invalid request: upload bytes");
+        await b(
+          "uploads.putPart",
+          O(
+            "PUT",
+            C(e.chatId) + "/uploads/" + J(e.uploadId) + "/parts/" + e.part,
+            void 0,
+            e.bytes
+          ),
+          () => {
+          },
+          s,
+          !0,
+          [204]
+        );
+      },
+      async complete(e, s) {
+        return E(e, ["chatId", "uploadId"]), b(
+          "uploads.complete",
+          O(
+            "POST",
+            C(e.chatId) + "/uploads/" + J(e.uploadId) + "/complete",
+            {}
+          ),
+          (r) => ue(r, e.uploadId),
+          s
+        );
+      },
+      async uploadFile(e, s) {
+        const r = p(s?.concurrency ?? 2, 1, 8), t = Y(s, o.timeoutMs ?? 3e5), c = () => ({
+          signal: t.controller.signal,
+          timeoutMs: Math.max(1, t.deadline - Date.now())
+        });
+        try {
+          const { source: u, ...d } = e, I = await N.uploads.start(
+            { ...d, sizeBytes: u.sizeBytes },
+            c()
+          );
+          if (I.status === "ready") return I;
+          if (I.status !== "uploading" || I.partSize > m || I.sizeBytes !== u.sizeBytes)
+            throw new h("AI_UPLOAD_UNAVAILABLE");
+          const y = new Set(I.completedParts), R = Math.ceil(u.sizeBytes / I.partSize);
+          let w = 0, v = I.completedParts.reduce(
+            (T, L) => T + Math.min(
+              I.partSize,
+              u.sizeBytes - L * I.partSize
+            ),
+            0
+          );
+          const S = Array.from({ length: r }, async () => {
+            for (; w < R; ) {
+              if (t.controller.signal.aborted) throw t.failure();
+              const T = w++;
+              if (y.has(T)) continue;
+              const L = Math.min(
+                I.partSize,
+                u.sizeBytes - T * I.partSize
+              ), z = await ee(
+                u.read(T * I.partSize, L, c()),
+                t.controller.signal
+              );
+              if (!(z instanceof Uint8Array) || z.length !== L)
+                throw new h("AI_CONTENT_INTEGRITY_ERROR");
+              await N.uploads.putPart(
+                { chatId: e.chatId, uploadId: I.id, part: T, bytes: z },
+                c()
+              ), v += L;
+              try {
+                s?.onProgress?.(v);
+              } catch {
+              }
+            }
+          });
+          try {
+            await Promise.all(S);
+          } catch (T) {
+            throw t.controller.abort(), await Promise.allSettled(S), T;
+          }
+          return await N.uploads.complete(
+            { chatId: e.chatId, uploadId: I.id },
+            c()
+          );
+        } finally {
+          t.close();
+        }
+      }
+    },
+    content: {
+      async read(e, s) {
+        M("content.read"), console.info("[make-ai-assistant] client operation start", {
+          operation: "content.read"
+        }), E(e, ["chatId", "contentRef", "maxBytes"]), p(e.maxBytes, 1);
+        const r = Y(s, o.timeoutMs ?? 3e4);
+        try {
+          const t = await ee(
+            o.transport.request(
+              O(
+                "GET",
+                C(e.chatId) + "/content/" + J(e.contentRef)
+              ),
+              { signal: r.controller.signal }
+            ),
+            r.controller.signal
+          );
+          if (t.status !== 200)
+            throw await ae(t, r.controller.signal);
+          if (q(t, "make-ai-api-version") !== a)
+            throw new h("AI_PROTOCOL_ERROR");
+          const c = q(t, "content-length"), u = c === void 0 ? void 0 : Number(c);
+          if (u !== void 0 && (!Number.isSafeInteger(u) || u < 0 || u > e.maxBytes))
+            throw new h("AI_RESPONSE_TOO_LARGE");
+          return {
+            contentType: q(t, "content-type"),
+            contentLength: u,
+            body: (async function* () {
+              let d = 0;
+              try {
+                for await (const I of he(
+                  t,
+                  r.controller.signal
+                )) {
+                  if (d += I.length, d > e.maxBytes)
+                    throw new h("AI_RESPONSE_TOO_LARGE");
+                  yield I;
+                }
+                if (u !== void 0 && u !== d)
+                  throw new h("AI_CONTENT_INTEGRITY_ERROR");
+              } finally {
+                r.close();
+              }
+            })()
+          };
+        } catch (t) {
+          throw r.close(), t;
+        }
+      }
+    },
+    dispose() {
+      _ = !0, ie.clear();
+      for (const e of k) e.abort();
+      k.clear();
+    }
+  };
+  async function* Te(e, s) {
+    M("responses.subscribe"), console.info("[make-ai-assistant] client operation start", {
+      operation: "responses.subscribe"
+    }), E(e, ["chatId", "responseId", "cursor"]), g(e.chatId), g(e.responseId);
+    let r = e.cursor === void 0 ? void 0 : W(e.cursor);
+    const t = Y(s, o.stream?.maxDurationMs ?? 6e5), c = /* @__PURE__ */ new Map();
+    let u = 0, d = !1;
+    const I = o.transport.retryOwner === "sdk" ? i : 1;
+    try {
+      for (let y = 1; y <= I; y++) {
+        const R = new AbortController(), w = () => R.abort();
+        t.controller.signal.addEventListener("abort", w, {
+          once: !0
+        });
+        let v, S = !1;
+        try {
+          if (t.controller.signal.aborted) throw t.failure();
+          const T = O(
+            "GET",
+            C(e.chatId) + "/events?" + H({ responseId: e.responseId, cursor: r })
+          ), L = setTimeout(
+            w,
+            o.stream?.connectTimeoutMs ?? 3e4
+          );
+          let z;
+          try {
+            z = await ee(
+              o.transport.request(
+                {
+                  ...T,
+                  headers: { ...T.headers, accept: "text/event-stream" }
+                },
+                { signal: R.signal }
+              ),
+              R.signal
+            );
+          } finally {
+            clearTimeout(L);
+          }
+          if (z.status !== 200)
+            throw await ae(z, R.signal);
+          if (q(z, "make-ai-api-version") !== a || !q(z, "content-type")?.startsWith("text/event-stream"))
+            throw new h("AI_PROTOCOL_ERROR");
+          const we = new TextDecoder("utf-8", { fatal: !0 });
+          let V = "";
+          v = setTimeout(
+            w,
+            o.stream?.idleTimeoutMs ?? 6e4
+          );
+          for await (const Ae of he(z, R.signal)) {
+            if (clearTimeout(v), v = setTimeout(
+              w,
+              o.stream?.idleTimeoutMs ?? 6e4
+            ), S = !0, V += we.decode(Ae, { stream: !0 }), Z.encode(V).length > P * 2)
+              throw new h("AI_RESPONSE_TOO_LARGE");
+            let re;
+            for (; re = /\r?\n\r?\n/.exec(V); ) {
+              const Oe = V.slice(0, re.index);
+              V = V.slice(re.index + re[0].length);
+              let $ = "message", U;
+              const ce = [];
+              for (const D of Oe.split(/\r?\n/)) {
+                const j = D.indexOf(":");
+                if (j < 0 || j === 0) continue;
+                const Q = D.slice(0, j), de = D.slice(j + 1).replace(/^ /, "");
+                Q === "event" && ($ = de), Q === "id" && (U = de || void 0), Q === "data" && ce.push(de);
+              }
+              if (!ce.length) continue;
+              const ye = ce.join(`
+`);
+              if (Z.encode(ye).length > P)
+                throw new h("AI_RESPONSE_TOO_LARGE");
+              U && W(U);
+              const B = A(JSON.parse(ye));
+              if (B.responseId !== e.responseId)
+                throw new h("AI_PROTOCOL_ERROR");
+              const F = {
+                responseId: e.responseId,
+                ...U ? { cursor: U } : {}
+              };
+              let x;
+              switch ($) {
+                case "response.subscribed":
+                  x = { kind: "subscribed", ...F };
+                  break;
+                case "response.state":
+                  x = {
+                    kind: "state",
+                    ...F,
+                    status: f(B.status, 64)
+                  };
+                  break;
+                case "response.reset":
+                  x = {
+                    kind: "reset",
+                    ...F,
+                    reason: f(B.reason, 128)
+                  };
+                  break;
+                case "response.snapshot":
+                  x = {
+                    kind: "snapshot",
+                    ...F,
+                    snapshot: le(
+                      B,
+                      e.chatId,
+                      e.responseId
+                    )
+                  };
+                  break;
+                case "response.completed":
+                case "response.failed":
+                case "response.cancelled":
+                  x = {
+                    kind: $.slice(9),
+                    ...F,
+                    ...B.code === void 0 ? {} : { code: f(B.code, 128) }
+                  };
+                  break;
+                case "response.output_item.added":
+                case "response.output_text.delta":
+                case "response.output_item.done": {
+                  const D = {
+                    ...F,
+                    itemId: g(B.itemId),
+                    partId: g(B.partId),
+                    sequence: p(B.sequence, 1)
+                  };
+                  x = $ === "response.output_item.added" ? { kind: "itemAdded", ...D } : $ === "response.output_text.delta" ? {
+                    kind: "textDelta",
+                    ...D,
+                    delta: f(B.delta, 1e5, !0)
+                  } : {
+                    kind: "itemDone",
+                    ...D,
+                    text: f(B.text, 1e5, !0),
+                    final: G(B.final)
+                  };
+                  break;
+                }
+                default:
+                  x = {
+                    kind: "unknown",
+                    ...F,
+                    name: f($, 128)
+                  };
+              }
+              if (x.kind === "failed" && x.code === "AI_UPSTREAM_ERROR")
+                throw new h("AI_STREAM_INTERRUPTED", {
+                  lastCursor: r
+                });
+              if ((x.kind === "reset" || x.kind === "snapshot") && (d = !0), U) {
+                r = U;
+                const D = $ + "\0" + JSON.stringify(x), j = c.get(U);
+                if (j !== void 0) {
+                  if (j !== D)
+                    throw new h("AI_PROTOCOL_ERROR");
+                  continue;
+                }
+                for (c.set(U, D), u += D.length; c.size > 512 || u > 4e6; ) {
+                  const Q = c.keys().next().value;
+                  u -= c.get(Q).length, c.delete(Q);
+                }
+              }
+              if (yield x, ["completed", "failed", "cancelled"].includes(x.kind) || x.kind === "snapshot" && x.snapshot.terminal)
+                return;
+            }
+            S = !1;
+          }
+          throw S = !0, we.decode(), new h("AI_STREAM_INTERRUPTED", { lastCursor: r });
+        } catch (T) {
+          if (t.controller.signal.aborted) throw t.failure();
+          if (!(T instanceof h) && S)
+            throw new h("AI_PROTOCOL_ERROR", { lastCursor: r });
+          if (T instanceof h && !["AI_STREAM_INTERRUPTED", "AI_CLIENT_ABORTED"].includes(
+            T.code
+          ) && ![429, 502, 503, 504].includes(T.status ?? 0))
+            throw T;
+          if (d) {
+            for (console.info(
+              "[make-ai-assistant] stream recovery uses confirmed snapshots"
+            ); !t.controller.signal.aborted; ) {
+              const L = await N.responses.get(
+                { chatId: e.chatId, responseId: e.responseId },
+                {
+                  signal: t.controller.signal,
+                  timeoutMs: Math.max(1, t.deadline - Date.now())
+                }
+              );
+              if (yield { kind: "snapshot", snapshot: L }, L.terminal) return;
+              await se(1e3, t.controller.signal);
+            }
+            throw t.failure();
+          }
+          if (y === I) {
+            const L = await N.responses.get(
+              { chatId: e.chatId, responseId: e.responseId },
+              {
+                signal: t.controller.signal,
+                timeoutMs: Math.max(1, t.deadline - Date.now())
+              }
+            );
+            if (yield { kind: "snapshot", snapshot: L }, L.terminal) return;
+            throw new h("AI_STREAM_INTERRUPTED", { lastCursor: r });
+          }
+          await se(
+            Math.min(o.retry?.maxDelayMs ?? 2e3, 500 * y),
+            t.controller.signal
+          );
+        } finally {
+          clearTimeout(v), t.controller.signal.removeEventListener("abort", w), R.abort();
+        }
+      }
+    } finally {
+      t.close();
+    }
+  }
+  return N;
+}
+export {
+  h as ApiError,
+  De as createMakeAgentClient
+};