@leaflow/sdk 0.0.0-dev.358.gbb34078 → 0.0.0-dev.361.gefdc428

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

@@ -1,44 +1,794 @@
-export const getListModelsUrl = () => {
-    return `https://assistant.leaflow.cloud/api/v1/models`;
+export const getCreateThreadUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/threads`;
+};
+/**
+ * Creates a conversation and, when `message` is given, sends it as the first message in the same
+ * request, so starting a task is one round trip.
+ *
+ * The model is chosen in this order: `modelId` from the request, the caller's default from
+ * /api/v1/settings, then the first model in the Canopy catalogue that can run an agent. Fails with
+ * 422 and code MODEL_UNAVAILABLE when the chosen model cannot run an agent, and with 422 and code
+ * REASONING_UNSUPPORTED when `reasoningEffort` is given for a model without reasoning.
+ *
+ * Without `message`, creating a conversation does not contact a model provider.
+ * @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 getSearchThreadsUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/threads`;
+};
+/**
+ * Lists the caller's conversations in this project with their state, progress and usage. The
+ * criteria travel in the request body. Keep the same criteria when following `nextCursor`.
+ *
+ * Subagents are conversations too. They are excluded unless `parentId` or `role` asks for them.
+ * `ids` reads a bounded batch, including subagents and archived conversations, and cannot be
+ * combined with a cursor.
+ *
+ * Counts over everything the criteria match cost more than the page itself; ask for them with
+ * `include: [counts]`, typically on the first page only.
+ * @summary Search conversations
+ */
+export const searchThreads = async (searchThreadsRequestBody, 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)(getSearchThreadsUrl(), {
+        ...options,
+        method: "QUERY",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(searchThreadsRequestBody),
+    });
+    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 conversation's state: model, reasoning effort, approval mode, what it is doing now, its
+ * plan, what it is waiting for, context usage and token usage. The transcript is read separately
+ * from /items.
+ * @summary Get a conversation
+ */
+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, model, reasoning effort, approval mode, or whether the conversation is
+ * archived. Omitted fields stay as they are.
+ *
+ * Model, reasoning and approval changes apply to the next model request; a request already in
+ * flight keeps its settings. A model that cannot run an agent fails with 422 and code
+ * MODEL_UNAVAILABLE. Switching to a model without reasoning clears `reasoningEffort`.
+ *
+ * Archiving makes the conversation read-only and fails with 409 and code THREAD_RUNNING while a
+ * turn is running.
+ * @summary Update a conversation
+ */
+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 and its subagents from every list and makes them unreachable by id,
+ * including for the assistant. Deleting cannot be undone; archive instead to keep it readable.
+ *
+ * Fails with 409 and code THREAD_RUNNING while a turn is running. Deleting an already deleted
+ * conversation succeeds.
+ * @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 getInterruptThreadUrl = (thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/interrupt`;
+};
+/**
+ * Stops this conversation's running turn and discards its queued messages. Subagents keep
+ * running; stop them through their own conversations.
+ *
+ * Succeeds when nothing is running, because pressing stop races with the turn finishing on its
+ * own. Available while the project is suspended or being cleaned up.
+ * @summary Stop the 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 getResumeThreadUrl = (thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/resume`;
+};
+/**
+ * Starts a new turn that continues from where the conversation stopped, for example after it
+ * was interrupted or failed. An optional message is added first.
+ *
+ * Fails with 409 and code THREAD_RUNNING while a turn is running.
+ * @summary Resume a stopped conversation
+ */
+export const resumeThread = async (thread, resumeThreadRequestBody, 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)(getResumeThreadUrl(thread), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(resumeThreadRequestBody),
+    });
+    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 getCompactThreadUrl = (thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/compact`;
+};
+/**
+ * Starts a compaction turn that summarizes the history before the latest user message, the same
+ * way the service does automatically when the context window fills up. The result appears in the
+ * transcript as a `compaction` item and the turn reports its own token usage.
+ *
+ * Fails with 409 and code THREAD_RUNNING while a turn is running, and with 409 and code
+ * NOTHING_TO_COMPACT when there is no history to summarize.
+ * @summary Compact the conversation now
+ */
+export const compactThread = async (thread, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCompactThreadUrl(thread), {
+        ...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 getRevertThreadUrl = (thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/revert`;
+};
+/**
+ * Reverts the item at `ordinal` and everything after it. Reverted items stay in the transcript
+ * marked `reverted` and are left out of later model requests; ordinals are not renumbered.
+ * Executed tools and external changes are not undone. Returns how many items were 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 };
+};
+export const getMarkThreadReadUrl = (thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/read`;
+};
+/**
+ * Clears `unread` until the assistant replies again.
+ * @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 getListThreadItemsUrl = (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))}/items?${stringifiedParams}`
+        : `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/items`;
+};
+/**
+ * A window of the conversation's transcript, oldest first: messages, reasoning, tool calls and
+ * compaction markers. A window holds whole turns, so a turn's messages and tool calls arrive
+ * together; a single turn larger than the size limit is split across windows.
+ *
+ * Without a position the window ends at the latest item. `before` reads the window above an
+ * ordinal and `after` the window below it; pass `startOrdinal` and `endOrdinal` from the response.
+ * `around` opens a window that contains an ordinal, for jumping to a turn from list-thread-turns or
+ * to a search result.
+ *
+ * Long reasoning and tool arguments are cut to a preview and marked `truncated`; read the item for
+ * all of it. Messages are never cut.
+ *
+ * When the window reaches the end, `queued` holds the messages waiting for the assistant and
+ * `streamCursor` is set: subscribe to `thread:{id}` on /api/v1/realtime from it to follow what is
+ * written next.
+ * @summary List transcript items
+ */
+export const listThreadItems = async (thread, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListThreadItemsUrl(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 getGetThreadItemUrl = (thread, item) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/items/${encodeURIComponent(String(item))}`;
+};
+/**
+ * One item in full, including what list-thread-items cut from it.
+ * @summary Get a transcript item
+ */
+export const getThreadItem = async (thread, item, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetThreadItemUrl(thread, item), {
+        ...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 getSendMessageUrl = (thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/messages`;
+};
+/**
+ * Starts a turn and returns at once; a turn can run for tens of minutes and its progress arrives
+ * on /api/v1/realtime. Sending while the assistant is working is allowed: the message is queued
+ * and read at the next step of the running turn, and `queued` is true.
+ *
+ * Fails with 409 and code THREAD_ARCHIVED for an archived conversation.
+ * @summary Send a message
+ */
+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 getDecideToolCallsUrl = (thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/approvals`;
+};
+/**
+ * Decides the tool calls the conversation is waiting on, listed in `pendingAction.itemIds`. One
+ * decision applies to the whole batch, so `itemIds` must name exactly the calls awaiting approval.
+ *
+ * Repeating a decision that is already in effect succeeds. Fails with 409 and code
+ * APPROVAL_MISMATCH when `itemIds` is not the current batch, for example because another tab
+ * decided first and the assistant has moved on.
+ * @summary Approve or decline tool calls
+ */
+export const decideToolCalls = async (thread, decideToolCallsRequestBody, 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)(getDecideToolCallsUrl(thread), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(decideToolCallsRequestBody),
+    });
+    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 getAnswerQuestionUrl = (thread, item) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/items/${encodeURIComponent(String(item))}/answer`;
+};
+/**
+ * Answers an `ask` tool call. Its questions are in the item's `questions`. An item that is already
+ * answered also succeeds: another tab may have answered first, or the auto-answer window may have
+ * passed, and either way the turn has continued.
+ * @summary Answer the assistant's questions
+ */
+export const answerQuestion = async (thread, item, answerQuestionRequestBody, 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(answerQuestionRequestBody),
+    });
+    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 getSubmitToolResultUrl = (thread, item) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/items/${encodeURIComponent(String(item))}/result`;
+};
+/**
+ * The assistant asks the client to run one of the actions it declared by writing a tool call with
+ * the namespace `client`; the client runs it when the item turns in_progress and reports here.
+ *
+ * The first result counts. A later one fails with 409 and code RESULT_ALREADY_SUBMITTED.
+ * @summary Report what a client tool produced
+ */
+export const submitToolResult = async (thread, item, toolResultRequestBody, 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)(getSubmitToolResultUrl(thread, item), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(toolResultRequestBody),
+    });
+    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 getListThreadTurnsUrl = (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))}/turns?${stringifiedParams}`
+        : `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/turns`;
+};
+/**
+ * The conversation's turns, newest first, each with the model and reasoning effort it ran with,
+ * how long it took and the tokens it used. Cache hit rate is `cachedInputTokens / inputTokens`.
+ *
+ * Each turn names the ordinals it wrote and the message that started it, so a client can draw a
+ * timeline from this list and open a turn with list-thread-items `around`.
+ *
+ * `ids` reads the turns behind a page of transcript items in one request and cannot be combined
+ * with a cursor.
+ * @summary List turns
+ */
+export const listThreadTurns = async (thread, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListThreadTurnsUrl(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 getListCommandsUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/commands`;
+};
+/**
+ * The slash commands a person can type in a conversation, such as /status or /compact. The same
+ * commands work in the console and in chat apps, so a client builds its command menu from this
+ * list.
+ * @summary List commands
+ */
+export const listCommands = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListCommandsUrl(), {
+        ...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 getRunCommandUrl = (thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/commands`;
+};
+/**
+ * Runs a slash command against the conversation. Commands act directly and never reach the model.
+ * The result carries a plain-text `message`, which is what a chat app shows, and structured fields
+ * for clients that render more, such as `status` for /status.
+ *
+ * /new is carried out by the client, which opens an empty conversation, and fails here with 422
+ * and code COMMAND_CLIENT_ONLY. Fails with 404 and code COMMAND_NOT_FOUND for an unknown command,
+ * and with 422 and code COMMAND_ARGUMENTS_INVALID when the arguments do not fit.
+ * @summary Run a command
+ */
+export const runCommand = async (thread, runCommandRequestBody, 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)(getRunCommandUrl(thread), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(runCommandRequestBody),
+    });
+    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 getListFoldersUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/folders`;
+};
+/**
+ * The caller's folders in this project in their own order, inbox first. Every conversation is in
+ * exactly one folder; the inbox holds the ones nobody filed. Not paginated: the number of folders
+ * is capped 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 on the board and does nothing else: the assistant is never told
+ * which folder a conversation is in. New folders go after the existing ones.
+ *
+ * Names are unique among the caller's folders in this project; a duplicate fails with 409 and
+ * code FOLDER_EXISTS.
+ * @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))}`;
+};
+/**
+ * Its conversations are read with search-threads and `folderId`.
+ * @summary Get a 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 inbox cannot be renamed and fails with 409 and code INBOX_READ_ONLY.
+ * @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 move to the end of the inbox. The inbox cannot
+ * be deleted and fails with 409 and code INBOX_READ_ONLY. Deleting a folder that is already gone
+ * succeeds.
+ * @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 getMoveFolderUrl = (folder) => {
+    return `https://assistant.leaflow.cloud/api/v1/folders/${encodeURIComponent(String(folder))}/move`;
 };
 /**
- * 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
+ * Places the folder before `beforeFolderId`, or last when it is null. The inbox stays first.
+ * Fails with 409 and code ORDER_CHANGED when `expectedVersion` is stale; read the folders again
+ * and retry.
+ * @summary Reorder a folder
  */
