@leaflow/sdk 0.0.0-dev.35.g30ba751 → 0.0.0-dev.353.g74313e0

package/dist/assistant/v1/generated/functions.js

@@ -0,0 +1,1083 @@
+export const getListModelsUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/models`;
+};
+/**
+ * Returns Canopy's models filtered by Assistant's saved allowlist and selection policy. There is no separately maintained assistant catalogue. The complete list is not paginated and is ordered by displayName, then id.
+ *
+ * When allowModelSelection is true, models contains allowed Canopy models that remain callable, support tools and have positive context and output limits. When false, only the default is returned if it meets those conditions. defaultModelId is null if no usable default is known. Disallowed, retired and incompatible models are omitted, while saved preferences may still reference them.
+ *
+ * This operation reads capabilities without making an inference request. It does not check live provider health or the inference key's model restrictions. If Canopy cannot be read and no usable cached snapshot exists, it returns 503 with code MODEL_CATALOG_UNAVAILABLE; a failed read is not an empty catalogue. An empty allowlist returns an empty list without needing Canopy. Supplier connection details and credentials are not returned.
+ * @summary List assistant model choices
+ */
+export const listModels = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListModelsUrl(), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUploadAttachmentUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://assistant.leaflow.cloud/api/v1/attachments?${stringifiedParams}`
+        : `https://assistant.leaflow.cloud/api/v1/attachments`;
+};
+/**
+ * The body is the file bytes themselves, not multipart, one file per request. The kind is determined from the content, not from Content-Type or from the name. Put the returned id in attachmentIds when sending a message.
+ *
+ * An upload that no message ever references is a draft, and drafts are collected — `draftExpiresAt` in the response says when this one goes. Sending a message with the id makes it permanent.
+ *
+ * The returned `kind` says how the assistant will see it. An `image` is read directly, and only by models that accept image input. A small `text` file is placed inline in the message. A large `text` file, and anything `binary`, arrives as a reference the assistant reads on demand — for a binary that usually means downloading it onto one of the project's cloud instances.
+ * @summary Upload a file
+ */
+export const uploadAttachment = async (uploadAttachmentBody, params, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getUploadAttachmentUrl(params), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "*/*", ...getHeaders(options?.headers) },
+        body: uploadAttachmentBody,
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDownloadAttachmentUrl = (attachment) => {
+    return `https://assistant.leaflow.cloud/api/v1/attachments/${encodeURIComponent(String(attachment))}`;
+};
+/**
+ * Returns the original bytes for an attachment id. The response carries long-lived cache headers because the content never changes. Returns 404 when the attachment does not exist or does not belong to the current user.
+ *
+ * Only an attachment whose `kind` is `image` comes back with its own image type and is usable as the address of an `<img>`. Everything else is served as `application/octet-stream` with `Content-Disposition: attachment`, deliberately: an uploaded file is arbitrary bytes under a name its uploader chose, and serving it back inline would run it on this origin.
+ * @summary Download a file
+ */
+export const downloadAttachment = async (attachment, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDownloadAttachmentUrl(attachment), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.blob();
+    const data = body;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListBindingsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://assistant.leaflow.cloud/api/v1/bindings?${stringifiedParams}`
+        : `https://assistant.leaflow.cloud/api/v1/bindings`;
+};
+/**
+ * Filter by channelId to show, per channel, who is bound to it.
+ * @summary List bindings
+ */
+export const listBindings = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListBindingsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetBindingUrl = (binding) => {
+    return `https://assistant.leaflow.cloud/api/v1/bindings/${encodeURIComponent(String(binding))}`;
+};
+/**
+ * @summary Get a binding
+ */
+export const getBinding = async (binding, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetBindingUrl(binding), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteBindingUrl = (binding) => {
+    return `https://assistant.leaflow.cloud/api/v1/bindings/${encodeURIComponent(String(binding))}`;
+};
+/**
+ * @summary Remove a binding
+ */
+export const deleteBinding = async (binding, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteBindingUrl(binding), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListChannelsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://assistant.leaflow.cloud/api/v1/channels?${stringifiedParams}`
+        : `https://assistant.leaflow.cloud/api/v1/channels`;
+};
+/**
+ * @summary List channels
+ */
+export const listChannels = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListChannelsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateChannelUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/channels`;
+};
+/**
+ * Which side owns the webhook secret is decided by the platform; see secretSource on list-platforms. For a `generated` platform, do not send webhookSecret — the one we generate is returned exactly once in this response and cannot be retrieved again; miss it and the only way forward is rotating to a new one. For a `supplied` platform you must pass the secret from that platform's own console, and webhookSecret in the response is null.
+ * @summary Create a channel
+ */
+export const createChannel = async (createChannelRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateChannelUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createChannelRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetChannelUrl = (channel) => {
+    return `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}`;
+};
+/**
+ * @summary Get a channel
+ */
+export const getChannel = async (channel, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetChannelUrl(channel), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUpdateChannelUrl = (channel) => {
+    return `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}`;
+};
+/**
+ * Only the fields present are changed. senderPolicy and allowFrom go together, and senderPolicy decides whether they are replaced. For platforms held open by a long-lived connection the change applies once that connection is rebuilt; for webhook platforms it applies at once.
+ * @summary Update a channel
+ */
+export const updateChannel = async (channel, updateChannelRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getUpdateChannelUrl(channel), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(updateChannelRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteChannelUrl = (channel) => {
+    return `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}`;
+};
+/**
+ * The channel stops accepting inbound messages and every binding on it stops working. This operation remains available while the project is suspended or being cleaned up.
+ * @summary Delete a channel
+ */
+export const deleteChannel = async (channel, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteChannelUrl(channel), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateBindingCodeUrl = (channel) => {
+    return `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}/binding-codes`;
+};
+/**
+ * Produces a single-use code to hand to the person being bound. They send that code to the assistant from their own account on that platform, which completes the binding. A binding can only be established this way, by the person themselves — a platform account cannot be named directly. Codes expire and have to be reissued.
+ * @summary Issue a binding code
+ */
+export const createBindingCode = async (channel, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCreateBindingCodeUrl(channel), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListChannelRejectionsUrl = (channel, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}/rejections?${stringifiedParams}`
+        : `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}/rejections`;
+};
+/**
+ * For diagnosing "I sent a message and the assistant never answered". Returns the inbound messages this channel rejected most recently, newest first, each with its reason. The most common reason is that the sender is not bound yet.
+ * @summary List recently rejected inbound messages
+ */
+export const listChannelRejections = async (channel, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListChannelRejectionsUrl(channel, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRotateChannelSecretUrl = (channel) => {
+    return `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}/secret`;
+};
+/**
+ * Replaces the webhook secret. The old one stops working immediately and the channel drops back to awaiting confirmation from the platform. Which side owns the secret is decided by the platform; see secretSource on list-platforms. For a `generated` platform, send no body — the new secret is returned in this response only and cannot be retrieved again. For a `supplied` platform you must pass the new secret from that platform's own console.
+ * @summary Rotate the webhook secret
+ */
+export const rotateChannelSecret = async (channel, rotateSecretRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRotateChannelSecretUrl(channel), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(rotateSecretRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCheckSenderUrl = (channel, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}/sender-check?${stringifiedParams}`
+        : `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}/sender-check`;
+};
+/**
+ * For checking a sender policy after changing it. Sends nothing and changes nothing: it runs exactly the same decision a real inbound message goes through, and says which rule produced the answer. The binding-code rule cannot be tested this way — whether something is a binding code depends on what the sender actually wrote.
+ * @summary Test whether a sender would be let through
+ */
+export const checkSender = async (channel, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCheckSenderUrl(channel, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getBeginWeixinLoginUrl = (channel) => {
+    return `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}/weixin-logins`;
+};
+/**
+ * A personal WeChat channel can only send and receive once its owner has signed in by scanning a QR code. This returns that code; poll `GET /v1/weixin-logins/{login}` for progress, and when the status asks for a verification code, submit it with `POST /v1/weixin-logins/{login}/verify-code`.
+ * @summary Begin a WeChat QR login
+ */
+export const beginWeixinLogin = async (channel, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getBeginWeixinLoginUrl(channel), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListPlatformsUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/platforms`;
+};
+/**
+ * The instant messaging platforms that can currently be connected, along with the flow and the credential fields each one needs. The create-channel form is driven entirely by this response: setupMethod decides between a credential form and a QR flow, credentialFields is what to ask for, and secretSource decides whether there is a webhook secret field at all.
+ * @summary List platforms that can be connected
+ */
+export const listPlatforms = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListPlatformsUrl(), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetWeixinLoginUrl = (login) => {
+    return `https://assistant.leaflow.cloud/api/v1/weixin-logins/${encodeURIComponent(String(login))}`;
+};
+/**
+ * Poll this until the status is success or failure. When the status asks for a verification code, submit it with the verification-code operation.
+ * @summary Get the state of a QR login
+ */
+export const getWeixinLogin = async (login, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetWeixinLoginUrl(login), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getSubmitWeixinVerifyCodeUrl = (login) => {
+    return `https://assistant.leaflow.cloud/api/v1/weixin-logins/${encodeURIComponent(String(login))}/verify-code`;
+};
+/**
+ * For when WeChat asks for an SMS or device code after the scan. The person who started the login gets that code on their own phone.
+ * @summary Submit a login verification code
+ */
+export const submitWeixinVerifyCode = async (login, verifyCodeRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getSubmitWeixinVerifyCodeUrl(login), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(verifyCodeRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getSubmitDynamicCallResultUrl = (call) => {
+    return `https://assistant.leaflow.cloud/api/v1/dynamic-calls/${encodeURIComponent(String(call))}/result`;
+};
+/**
+ * The assistant asks the client to run an action by adding a tool call to the conversation
+ * with the namespace `dynamic`; the client acts when that entry turns in_progress and reports
+ * back here.
+ *
+ * The first result is the one that counts. A later one is refused rather than replacing it.
+ * @summary Report what an action produced
+ */
+export const submitDynamicCallResult = async (call, dynamicCallResultRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getSubmitDynamicCallResultUrl(call), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(dynamicCallResultRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListFoldersUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/folders`;
+};
+/**
+ * The current account's folders in this project, oldest first. That order is fixed and does not react to what happens inside a folder: a folder is a place on the screen, and a place that moves whenever something is put into it is not one anybody can aim at. Not paginated — there is a cap on how many there can be, and all of them come back at once.
+ * @summary List folders
+ */
+export const listFolders = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListFoldersUrl(), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateFolderUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/folders`;
+};
+/**
+ * A folder groups conversations in the sidebar and does nothing else. The assistant is never told which folder a conversation is in, and a conversation behaves exactly the same inside one as outside: no shared instructions, no shared files, no shared memory.
+ *
+ * Names are unique within an account's folders in this project, because the only way to aim at a folder is to read its name.
+ * @summary Create a folder
+ */
+export const createFolder = async (createFolderRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateFolderUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createFolderRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetFolderUrl = (folder) => {
+    return `https://assistant.leaflow.cloud/api/v1/folders/${encodeURIComponent(String(folder))}`;
+};
+/**
+ * The list returns every folder at once, so this is for the case the list does not cover: a page opened straight at a folder, holding nothing but the id from the address bar. Its conversations are a separate request — `GET /api/v1/threads?folder=<id>`.
+ * @summary Fetch one folder
+ */
+export const getFolder = async (folder, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetFolderUrl(folder), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUpdateFolderUrl = (folder) => {
+    return `https://assistant.leaflow.cloud/api/v1/folders/${encodeURIComponent(String(folder))}`;
+};
+/**
+ * The conversations in it are untouched, and none of them move in the list — a folder's name is not part of what any conversation is about.
+ * @summary Rename a folder
+ */
+export const updateFolder = async (folder, updateFolderRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getUpdateFolderUrl(folder), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(updateFolderRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteFolderUrl = (folder) => {
+    return `https://assistant.leaflow.cloud/api/v1/folders/${encodeURIComponent(String(folder))}`;
+};
+/**
+ * The conversations inside are **not** deleted. They leave the folder and go back to the ungrouped list, where they can be filed again. Emptying a shelf is not the same as throwing out what was on it, and deleting a conversation is a different request.
+ *
+ * Idempotent: deleting a folder that is already gone succeeds and changes nothing.
+ * @summary Delete a folder
+ */
+export const deleteFolder = async (folder, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteFolderUrl(folder), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListMemoriesUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/memories`;
+};
+/**
+ * Facts the assistant has written down for the current account in this project. They appear at the start of every later conversation. Members of the same project each have their own, and this returns only the current account's. Not paginated: there is a cap on how many there can be, and all of them come back at once.
+ * @summary List what the assistant remembers
+ */
+export const listMemories = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListMemoriesUrl(), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteMemoryUrl = (memory) => {
+    return `https://assistant.leaflow.cloud/api/v1/memories/${encodeURIComponent(String(memory))}`;
+};
+/**
+ * The assistant stops remembering this. It takes effect at once, so the next conversation will not carry it. The assistant may well learn the same thing again.
+ * @summary Delete one memory
+ */
+export const deleteMemory = async (memory, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteMemoryUrl(memory), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListSkillsUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/skills`;
+};
+/**
+ * Everything the assistant can reach in this project, including the ones that are turned off —
+ * an entry that disappeared once it was switched off could not be switched back on.
+ *
+ * `origin` says whether a skill can be edited here. Skills belonging to the project are
+ * visible to everyone in it, whoever wrote them.
+ * @summary List the skills this project can use
+ */
+export const listSkills = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListSkillsUrl(), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getPutSkillUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/skills`;
+};
+/**
+ * Creates it, or replaces the project's skill of that name. The whole package goes in each
+ * time: files left out of a write are removed, so the stored skill is what was sent and not
+ * what accumulated.
+ *
+ * A project skill takes precedence over a built-in one of the same name for this project only.
+ * The built-in is untouched and reappears if the project's is deleted.
+ * @summary Write a skill for this project
+ */
+export const putSkill = async (skillRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getPutSkillUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(skillRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetSkillUrl = (skill) => {
+    return `https://assistant.leaflow.cloud/api/v1/skills/${encodeURIComponent(String(skill))}`;
+};
+/**
+ * Works for built-in skills too; they simply cannot be written.
+ * @summary Read one skill, with its files
+ */
+export const getSkill = async (skill, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetSkillUrl(skill), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getSetSkillEnabledUrl = (skill) => {
+    return `https://assistant.leaflow.cloud/api/v1/skills/${encodeURIComponent(String(skill))}`;
+};
+/**
+ * Separate from writing it, because this is the frequent one: a skill that is off costs
+ * nothing and stays where it is.
+ *
+ * Only skills belonging to the project can be switched. To keep a built-in one out of the
+ * way, write a project skill of the same name and turn that off.
+ * @summary Turn a skill on or off
+ */
+export const setSkillEnabled = async (skill, skillEnabledRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getSetSkillEnabledUrl(skill), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(skillEnabledRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteSkillUrl = (skill) => {
+    return `https://assistant.leaflow.cloud/api/v1/skills/${encodeURIComponent(String(skill))}`;
+};
+/**
+ * A built-in skill of the same name, if there was one, becomes visible again.
+ * @summary Delete this project's skill
+ */
+export const deleteSkill = async (skill, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteSkillUrl(skill), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListThreadsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://assistant.leaflow.cloud/api/v1/threads?${stringifiedParams}`
+        : `https://assistant.leaflow.cloud/api/v1/threads`;
+};
+/**
+ * Ordered by most recent activity, limited to the current account's conversations in the current project. `archived` selects between two sets rather than widening one: archived conversations are absent from the default list, and turning the flag on shows those instead.
+ *
+ * Pass the returned nextCursor as cursor; omit cursor on the first page. Continue with the same q, archived and folder filters. The cursor marks a position in the activity order, so changing filters between pages does not continue the same list.
+ * @summary List conversations
+ */
+export const listThreads = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListThreadsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateThreadUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/threads`;
+};
+/**
+ * Omit preferredModelId or set it to null to follow the platform default. A non-null preference is accepted only while model selection is enabled; otherwise the request fails with 403 and code MODEL_SELECTION_DISABLED.
+ *
+ * A well-formed preference for a Canopy model that is no longer allowed or has been retired or removed is retained and uses the default when a turn starts. This also handles a catalogue change between displaying the selector and submitting the choice. Creating a conversation does not contact a model provider and remains possible when generation is unavailable.
+ * @summary Create a conversation
+ */
+export const createThread = async (createThreadRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateThreadUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createThreadRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetThreadUrl = (thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}`;
+};
+/**
+ * The complete current state of a conversation, for the first render. Its `stream` gives the address and admission ticket for live output, and what that stream pushes are incremental edits to this same document, so the same rendering logic applies.
+ * @summary Fetch the conversation document
+ */
+export const getThread = async (thread, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetThreadUrl(thread), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUpdateThreadUrl = (thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}`;
+};
+/**
+ * Changes the title, folder, approval mode, model preference, and whether the conversation is archived. Approval and model preference changes take effect from the next turn; a turn already running keeps the settings it started with.
+ *
+ * Omit preferredModelId to leave the preference unchanged, or set it to null to follow the platform default. A non-null preference is accepted only while model selection is enabled; otherwise the whole request fails with 403 and code MODEL_SELECTION_DISABLED and none of its fields are changed. Clearing a preference remains allowed while selection is disabled. A well-formed preference for a disallowed, retired or removed Canopy model is retained and falls back to the default when used.
+ *
+ * Model switching is allowed on an existing conversation, including while a turn is generating or waiting for approval or an answer. The response immediately returns the saved preferredModelId, while model continues to identify the running turn's effective model until it finishes. Messages queued into that running turn also keep its captured model choices. The next turn uses the latest saved preference.
+ *
+ * Changing the preference does not create a new conversation, start a turn, call a model provider, clear the transcript, or rewrite historical model attribution. Before the next turn sends its first request to the selected model, the service checks that model's input capabilities and usable context budget. A switch to a smaller window may require compaction under the compaction policy above; saving the preference alone does not establish that the conversation fits.
+ *
+ * Archiving makes a conversation read-only: it stays in the list under "archived", stays readable, and the assistant can still find it when it searches past conversations — it just takes no new input. Unarchive it to continue. Archiving fails while a turn is running; stop it first.
+ * @summary Update conversation settings
+ */
+export const updateThread = async (thread, updateThreadRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getUpdateThreadUrl(thread), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(updateThreadRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteThreadUrl = (thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}`;
+};
+/**
+ * Removes the conversation from every list and makes it unreachable by id. The assistant can no longer find it either — neither by searching past conversations nor by reading one back.
+ *
+ * Deleting is not the same as archiving, and the two are not degrees of the same thing. An archived conversation is still there and still readable, it just takes no new input; a deleted one is gone from view. Archiving can be undone; this cannot.
+ *
+ * What survives is the record itself, because a conversation with this assistant is an account of what was done to real infrastructure — which machine was changed, which disk was removed. That record is kept even though nobody can reach it here.
+ *
+ * Fails while a turn is running: stop it first. Deleting an already deleted conversation succeeds and changes nothing.
+ * @summary Delete a conversation
+ */
+export const deleteThread = async (thread, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteThreadUrl(thread), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDecideApprovalUrl = (thread, batch) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/approvals/${encodeURIComponent(String(batch))}`;
+};
+/**
+ * The batch id comes from the conversation document's `wait`. This is idempotent: submitting the same batch again neither changes a decision already in effect nor reports an error. Returns 404 when the batch does not belong to that conversation.
+ * @summary Approve or decline a batch of tool calls
+ */
+export const decideApproval = async (thread, batch, decideRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getDecideApprovalUrl(thread, batch), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(decideRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListEarlierItemsUrl = (thread, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/earlier?${stringifiedParams}`
+        : `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/earlier`;
+};
+/**
+ * The first render only carries the latest stretch of a conversation; anything above it is fetched here, one stretch at a time. Pass the document's earlier.before as `before`; the `earlier` in the response is the cursor for the stretch above that, and null means the top has been reached. The entries have the same shape and the same order (oldest first) as `items` in the document, so they can be prepended as they are.
+ * @summary Fetch earlier parts of a conversation
+ */
+export const listEarlierItems = async (thread, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListEarlierItemsUrl(thread, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getInterruptThreadUrl = (thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/interrupt`;
+};
+/**
+ * Calling this on a conversation with no running turn also returns 204 rather than an error — the user pressing stop races with the turn finishing on its own, and both outcomes are the same. This operation remains available while the project is suspended or being cleaned up.
+ * @summary Interrupt a running turn
+ */
+export const interruptThread = async (thread, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getInterruptThreadUrl(thread), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getSendMessageUrl = (thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/messages`;
+};
+/**
+ * Returns a turnId immediately without waiting for execution — a turn can run for tens of minutes. Progress arrives on the live stream the conversation document's `stream` points at, not in this response. Sending while the assistant is still working is allowed: the message is put in line and `queued` comes back true, to be read at the next step of the turn already running — so the editor should stay open rather than blocking on a busy conversation.
+ * @summary Send a message and start a turn
+ */
+export const sendMessage = async (thread, sendMessageRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getSendMessageUrl(thread), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(sendMessageRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getAnswerQuestionUrl = (thread, item) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/questions/${encodeURIComponent(String(item))}`;
+};
+/**
+ * The question id comes from the conversation document's `wait`. An already-answered question also returns 204 — another tab may have submitted first, or the auto-answer window may have expired, and in both cases the turn has already continued with an answer.
+ * @summary Answer the assistant's questions
+ */
+export const answerQuestion = async (thread, item, answerRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getAnswerQuestionUrl(thread, item), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(answerRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getMarkThreadReadUrl = (thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/read`;
+};
+/**
+ * @summary Mark a conversation as read
+ */
+export const markThreadRead = async (thread, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getMarkThreadReadUrl(thread), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRevertThreadUrl = (thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/revert`;
+};
+/**
+ * Reverts the entry at `ordinal` and everything after it. Reverted entries stay in the transcript marked `reverted`, and ordinals are not renumbered. Returns how many were actually reverted.
+ * @summary Revert from a given point
+ */
+export const revertThread = async (thread, revertRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRevertThreadUrl(thread), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(revertRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};