-export const listModels = async (options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getListModelsUrl(), {
+export const moveFolder = async (folder, moveFolderRequestBody, 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)(getMoveFolderUrl(folder), {
         ...options,
-        method: "GET",
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(moveFolderRequestBody),
     });
     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));
+export const getPlaceThreadUrl = (folder, thread) => {
+    return `https://assistant.leaflow.cloud/api/v1/folders/${encodeURIComponent(String(folder))}/threads/${encodeURIComponent(String(thread))}`;
+};
+/**
+ * Puts the conversation into this folder at the given position, moving it out of the folder it
+ * was in. Give `beforeThreadId` or `afterThreadId` to place it next to a conversation of this
+ * folder; with neither it goes last. Moving does not change the conversation's activity time.
+ *
+ * Subagents are not filed and fail with 409 and code SUBAGENT_NOT_FILED. Fails with 409 and code
+ * ORDER_CHANGED when `expectedVersion` is stale.
+ * @summary Place a conversation in a folder
+ */
+export const placeThread = async (folder, thread, placeThreadRequestBody, 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)(getPlaceThreadUrl(folder, thread), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(placeThreadRequestBody),
     });
-    const stringifiedParams = normalizedParams.toString();
-    return stringifiedParams.length > 0
-        ? `https://assistant.leaflow.cloud/api/v1/attachments?${stringifiedParams}`
-        : `https://assistant.leaflow.cloud/api/v1/attachments`;
+    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 getCreateTaskUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/tasks`;
 };
 /**
- * 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.
+ * A task does something on a trigger and reports to a conversation. Its action either sends a
+ * prompt to the conversation, which starts a turn there, or runs a command on an instance and
+ * sends the result to the conversation when it ends.
  *
- * 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.
+ * `trigger.type` `now` runs once immediately; `at` runs once at `runAt`; `interval` repeats every
+ * `intervalSeconds` from `anchorAt`; `cron` repeats on a cron expression in `timezone`. Each
+ * execution is a run, listed under /runs.
  *
- * 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
+ * Fails with 404 when the conversation does not exist and with 409 and code THREAD_ARCHIVED when
+ * it is archived.
+ * @summary Create a task
  */
-export const uploadAttachment = async (uploadAttachmentBody, params, options, fetchFn) => {
+export const createTask = async (createTaskRequestBody, options, fetchFn) => {
     const getHeaders = (h) => {
         if (!h)
             return {};
@@ -54,52 +804,57 @@ export const uploadAttachment = async (uploadAttachmentBody, params, options, fe
         }
         return headers;
     };
-    const res = await (fetchFn ?? fetch)(getUploadAttachmentUrl(params), {
+    const res = await (fetchFn ?? fetch)(getCreateTaskUrl(), {
         ...options,
         method: "POST",
-        headers: { "Content-Type": "*/*", ...getHeaders(options?.headers) },
-        body: uploadAttachmentBody,
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createTaskRequestBody),
     });
     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))}`;
+export const getSearchTasksUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/tasks`;
 };
 /**
- * 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
+ * The caller's tasks in this project, most recently created first.
+ * @summary Search tasks
  */
-export const downloadAttachment = async (attachment, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getDownloadAttachmentUrl(attachment), {
+export const searchTasks = async (searchTasksRequestBody, 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)(getSearchTasksUrl(), {
         ...options,
-        method: "GET",
+        method: "QUERY",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(searchTasksRequestBody),
     });
-    const body = [204, 205, 304].includes(res.status) ? null : await res.blob();
-    const data = body;
+    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 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`;
+export const getGetTaskUrl = (task) => {
+    return `https://assistant.leaflow.cloud/api/v1/tasks/${encodeURIComponent(String(task))}`;
 };
 /**
- * Filter by channelId to show, per channel, who is bound to it.
- * @summary List bindings
+ * @summary Get a task
  */
-export const listBindings = async (params, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getListBindingsUrl(params), {
+export const getTask = async (task, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetTaskUrl(task), {
         ...options,
         method: "GET",
     });
@@ -107,29 +862,49 @@ export const listBindings = async (params, options, fetchFn) => {
     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))}`;
+export const getUpdateTaskUrl = (task) => {
+    return `https://assistant.leaflow.cloud/api/v1/tasks/${encodeURIComponent(String(task))}`;
 };
 /**
- * @summary Get a binding
+ * Changes the name, trigger or action. Omitted fields stay as they are; `trigger` and `action`
+ * are replaced as a whole. A run already in progress keeps the settings it started with.
+ * @summary Update a task
  */
-export const getBinding = async (binding, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getGetBindingUrl(binding), {
+export const updateTask = async (task, updateTaskRequestBody, 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)(getUpdateTaskUrl(task), {
         ...options,
-        method: "GET",
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(updateTaskRequestBody),
     });
     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))}`;
+export const getDeleteTaskUrl = (task) => {
+    return `https://assistant.leaflow.cloud/api/v1/tasks/${encodeURIComponent(String(task))}`;
 };
 /**
- * @summary Remove a binding
+ * Cancels a run in progress and removes the task. Its runs stay readable in the conversation's transcript.
+ * @summary Delete a task
  */
-export const deleteBinding = async (binding, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getDeleteBindingUrl(binding), {
+export const deleteTask = async (task, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteTaskUrl(task), {
         ...options,
         method: "DELETE",
     });
@@ -137,7 +912,72 @@ export const deleteBinding = async (binding, options, fetchFn) => {
     const data = body ? JSON.parse(body) : undefined;
     return { data, status: res.status, headers: res.headers };
 };
-export const getListChannelsUrl = (params) => {
+export const getRunTaskUrl = (task) => {
+    return `https://assistant.leaflow.cloud/api/v1/tasks/${encodeURIComponent(String(task))}/run`;
+};
+/**
+ * Starts a run immediately, outside its trigger. Fails with 409 and code TASK_RUNNING when a run
+ * is already in progress and the overlap policy is `skip`.
+ * @summary Run a task now
+ */
+export const runTask = async (task, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getRunTaskUrl(task), {
+        ...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 getPauseTaskUrl = (task) => {
+    return `https://assistant.leaflow.cloud/api/v1/tasks/${encodeURIComponent(String(task))}/pause`;
+};
+/**
+ * Stops future runs from its trigger. A run in progress continues. Pausing a paused task succeeds.
+ * @summary Pause a task
+ */
+export const pauseTask = async (task, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getPauseTaskUrl(task), {
+        ...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 getResumeTaskUrl = (task) => {
+    return `https://assistant.leaflow.cloud/api/v1/tasks/${encodeURIComponent(String(task))}/resume`;
+};
+/**
+ * Lets its trigger start runs again. Missed runs within `catchupSeconds` are started. Resuming an active task succeeds.
+ * @summary Resume a task
+ */
+export const resumeTask = async (task, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getResumeTaskUrl(task), {
+        ...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 getCancelTaskRunUrl = (task) => {
+    return `https://assistant.leaflow.cloud/api/v1/tasks/${encodeURIComponent(String(task))}/cancel`;
+};
+/**
+ * Stops the run in progress. The conversation is told the run was cancelled. Succeeds when nothing is running.
+ * @summary Cancel the running run
+ */
+export const cancelTaskRun = async (task, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCancelTaskRunUrl(task), {
+        ...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 getListTaskRunsUrl = (task, params) => {
     const normalizedParams = new URLSearchParams();
     Object.entries(params || {}).forEach(([key, value]) => {
         if (value !== undefined) {
@@ -146,14 +986,15 @@ export const getListChannelsUrl = (params) => {
     });
     const stringifiedParams = normalizedParams.toString();
     return stringifiedParams.length > 0
-        ? `https://assistant.leaflow.cloud/api/v1/channels?${stringifiedParams}`
-        : `https://assistant.leaflow.cloud/api/v1/channels`;
+        ? `https://assistant.leaflow.cloud/api/v1/tasks/${encodeURIComponent(String(task))}/runs?${stringifiedParams}`
+        : `https://assistant.leaflow.cloud/api/v1/tasks/${encodeURIComponent(String(task))}/runs`;
 };
 /**
- * @summary List channels
+ * Newest first, without output; read a run with get-task-run for it.
+ * @summary List a task's runs
  */
-export const listChannels = async (params, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getListChannelsUrl(params), {
+export const listTaskRuns = async (task, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListTaskRunsUrl(task, params), {
         ...options,
         method: "GET",
     });
@@ -161,47 +1002,33 @@ export const listChannels = async (params, options, fetchFn) => {
     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`;
+export const getGetTaskRunUrl = (task, run) => {
+    return `https://assistant.leaflow.cloud/api/v1/tasks/${encodeURIComponent(String(task))}/runs/${encodeURIComponent(String(run))}`;
 };
 /**
- * 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
+ * One run with the end of its output.
+ * @summary Get a task run
  */
-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(), {
+export const getTaskRun = async (task, run, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetTaskRunUrl(task, run), {
         ...options,
-        method: "POST",
-        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
-        body: JSON.stringify(createChannelRequestBody),
+        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 getGetChannelUrl = (channel) => {
-    return `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}`;
+export const getGetSettingsUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/settings`;
 };
 /**
- * @summary Get a channel
+ * The caller's assistant settings in this project. `defaultModel` is what a new conversation uses
+ * when it names no model: the caller's choice, or the first model in the Canopy catalogue that can
+ * run an agent.
+ * @summary Get settings
  */
-export const getChannel = async (channel, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getGetChannelUrl(channel), {
+export const getSettings = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetSettingsUrl(), {
         ...options,
         method: "GET",
     });
@@ -209,14 +1036,18 @@ export const getChannel = async (channel, options, fetchFn) => {
     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))}`;
+export const getUpdateSettingsUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/settings`;
 };
 /**
- * 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
+ * Omitted fields stay as they are; null clears a choice so the catalogue default applies again.
+ * Existing conversations keep their models.
+ *
+ * Fails with 422 and code MODEL_UNAVAILABLE when the model cannot run an agent, and with 422 and
+ * code REASONING_UNSUPPORTED when a reasoning effort is set for a model without reasoning.
+ * @summary Update settings
  */
-export const updateChannel = async (channel, updateChannelRequestBody, options, fetchFn) => {
+export const updateSettings = async (updateSettingsRequestBody, options, fetchFn) => {
     const getHeaders = (h) => {
         if (!h)
             return {};
@@ -232,41 +1063,36 @@ export const updateChannel = async (channel, updateChannelRequestBody, options,
         }
         return headers;
     };
-    const res = await (fetchFn ?? fetch)(getUpdateChannelUrl(channel), {
+    const res = await (fetchFn ?? fetch)(getUpdateSettingsUrl(), {
         ...options,
         method: "PATCH",
         headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
-        body: JSON.stringify(updateChannelRequestBody),
+        body: JSON.stringify(updateSettingsRequestBody),
     });
     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`;
+export const getCreateRealtimeTicketUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/realtime/tickets`;
 };
 /**
- * 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
+ * Returns the address and a short-lived ticket for the realtime WebSocket. Open
+ * `{url}?ticket={ticket}`; the ticket stands in for the bearer token, which a browser cannot set
+ * on a WebSocket. One connection carries every subscription of a client.
+ *
+ * Messages are JSON text frames. The client sends `RealtimeClientMessage` and receives
+ * `RealtimeServerMessage`. Subscribe to `workspace` for every conversation, folder and task of the
+ * caller in this project, and to `thread:{id}` for the transcript of one conversation. A
+ * transcript subscription takes the `streamCursor` from list-thread-items and replays what was
+ * written after it; when the cursor is too old the server sends `resync` and the client reads the
+ * items again.
+ *
+ * Reconnect with a new ticket after the connection closes. Ping at least every 30 seconds.
+ * @summary Issue a realtime ticket
  */
-export const createBindingCode = async (channel, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getCreateBindingCodeUrl(channel), {
+export const createRealtimeTicket = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCreateRealtimeTicketUrl(), {
         ...options,
         method: "POST",
     });
@@ -274,7 +1100,7 @@ export const createBindingCode = async (channel, options, fetchFn) => {
     const data = body ? JSON.parse(body) : {};
     return { data, status: res.status, headers: res.headers };
 };
-export const getListChannelRejectionsUrl = (channel, params) => {
+export const getOpenRealtimeUrl = (params) => {
     const normalizedParams = new URLSearchParams();
     Object.entries(params || {}).forEach(([key, value]) => {
         if (value !== undefined) {
@@ -283,15 +1109,17 @@ export const getListChannelRejectionsUrl = (channel, params) => {
     });
     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`;
+        ? `https://assistant.leaflow.cloud/api/v1/realtime?${stringifiedParams}`
+        : `https://assistant.leaflow.cloud/api/v1/realtime`;
 };
 /**
- * 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), {
+ * Upgrades to a WebSocket. The ticket from create-realtime-ticket authenticates the connection;
+ * a missing, expired or foreign ticket closes it with code 4401. The 200 response documents the
+ * message a client receives on the socket; the endpoint never answers with a plain HTTP body.
+ * @summary Open the realtime WebSocket
+ */
+export const openRealtime = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getOpenRealtimeUrl(params), {
         ...options,
         method: "GET",
     });
@@ -299,14 +1127,27 @@ export const listChannelRejections = async (channel, params, options, fetchFn) =
     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`;
+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`;
 };
 /**
- * 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
+ * The body is the file bytes themselves, not multipart, one file per request. The type 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 `type` 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 rotateChannelSecret = async (channel, rotateSecretRequestBody, options, fetchFn) => {
+export const uploadAttachment = async (uploadAttachmentBody, params, options, fetchFn) => {
     const getHeaders = (h) => {
         if (!h)
             return {};
@@ -322,34 +1163,42 @@ export const rotateChannelSecret = async (channel, rotateSecretRequestBody, opti
         }
         return headers;
     };
-    const res = await (fetchFn ?? fetch)(getRotateChannelSecretUrl(channel), {
+    const res = await (fetchFn ?? fetch)(getUploadAttachmentUrl(params), {
         ...options,
         method: "POST",
-        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
-        body: JSON.stringify(rotateSecretRequestBody),
+        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 getCheckSenderUrl = (channel, params) => {
-    const normalizedParams = new URLSearchParams();
-    Object.entries(params || {}).forEach(([key, value]) => {
-        if (value !== undefined) {
-            normalizedParams.append(key, value === null ? "null" : String(value));
-        }
+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 `type` 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 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`;
+    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 getGetUploadConfigurationUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/upload-configuration`;
 };
 /**
- * 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
+ * @summary Get upload configuration
  */
-export const checkSender = async (channel, params, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getCheckSenderUrl(channel, params), {
+export const getUploadConfiguration = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetUploadConfigurationUrl(), {
         ...options,
         method: "GET",
     });
@@ -357,31 +1206,46 @@ export const checkSender = async (channel, params, options, fetchFn) => {
     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`;
+export const getCreateUploadUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/uploads`;
 };
 /**
- * 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
+ * @summary Create upload
  */
-export const beginWeixinLogin = async (channel, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getBeginWeixinLoginUrl(channel), {
+export const createUpload = async (createUploadRequestBody, 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)(getCreateUploadUrl(), {
         ...options,
         method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createUploadRequestBody),
     });
     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`;
+export const getListUploadsUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/uploads`;
 };
 /**
- * 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
+ * @summary List uploads
  */
-export const listPlatforms = async (options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getListPlatformsUrl(), {
+export const listUploads = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListUploadsUrl(), {
         ...options,
         method: "GET",
     });
@@ -389,15 +1253,14 @@ export const listPlatforms = async (options, fetchFn) => {
     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))}`;
+export const getGetUploadUrl = (upload) => {
+    return `https://assistant.leaflow.cloud/api/v1/uploads/${encodeURIComponent(String(upload))}`;
 };
 /**
- * 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
+ * @summary Get upload
  */
-export const getWeixinLogin = async (login, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getGetWeixinLoginUrl(login), {
+export const getUpload = async (upload, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetUploadUrl(upload), {
         ...options,
         method: "GET",
     });
@@ -405,14 +1268,13 @@ export const getWeixinLogin = async (login, options, fetchFn) => {
     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`;
+export const getUpdateUploadUrl = (upload) => {
+    return `https://assistant.leaflow.cloud/api/v1/uploads/${encodeURIComponent(String(upload))}`;
 };
 /**
- * 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
+ * @summary Update upload
  */
-export const submitWeixinVerifyCode = async (login, verifyCodeRequestBody, options, fetchFn) => {
+export const updateUpload = async (upload, updateUploadRequestBody, options, fetchFn) => {
     const getHeaders = (h) => {
         if (!h)
             return {};
@@ -428,79 +1290,53 @@ export const submitWeixinVerifyCode = async (login, verifyCodeRequestBody, optio
         }
         return headers;
     };
-    const res = await (fetchFn ?? fetch)(getSubmitWeixinVerifyCodeUrl(login), {
+    const res = await (fetchFn ?? fetch)(getUpdateUploadUrl(upload), {
         ...options,
-        method: "POST",
+        method: "PATCH",
         headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
-        body: JSON.stringify(verifyCodeRequestBody),
+        body: JSON.stringify(updateUploadRequestBody),
     });
     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`;
+export const getDeleteUploadUrl = (upload) => {
+    return `https://assistant.leaflow.cloud/api/v1/uploads/${encodeURIComponent(String(upload))}`;
 };
 /**
- * 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
+ * @summary Delete upload
  */
-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), {
+export const deleteUpload = async (upload, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteUploadUrl(upload), {
         ...options,
-        method: "POST",
-        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
-        body: JSON.stringify(dynamicCallResultRequestBody),
+        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 getListFoldersUrl = () => {
-    return `https://assistant.leaflow.cloud/api/v1/folders`;
+export const getCancelUploadUrl = (upload) => {
+    return `https://assistant.leaflow.cloud/api/v1/uploads/${encodeURIComponent(String(upload))}/cancel`;
 };
 /**
- * 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
+ * @summary Cancel upload
  */
-export const listFolders = async (options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getListFoldersUrl(), {
+export const cancelUpload = async (upload, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCancelUploadUrl(upload), {
         ...options,
-        method: "GET",
+        method: "POST",
     });
     const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-    const data = body ? JSON.parse(body) : {};
+    const data = body ? JSON.parse(body) : undefined;
     return { data, status: res.status, headers: res.headers };
 };
-export const getCreateFolderUrl = () => {
-    return `https://assistant.leaflow.cloud/api/v1/folders`;
+export const getCompleteUploadUrl = (upload) => {
+    return `https://assistant.leaflow.cloud/api/v1/uploads/${encodeURIComponent(String(upload))}/complete`;
 };
 /**
- * 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
+ * @summary Complete upload
  */
-export const createFolder = async (createFolderRequestBody, options, fetchFn) => {
+export const completeUpload = async (upload, completeUploadRequestBody, options, fetchFn) => {
     const getHeaders = (h) => {
         if (!h)
             return {};
@@ -516,40 +1352,32 @@ export const createFolder = async (createFolderRequestBody, options, fetchFn) =>
         }
         return headers;
     };
-    const res = await (fetchFn ?? fetch)(getCreateFolderUrl(), {
+    const res = await (fetchFn ?? fetch)(getCompleteUploadUrl(upload), {
         ...options,
         method: "POST",
         headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
-        body: JSON.stringify(createFolderRequestBody),
+        body: JSON.stringify(completeUploadRequestBody),
     });
     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",
+export const getPutUploadPartUrl = (upload, part, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
     });
-    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))}`;
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://assistant.leaflow.cloud/api/v1/uploads/${encodeURIComponent(String(upload))}/parts/${encodeURIComponent(String(part))}?${stringifiedParams}`
+        : `https://assistant.leaflow.cloud/api/v1/uploads/${encodeURIComponent(String(upload))}/parts/${encodeURIComponent(String(part))}`;
 };
 /**
- * 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
+ * @summary Put upload part
  */
-export const updateFolder = async (folder, updateFolderRequestBody, options, fetchFn) => {
+export const putUploadPart = async (upload, part, putUploadPartBody, params, headers, options, fetchFn) => {
     const getHeaders = (h) => {
         if (!h)
             return {};
@@ -565,34 +1393,20 @@ export const updateFolder = async (folder, updateFolderRequestBody, options, fet
         }
         return headers;
     };
-    const res = await (fetchFn ?? fetch)(getUpdateFolderUrl(folder), {
+    const res = await (fetchFn ?? fetch)(getPutUploadPartUrl(upload, part, params), {
         ...options,
-        method: "PATCH",
-        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
-        body: JSON.stringify(updateFolderRequestBody),
+        method: "PUT",
+        headers: {
+            "Content-Type": "application/octet-stream",
+            ...Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, String(value)])),
+            ...getHeaders(options?.headers),
+        },
+        body: putUploadPartBody,
     });
     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`;
 };
@@ -703,48 +1517,103 @@ 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
+ * 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 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 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), {
+export const getBinding = async (binding, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetBindingUrl(binding), {
         ...options,
-        method: "PATCH",
-        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
-        body: JSON.stringify(skillEnabledRequestBody),
+        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 getDeleteSkillUrl = (skill) => {
-    return `https://assistant.leaflow.cloud/api/v1/skills/${encodeURIComponent(String(skill))}`;
+export const getDeleteBindingUrl = (binding) => {
+    return `https://assistant.leaflow.cloud/api/v1/bindings/${encodeURIComponent(String(binding))}`;
 };
 /**
- * A built-in skill of the same name, if there was one, becomes visible again.
- * @summary Delete this project's skill
+ * @summary Remove a binding
  */
-export const deleteSkill = async (skill, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getDeleteSkillUrl(skill), {
+export const deleteBinding = async (binding, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteBindingUrl(binding), {
         ...options,
         method: "DELETE",
     });
@@ -752,7 +1621,7 @@ export const deleteSkill = async (skill, options, fetchFn) => {
     const data = body ? JSON.parse(body) : undefined;
     return { data, status: res.status, headers: res.headers };
 };
-export const getListThreadsUrl = (params) => {
+export const getListChannelsUrl = (params) => {
     const normalizedParams = new URLSearchParams();
     Object.entries(params || {}).forEach(([key, value]) => {
         if (value !== undefined) {
@@ -761,17 +1630,14 @@ export const getListThreadsUrl = (params) => {
     });
     const stringifiedParams = normalizedParams.toString();
     return stringifiedParams.length > 0
-        ? `https://assistant.leaflow.cloud/api/v1/threads?${stringifiedParams}`
-        : `https://assistant.leaflow.cloud/api/v1/threads`;
+        ? `https://assistant.leaflow.cloud/api/v1/channels?${stringifiedParams}`
+        : `https://assistant.leaflow.cloud/api/v1/channels`;
 };
 /**
- * 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
+ * @summary List channels
  */
-export const listThreads = async (params, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getListThreadsUrl(params), {
+export const listChannels = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListChannelsUrl(params), {
         ...options,
         method: "GET",
     });
@@ -779,16 +1645,14 @@ export const listThreads = async (params, options, fetchFn) => {
     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`;
+export const getCreateChannelUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/channels`;
 };
 /**
- * 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
+ * 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 createThread = async (createThreadRequestBody, options, fetchFn) => {
+export const createChannel = async (createChannelRequestBody, options, fetchFn) => {
     const getHeaders = (h) => {
         if (!h)
             return {};
@@ -804,25 +1668,24 @@ export const createThread = async (createThreadRequestBody, options, fetchFn) =>
         }
         return headers;
     };
-    const res = await (fetchFn ?? fetch)(getCreateThreadUrl(), {
+    const res = await (fetchFn ?? fetch)(getCreateChannelUrl(), {
         ...options,
         method: "POST",
         headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
-        body: JSON.stringify(createThreadRequestBody),
+        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 getGetThreadUrl = (thread) => {
-    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}`;
+export const getGetChannelUrl = (channel) => {
+    return `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}`;
 };
 /**
- * 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
+ * @summary Get a channel
  */
-export const getThread = async (thread, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getGetThreadUrl(thread), {
+export const getChannel = async (channel, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetChannelUrl(channel), {
         ...options,
         method: "GET",
     });
@@ -830,22 +1693,14 @@ export const getThread = async (thread, options, fetchFn) => {
     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))}`;
+export const getUpdateChannelUrl = (channel) => {
+    return `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}`;
 };
 /**
- * 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
+ * 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 updateThread = async (thread, updateThreadRequestBody, options, fetchFn) => {
+export const updateChannel = async (channel, updateChannelRequestBody, options, fetchFn) => {
     const getHeaders = (h) => {
         if (!h)
             return {};
@@ -861,31 +1716,25 @@ export const updateThread = async (thread, updateThreadRequestBody, options, fet
         }
         return headers;
     };
-    const res = await (fetchFn ?? fetch)(getUpdateThreadUrl(thread), {
+    const res = await (fetchFn ?? fetch)(getUpdateChannelUrl(channel), {
         ...options,
         method: "PATCH",
         headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
-        body: JSON.stringify(updateThreadRequestBody),
+        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 getDeleteThreadUrl = (thread) => {
-    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}`;
+export const getDeleteChannelUrl = (channel) => {
+    return `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}`;
 };
 /**
- * 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
+ * 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 deleteThread = async (thread, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getDeleteThreadUrl(thread), {
+export const deleteChannel = async (channel, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteChannelUrl(channel), {
         ...options,
         method: "DELETE",
     });
@@ -893,40 +1742,23 @@ export const deleteThread = async (thread, options, fetchFn) => {
     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))}`;
+export const getCreateBindingCodeUrl = (channel) => {
+    return `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}/binding-codes`;
 };
 /**
- * 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
+ * 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 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), {
+export const createBindingCode = async (channel, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCreateBindingCodeUrl(channel), {
         ...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;
+    const data = body ? JSON.parse(body) : {};
     return { data, status: res.status, headers: res.headers };
 };
-export const getListEarlierItemsUrl = (thread, params) => {
+export const getListChannelRejectionsUrl = (channel, params) => {
     const normalizedParams = new URLSearchParams();
     Object.entries(params || {}).forEach(([key, value]) => {
         if (value !== undefined) {
@@ -935,15 +1767,15 @@ export const getListEarlierItemsUrl = (thread, params) => {
     });
     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`;
+        ? `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}/rejections?${stringifiedParams}`
+        : `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}/rejections`;
 };
 /**
- * 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
+ * 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 listEarlierItems = async (thread, params, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getListEarlierItemsUrl(thread, params), {
+export const listChannelRejections = async (channel, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListChannelRejectionsUrl(channel, params), {
         ...options,
         method: "GET",
     });
@@ -951,30 +1783,14 @@ export const listEarlierItems = async (thread, params, options, fetchFn) => {
     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`;
+export const getRotateChannelSecretUrl = (channel) => {
+    return `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}/secret`;
 };
 /**
- * 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
+ * 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 sendMessage = async (thread, sendMessageRequestBody, options, fetchFn) => {
+export const rotateChannelSecret = async (channel, rotateSecretRequestBody, options, fetchFn) => {
     const getHeaders = (h) => {
         if (!h)
             return {};
@@ -990,72 +1806,97 @@ export const sendMessage = async (thread, sendMessageRequestBody, options, fetch
         }
         return headers;
     };
-    const res = await (fetchFn ?? fetch)(getSendMessageUrl(thread), {
+    const res = await (fetchFn ?? fetch)(getRotateChannelSecretUrl(channel), {
         ...options,
         method: "POST",
         headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
-        body: JSON.stringify(sendMessageRequestBody),
+        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 getAnswerQuestionUrl = (thread, item) => {
-    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/questions/${encodeURIComponent(String(item))}`;
+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`;
 };
 /**
- * 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
+ * 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 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), {
+export const checkSender = async (channel, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCheckSenderUrl(channel, params), {
         ...options,
-        method: "POST",
-        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
-        body: JSON.stringify(answerRequestBody),
+        method: "GET",
     });
     const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-    const data = body ? JSON.parse(body) : undefined;
+    const data = body ? JSON.parse(body) : {};
     return { data, status: res.status, headers: res.headers };
 };
-export const getMarkThreadReadUrl = (thread) => {
-    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/read`;
+export const getBeginWeixinLoginUrl = (channel) => {
+    return `https://assistant.leaflow.cloud/api/v1/channels/${encodeURIComponent(String(channel))}/weixin-logins`;
 };
 /**
- * @summary Mark a conversation as read
+ * 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 markThreadRead = async (thread, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getMarkThreadReadUrl(thread), {
+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) : undefined;
+    const data = body ? JSON.parse(body) : {};
     return { data, status: res.status, headers: res.headers };
 };
-export const getRevertThreadUrl = (thread) => {
-    return `https://assistant.leaflow.cloud/api/v1/threads/${encodeURIComponent(String(thread))}/revert`;
+export const getListPlatformsUrl = () => {
+    return `https://assistant.leaflow.cloud/api/v1/platforms`;
 };
 /**
- * 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
+ * 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 revertThread = async (thread, revertRequestBody, options, fetchFn) => {
+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 {};
@@ -1071,11 +1912,11 @@ export const revertThread = async (thread, revertRequestBody, options, fetchFn)
         }
         return headers;
     };
-    const res = await (fetchFn ?? fetch)(getRevertThreadUrl(thread), {
+    const res = await (fetchFn ?? fetch)(getSubmitWeixinVerifyCodeUrl(login), {
         ...options,
         method: "POST",
         headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
-        body: JSON.stringify(revertRequestBody),
+        body: JSON.stringify(verifyCodeRequestBody),
     });
     const body = [204, 205, 304].includes(res.status) ? null : await res.text();
     const data = body ? JSON.parse(body) : {};