@leaflow/sdk 0.0.0-dev.359.gca6d1b5 → 0.0.0-dev.361.gefdc428

package/dist/assistant/v1/generated/schemas.zod.js

@@ -2,72 +2,569 @@
  * Generated by orval 🍺
  * Do not edit manually.
  * Leaflow Assistant API
- * The AI assistant inside the console: conversations, messages, tool calls and their approval, attachments, and connecting the assistant to instant messaging platforms such as WeChat, Feishu and Telegram.
+ * Conversations with agents that operate the Leaflow platform, plus their folders, tasks, files and
+ * chat-app channels.
  *
- * ## A conversation
+ * A conversation is a thread. A person talks to the main thread; the agent in it can start subagents,
+ * which are threads too and run on their own: stopping the main thread does not stop them, and each
+ * subagent tells its parent when it ends. A thread runs in turns; each turn records the model and
+ * reasoning effort it used and its token usage.
  *
- * The path one conversation takes, end to end. It names the operations that path needs, not all of them — the full list is below, and it also covers folders, attachments, memories, skills and the instant messaging side.
+ * Models come from the Canopy catalogue. A new thread uses the model it names, the caller's default
+ * from /api/v1/settings, or the first catalogue model that can run an agent. Reasoning models take one
+ * of three efforts — low, medium or high — which are sent to the model unchanged.
  *
- * 1. `POST /api/v1/threads` creates one;
- * 2. `POST /api/v1/threads/{thread}/messages` sends a message and returns a `turnId` at once; the assistant runs in the background;
- * 3. `GET /api/v1/threads/{thread}` returns the conversation document to render, whose `stream` is where live output arrives;
- * 4. When the assistant needs the user, the document's `wait` says which kind: approving a batch of tool calls (`POST /api/v1/threads/{thread}/approvals/{batch}`), or answering a few questions (`POST /api/v1/threads/{thread}/questions/{item}`). It continues on its own once that is handled.
+ * Read a thread's state with get-thread and its transcript with list-thread-items. Follow both live
+ * over the WebSocket described under /api/v1/realtime/tickets. Slash commands such as /status and
+ * /compact are listed by list-commands and work the same in the console and in chat apps.
  *
- * Sending a file takes two steps: `POST /api/v1/attachments` for an id, then put that id in `attachmentIds` when sending the message. Images, text and arbitrary binaries all go through the same two steps; what differs is how the assistant reads them afterwards, which the upload response's `kind` says.
- *
- * ## Models
- *
- * Canopy owns the model catalogue and capabilities. Model ids in this API, conversation preferences and historical entries are Canopy model ids, with no separate assistant model registration. GET /api/v1/models returns the allowed, usable choices and allowModelSelection. Hide the selector when selection is disabled; the service enforces the same rule.
- *
- * preferredModelId is the user's choice. Null follows the platform default, including later changes. Disabled selection preserves but ignores preferences for new turns. A model removed from the allowlist, retired in Canopy or otherwise unusable falls back to the default without clearing the preference.
- *
- * Users can switch an existing conversation through PATCH /api/v1/threads/{thread} with preferredModelId. This preserves the transcript, starts no turn and makes no inference request. Null returns to following the default. Changes apply from the next turn; a running or waiting turn and messages queued into it retain their captured choices and fallback policy.
- *
- * If the chosen model cannot serve a request, the service may safely fall back to the default without confirmation or an additional switching message. If the default also fails, the turn fails normally; no third model is selected for ordinary answers. Fallback preserves executed tool results and never splices answers from different models. Invalid input, cancellation and a declined tool call do not trigger model fallback. Each entry's model records its actual Canopy author, not the saved preference.
- *
- * Users cannot choose a compaction model. Normal compaction reuses the effective model and reasoning settings for context-cache reuse. Only if that model cannot handle the compaction request or produce a summary fitting the target window may the service automatically use another allowed Canopy model with suitable capabilities. This does not change the preference or ordinary answer model, and is permitted even when user model selection is disabled.
- *
- * After compaction, the full next request, including instructions, tools and retained messages, must fit the target's usable prompt budget with room left for an answer, respecting its output limit. If still too large, further compaction attempts are bounded; exhaustion fails with CANNOT_FOLD instead of sending an oversized request or silently discarding history or images. The same checks apply when switching models or falling back. Each compaction entry records its actual author.
- *
- * An empty allowlist or unavailable default does not prevent reading conversations or saving permitted preference changes. A failed Canopy catalogue read is not evidence that a model was removed: use a valid cached snapshot or return MODEL_CATALOG_UNAVAILABLE, without deleting references or inventing capabilities. Catalogue presence is configuration information, not a live provider health check.
- *
- * ## Live output
- *
- * ```
- * GET /api/v1/turns/{turn}/stream?ticket=<ticket>&cursor=<cursor>
- * ```
- *
- * This is a Server-Sent Events stream, which is why it is not in the operation list below and why generated clients have no method for it. Open it with `EventSource`, or any SSE client. It is how live output arrives; polling the document on a timer is not the intended way to follow a conversation.
- *
- * - `path` and `ticket` both come from the conversation document's `stream`. `path` is relative, resolved against the address the document was fetched from;
- * - `cursor` is where to start, from the document's `cursor`. Omit it to start at the beginning of what is still available;
- * - every event is one incremental edit to that same document, so the same rendering logic applies;
- * - the connection has a lifetime and closes cleanly when it ends. With `EventSource` the browser reconnects with `Last-Event-ID` and resumes by itself, so nothing needs handling;
- * - three terminal events: `done` this turn finished (carrying its final status), `paused` the assistant is waiting on the user (fetch the document again and read `wait`), `stalled` execution was interrupted and will not resume — do not reconnect.
- * OpenAPI spec version: 1.0.0
+ * Upload large files with /api/v1/uploads: read /api/v1/upload-configuration first, send exact-sized
+ * parts, then complete the upload and send its attachment id in a message.
+ * OpenAPI spec version: 2.0.0
  */
 import * as zod from "zod";
-import { AnswerRequestBody } from "./validators/answerRequestBody.zod.js";
+import { AnswerQuestionRequestBody } from "./validators/answerQuestionRequestBody.zod.js";
+import { CompleteUploadRequestBody } from "./validators/completeUploadRequestBody.zod.js";
 import { CreateChannelRequestBody } from "./validators/createChannelRequestBody.zod.js";
 import { CreateFolderRequestBody } from "./validators/createFolderRequestBody.zod.js";
+import { CreateTaskRequestBody } from "./validators/createTaskRequestBody.zod.js";
 import { CreateThreadRequestBody } from "./validators/createThreadRequestBody.zod.js";
-import { DecideRequestBody } from "./validators/decideRequestBody.zod.js";
-import { DynamicCallResultRequestBody } from "./validators/dynamicCallResultRequestBody.zod.js";
+import { CreateUploadRequestBody } from "./validators/createUploadRequestBody.zod.js";
+import { DecideToolCallsRequestBody } from "./validators/decideToolCallsRequestBody.zod.js";
+import { MoveFolderRequestBody } from "./validators/moveFolderRequestBody.zod.js";
+import { PlaceThreadRequestBody } from "./validators/placeThreadRequestBody.zod.js";
+import { ResumeThreadRequestBody } from "./validators/resumeThreadRequestBody.zod.js";
 import { RevertRequestBody } from "./validators/revertRequestBody.zod.js";
 import { RotateSecretRequestBody } from "./validators/rotateSecretRequestBody.zod.js";
+import { RunCommandRequestBody } from "./validators/runCommandRequestBody.zod.js";
 import { SendMessageRequestBody } from "./validators/sendMessageRequestBody.zod.js";
 import { SkillEnabledRequestBody } from "./validators/skillEnabledRequestBody.zod.js";
 import { SkillRequestBody } from "./validators/skillRequestBody.zod.js";
+import { ToolResultRequestBody } from "./validators/toolResultRequestBody.zod.js";
 import { UpdateChannelRequestBody } from "./validators/updateChannelRequestBody.zod.js";
 import { UpdateFolderRequestBody } from "./validators/updateFolderRequestBody.zod.js";
+import { UpdateSettingsRequestBody } from "./validators/updateSettingsRequestBody.zod.js";
+import { UpdateTaskRequestBody } from "./validators/updateTaskRequestBody.zod.js";
 import { UpdateThreadRequestBody } from "./validators/updateThreadRequestBody.zod.js";
+import { UpdateUploadRequestBody } from "./validators/updateUploadRequestBody.zod.js";
 import { VerifyCodeRequestBody } from "./validators/verifyCodeRequestBody.zod.js";
 /**
- * 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.
+ * 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 CreateThreadBody = CreateThreadRequestBody;
+/**
+ * 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 getThreadPathThreadMax = 64;
+export const GetThreadParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(getThreadPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+});
+/**
+ * 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 updateThreadPathThreadMax = 64;
+export const UpdateThreadParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(updateThreadPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+});
+export const UpdateThreadBody = UpdateThreadRequestBody;
+/**
+ * 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 deleteThreadPathThreadMax = 64;
+export const DeleteThreadParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(deleteThreadPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+});
+/**
+ * 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 interruptThreadPathThreadMax = 64;
+export const InterruptThreadParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(interruptThreadPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+});
+/**
+ * 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 resumeThreadPathThreadMax = 64;
+export const ResumeThreadParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(resumeThreadPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+});
+export const ResumeThreadBody = ResumeThreadRequestBody;
+/**
+ * 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 compactThreadPathThreadMax = 64;
+export const CompactThreadParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(compactThreadPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+});
+/**
+ * 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 revertThreadPathThreadMax = 64;
+export const RevertThreadParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(revertThreadPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+});
+export const RevertThreadBody = RevertRequestBody;
+/**
+ * Clears `unread` until the assistant replies again.
+ * @summary Mark a conversation as read
+ */
+export const markThreadReadPathThreadMax = 64;
+export const MarkThreadReadParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(markThreadReadPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+});
+/**
+ * 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 listThreadItemsPathThreadMax = 64;
+export const ListThreadItemsParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(listThreadItemsPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+});
+export const listThreadItemsQueryBeforeMin = 0;
+export const listThreadItemsQueryAfterMin = 0;
+export const listThreadItemsQueryAroundMin = 0;
+export const listThreadItemsQueryTurnsDefault = 10;
+export const listThreadItemsQueryTurnsMax = 50;
+export const ListThreadItemsQueryParams = zod.strictObject({
+    before: zod
+        .int()
+        .min(listThreadItemsQueryBeforeMin)
+        .optional()
+        .describe("Return the window ending just above this ordinal."),
+    after: zod
+        .int()
+        .min(listThreadItemsQueryAfterMin)
+        .optional()
+        .describe("Return the window starting just below this ordinal."),
+    around: zod
+        .int()
+        .min(listThreadItemsQueryAroundMin)
+        .optional()
+        .describe("Return a window containing this ordinal. Only one of before, after and around may be given."),
+    turns: zod
+        .int()
+        .min(1)
+        .max(listThreadItemsQueryTurnsMax)
+        .default(listThreadItemsQueryTurnsDefault)
+        .describe("How many turns a window holds at most."),
+});
+/**
+ * One item in full, including what list-thread-items cut from it.
+ * @summary Get a transcript item
+ */
+export const getThreadItemPathThreadMax = 64;
+export const getThreadItemPathItemMax = 64;
+export const GetThreadItemParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(getThreadItemPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+    item: zod.string().max(getThreadItemPathItemMax).describe("A transcript item id."),
+});
+/**
+ * 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 sendMessagePathThreadMax = 64;
+export const SendMessageParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(sendMessagePathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+});
+export const SendMessageBody = SendMessageRequestBody;
+/**
+ * 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 decideToolCallsPathThreadMax = 64;
+export const DecideToolCallsParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(decideToolCallsPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+});
+export const DecideToolCallsBody = DecideToolCallsRequestBody;
+/**
+ * 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 answerQuestionPathThreadMax = 64;
+export const answerQuestionPathItemMax = 64;
+export const AnswerQuestionParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(answerQuestionPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+    item: zod.string().max(answerQuestionPathItemMax).describe("A transcript item id."),
+});
+export const AnswerQuestionBody = AnswerQuestionRequestBody;
+/**
+ * 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 submitToolResultPathThreadMax = 64;
+export const submitToolResultPathItemMax = 64;
+export const SubmitToolResultParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(submitToolResultPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+    item: zod.string().max(submitToolResultPathItemMax).describe("A transcript item id."),
+});
+export const SubmitToolResultBody = ToolResultRequestBody;
+/**
+ * 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 listThreadTurnsPathThreadMax = 64;
+export const ListThreadTurnsParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(listThreadTurnsPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+});
+export const listThreadTurnsQueryIdsMax = 200;
+export const listThreadTurnsQueryCursorMax = 1024;
+export const listThreadTurnsQueryLimitDefault = 50;
+export const listThreadTurnsQueryLimitMax = 200;
+export const ListThreadTurnsQueryParams = zod.strictObject({
+    ids: zod.array(zod.string()).min(1).max(listThreadTurnsQueryIdsMax).optional(),
+    cursor: zod
+        .string()
+        .min(1)
+        .max(listThreadTurnsQueryCursorMax)
+        .optional()
+        .describe("The next_cursor returned by the previous page. Omit it for the first page."),
+    limit: zod
+        .int()
+        .min(1)
+        .max(listThreadTurnsQueryLimitMax)
+        .default(listThreadTurnsQueryLimitDefault)
+        .describe("Items returned in this page. Defaults to 50; at most 200."),
+});
+/**
+ * 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 runCommandPathThreadMax = 64;
+export const RunCommandParams = zod.strictObject({
+    thread: zod
+        .string()
+        .max(runCommandPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+});
+export const RunCommandBody = RunCommandRequestBody;
+/**
+ * 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 CreateFolderBody = CreateFolderRequestBody;
+/**
+ * Its conversations are read with search-threads and `folderId`.
+ * @summary Get a folder
+ */
+export const getFolderPathFolderMax = 64;
+export const GetFolderParams = zod.strictObject({
+    folder: zod.string().max(getFolderPathFolderMax).describe("A folder id."),
+});
+/**
+ * The inbox cannot be renamed and fails with 409 and code INBOX_READ_ONLY.
+ * @summary Rename a folder
+ */
+export const updateFolderPathFolderMax = 64;
+export const UpdateFolderParams = zod.strictObject({
+    folder: zod.string().max(updateFolderPathFolderMax).describe("A folder id."),
+});
+export const UpdateFolderBody = UpdateFolderRequestBody;
+/**
+ * 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 deleteFolderPathFolderMax = 64;
+export const DeleteFolderParams = zod.strictObject({
+    folder: zod.string().max(deleteFolderPathFolderMax).describe("A folder id."),
+});
+/**
+ * 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 moveFolderPathFolderMax = 64;
+export const MoveFolderParams = zod.strictObject({
+    folder: zod.string().max(moveFolderPathFolderMax).describe("A folder id."),
+});
+export const MoveFolderBody = MoveFolderRequestBody;
+/**
+ * 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 placeThreadPathFolderMax = 64;
+export const placeThreadPathThreadMax = 64;
+export const PlaceThreadParams = zod.strictObject({
+    folder: zod.string().max(placeThreadPathFolderMax).describe("A folder id."),
+    thread: zod
+        .string()
+        .max(placeThreadPathThreadMax)
+        .describe("A thread id. Subagents are threads as well."),
+});
+export const PlaceThreadBody = PlaceThreadRequestBody;
+/**
+ * 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.
+ *
+ * `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.
+ *
+ * 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 CreateTaskBody = CreateTaskRequestBody;
+/**
+ * @summary Get a task
+ */
+export const getTaskPathTaskMax = 64;
+export const GetTaskParams = zod.strictObject({
+    task: zod.string().max(getTaskPathTaskMax).describe("A task id."),
+});
+/**
+ * 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 updateTaskPathTaskMax = 64;
+export const UpdateTaskParams = zod.strictObject({
+    task: zod.string().max(updateTaskPathTaskMax).describe("A task id."),
+});
+export const UpdateTaskBody = UpdateTaskRequestBody;
+/**
+ * Cancels a run in progress and removes the task. Its runs stay readable in the conversation's transcript.
+ * @summary Delete a task
+ */
+export const deleteTaskPathTaskMax = 64;
+export const DeleteTaskParams = zod.strictObject({
+    task: zod.string().max(deleteTaskPathTaskMax).describe("A task id."),
+});
+/**
+ * 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 runTaskPathTaskMax = 64;
+export const RunTaskParams = zod.strictObject({
+    task: zod.string().max(runTaskPathTaskMax).describe("A task id."),
+});
+/**
+ * Stops future runs from its trigger. A run in progress continues. Pausing a paused task succeeds.
+ * @summary Pause a task
+ */
+export const pauseTaskPathTaskMax = 64;
+export const PauseTaskParams = zod.strictObject({
+    task: zod.string().max(pauseTaskPathTaskMax).describe("A task id."),
+});
+/**
+ * Lets its trigger start runs again. Missed runs within `catchupSeconds` are started. Resuming an active task succeeds.
+ * @summary Resume a task
+ */
+export const resumeTaskPathTaskMax = 64;
+export const ResumeTaskParams = zod.strictObject({
+    task: zod.string().max(resumeTaskPathTaskMax).describe("A task id."),
+});
+/**
+ * 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 cancelTaskRunPathTaskMax = 64;
+export const CancelTaskRunParams = zod.strictObject({
+    task: zod.string().max(cancelTaskRunPathTaskMax).describe("A task id."),
+});
+/**
+ * Newest first, without output; read a run with get-task-run for it.
+ * @summary List a task's runs
+ */
+export const listTaskRunsPathTaskMax = 64;
+export const ListTaskRunsParams = zod.strictObject({
+    task: zod.string().max(listTaskRunsPathTaskMax).describe("A task id."),
+});
+export const listTaskRunsQueryCursorMax = 1024;
+export const listTaskRunsQueryLimitDefault = 50;
+export const listTaskRunsQueryLimitMax = 200;
+export const ListTaskRunsQueryParams = zod.strictObject({
+    cursor: zod
+        .string()
+        .min(1)
+        .max(listTaskRunsQueryCursorMax)
+        .optional()
+        .describe("The next_cursor returned by the previous page. Omit it for the first page."),
+    limit: zod
+        .int()
+        .min(1)
+        .max(listTaskRunsQueryLimitMax)
+        .default(listTaskRunsQueryLimitDefault)
+        .describe("Items returned in this page. Defaults to 50; at most 200."),
+});
+/**
+ * One run with the end of its output.
+ * @summary Get a task run
+ */
+export const getTaskRunPathTaskMax = 64;
+export const getTaskRunPathRunMax = 128;
+export const GetTaskRunParams = zod.strictObject({
+    task: zod.string().max(getTaskRunPathTaskMax).describe("A task id."),
+    run: zod.string().max(getTaskRunPathRunMax).describe("A task run id."),
+});
+/**
+ * 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 UpdateSettingsBody = UpdateSettingsRequestBody;
+/**
+ * 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 openRealtimeQueryTicketMax = 4096;
+export const OpenRealtimeQueryParams = zod.strictObject({
+    ticket: zod.string().max(openRealtimeQueryTicketMax),
+});
+/**
+ * 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 `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.
+ * 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 uploadAttachmentQueryFilenameMax = 255;
@@ -81,12 +578,105 @@ export const UploadAttachmentQueryParams = zod.strictObject({
 /**
  * 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.
+ * 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 DownloadAttachmentParams = zod.strictObject({
     attachment: zod.string(),
 });
+/**
+ * @summary Create upload
+ */
+export const CreateUploadBody = CreateUploadRequestBody;
+/**
+ * @summary Get upload
+ */
+export const GetUploadParams = zod.strictObject({
+    upload: zod.string(),
+});
+/**
+ * @summary Update upload
+ */
+export const UpdateUploadParams = zod.strictObject({
+    upload: zod.string(),
+});
+export const UpdateUploadBody = UpdateUploadRequestBody;
+/**
+ * @summary Delete upload
+ */
+export const DeleteUploadParams = zod.strictObject({
+    upload: zod.string(),
+});
+/**
+ * @summary Cancel upload
+ */
+export const CancelUploadParams = zod.strictObject({
+    upload: zod.string(),
+});
+/**
+ * @summary Complete upload
+ */
+export const CompleteUploadParams = zod.strictObject({
+    upload: zod.string(),
+});
+export const CompleteUploadBody = CompleteUploadRequestBody;
+/**
+ * @summary Put upload part
+ */
+export const putUploadPartPathPartMax = 10000;
+export const PutUploadPartParams = zod.strictObject({
+    upload: zod.string(),
+    part: zod.int().min(1).max(putUploadPartPathPartMax),
+});
+export const PutUploadPartQueryParams = zod.strictObject({
+    policyId: zod.string(),
+});
+export const PutUploadPartHeader = zod.strictObject({
+    "X-Part-Size": zod.int().min(1),
+});
+/**
+ * The assistant stops remembering this. It takes effect at once, so the next conversation will not carry it. The assistant may well learn the same thing again.
+ * @summary Delete one memory
+ */
+export const DeleteMemoryParams = zod.strictObject({
+    memory: zod.string(),
+});
+/**
+ * Creates it, or replaces the project's skill of that name. The whole package goes in each
+ * time: files left out of a write are removed, so the stored skill is what was sent and not
+ * what accumulated.
+ *
+ * A project skill takes precedence over a built-in one of the same name for this project only.
+ * The built-in is untouched and reappears if the project's is deleted.
+ * @summary Write a skill for this project
+ */
+export const PutSkillBody = SkillRequestBody;
+/**
+ * Works for built-in skills too; they simply cannot be written.
+ * @summary Read one skill, with its files
+ */
+export const GetSkillParams = zod.strictObject({
+    skill: zod.string().describe("The skill's name, as `list-skills` returned it."),
+});
+/**
+ * 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 SetSkillEnabledParams = zod.strictObject({
+    skill: zod.string(),
+});
+export const SetSkillEnabledBody = SkillEnabledRequestBody;
+/**
+ * A built-in skill of the same name, if there was one, becomes visible again.
+ * @summary Delete this project's skill
+ */
+export const DeleteSkillParams = zod.strictObject({
+    skill: zod.string(),
+});
 /**
  * Filter by channelId to show, per channel, who is bound to it.
  * @summary List bindings
@@ -245,232 +835,3 @@ export const SubmitWeixinVerifyCodeParams = zod.strictObject({
     login: zod.uuid(),
 });
 export const SubmitWeixinVerifyCodeBody = VerifyCodeRequestBody;
-/**
- * The assistant asks the client to run an action by adding a tool call to the conversation
- * with the namespace `dynamic`; the client acts when that entry turns in_progress and reports
- * back here.
- *
- * The first result is the one that counts. A later one is refused rather than replacing it.
- * @summary Report what an action produced
- */
-export const SubmitDynamicCallResultParams = zod.strictObject({
-    call: zod.string().describe("The id of the tool call entry in the conversation."),
-});
-export const SubmitDynamicCallResultBody = DynamicCallResultRequestBody;
-/**
- * A folder groups conversations in the sidebar and does nothing else. The assistant is never told which folder a conversation is in, and a conversation behaves exactly the same inside one as outside: no shared instructions, no shared files, no shared memory.
- *
- * Names are unique within an account's folders in this project, because the only way to aim at a folder is to read its name.
- * @summary Create a folder
- */
-export const CreateFolderBody = CreateFolderRequestBody;
-/**
- * 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 GetFolderParams = zod.strictObject({
-    folder: zod.string(),
-});
-/**
- * The conversations in it are untouched, and none of them move in the list — a folder's name is not part of what any conversation is about.
- * @summary Rename a folder
- */
-export const UpdateFolderParams = zod.strictObject({
-    folder: zod.string(),
-});
-export const UpdateFolderBody = UpdateFolderRequestBody;
-/**
- * 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 DeleteFolderParams = zod.strictObject({
-    folder: zod.string(),
-});
-/**
- * The assistant stops remembering this. It takes effect at once, so the next conversation will not carry it. The assistant may well learn the same thing again.
- * @summary Delete one memory
- */
-export const DeleteMemoryParams = zod.strictObject({
-    memory: zod.string(),
-});
-/**
- * Creates it, or replaces the project's skill of that name. The whole package goes in each
- * time: files left out of a write are removed, so the stored skill is what was sent and not
- * what accumulated.
- *
- * A project skill takes precedence over a built-in one of the same name for this project only.
- * The built-in is untouched and reappears if the project's is deleted.
- * @summary Write a skill for this project
- */
-export const PutSkillBody = SkillRequestBody;
-/**
- * Works for built-in skills too; they simply cannot be written.
- * @summary Read one skill, with its files
- */
-export const GetSkillParams = zod.strictObject({
-    skill: zod.string().describe("The skill's name, as `list-skills` returned it."),
-});
-/**
- * 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 SetSkillEnabledParams = zod.strictObject({
-    skill: zod.string(),
-});
-export const SetSkillEnabledBody = SkillEnabledRequestBody;
-/**
- * A built-in skill of the same name, if there was one, becomes visible again.
- * @summary Delete this project's skill
- */
-export const DeleteSkillParams = zod.strictObject({
-    skill: zod.string(),
-});
-/**
- * Ordered by most recent activity, limited to the current account's conversations in the current project. `archived` selects between two sets rather than widening one: archived conversations are absent from the default list, and turning the flag on shows those instead.
- *
- * Pass the returned nextCursor as cursor; omit cursor on the first page. Continue with the same q, archived and folder filters. The cursor marks a position in the activity order, so changing filters between pages does not continue the same list.
- * @summary List conversations
- */
-export const listThreadsQueryQMax = 100;
-export const listThreadsQueryFolderMax = 64;
-export const listThreadsQueryCursorMax = 1024;
-export const listThreadsQueryLimitDefault = 50;
-export const listThreadsQueryLimitMax = 200;
-export const ListThreadsQueryParams = zod.strictObject({
-    q: zod
-        .string()
-        .max(listThreadsQueryQMax)
-        .optional()
-        .describe("Search titles, case-insensitively. Leave it empty for the most recent conversations"),
-    archived: zod
-        .boolean()
-        .optional()
-        .describe("When true, returns **only** archived conversations; otherwise only unarchived ones"),
-    folder: zod
-        .string()
-        .max(listThreadsQueryFolderMax)
-        .optional()
-        .describe('Narrow the list to one folder. Omitting it returns conversations from every folder and from none; a folder id returns that folder\'s; the empty value (`?folder=`) returns the ones that are in no folder at all. Empty is not the same as omitted, and a sidebar needs both: "chats" is exactly the ungrouped set, and asking for everything would let filed conversations crowd it out of the limit.'),
-    cursor: zod
-        .string()
-        .min(1)
-        .max(listThreadsQueryCursorMax)
-        .optional()
-        .describe("The next_cursor returned by the previous page. Omit it for the first page."),
-    limit: zod
-        .int()
-        .min(1)
-        .max(listThreadsQueryLimitMax)
-        .default(listThreadsQueryLimitDefault)
-        .describe("Items returned in this page. Defaults to 50; at most 200."),
-});
-/**
- * Omit preferredModelId or set it to null to follow the platform default. A non-null preference is accepted only while model selection is enabled; otherwise the request fails with 403 and code MODEL_SELECTION_DISABLED.
- *
- * A well-formed preference for a Canopy model that is no longer allowed or has been retired or removed is retained and uses the default when a turn starts. This also handles a catalogue change between displaying the selector and submitting the choice. Creating a conversation does not contact a model provider and remains possible when generation is unavailable.
- * @summary Create a conversation
- */
-export const CreateThreadBody = CreateThreadRequestBody;
-/**
- * The complete current state of a conversation, for the first render. Its `stream` gives the address and admission ticket for live output, and what that stream pushes are incremental edits to this same document, so the same rendering logic applies.
- * @summary Fetch the conversation document
- */
-export const GetThreadParams = zod.strictObject({
-    thread: zod.string(),
-});
-/**
- * Changes the title, folder, approval mode, model preference, and whether the conversation is archived. Approval and model preference changes take effect from the next turn; a turn already running keeps the settings it started with.
- *
- * Omit preferredModelId to leave the preference unchanged, or set it to null to follow the platform default. A non-null preference is accepted only while model selection is enabled; otherwise the whole request fails with 403 and code MODEL_SELECTION_DISABLED and none of its fields are changed. Clearing a preference remains allowed while selection is disabled. A well-formed preference for a disallowed, retired or removed Canopy model is retained and falls back to the default when used.
- *
- * Model switching is allowed on an existing conversation, including while a turn is generating or waiting for approval or an answer. The response immediately returns the saved preferredModelId, while model continues to identify the running turn's effective model until it finishes. Messages queued into that running turn also keep its captured model choices. The next turn uses the latest saved preference.
- *
- * Changing the preference does not create a new conversation, start a turn, call a model provider, clear the transcript, or rewrite historical model attribution. Before the next turn sends its first request to the selected model, the service checks that model's input capabilities and usable context budget. A switch to a smaller window may require compaction under the compaction policy above; saving the preference alone does not establish that the conversation fits.
- *
- * Archiving makes a conversation read-only: it stays in the list under "archived", stays readable, and the assistant can still find it when it searches past conversations — it just takes no new input. Unarchive it to continue. Archiving fails while a turn is running; stop it first.
- * @summary Update conversation settings
- */
-export const UpdateThreadParams = zod.strictObject({
-    thread: zod.string(),
-});
-export const UpdateThreadBody = UpdateThreadRequestBody;
-/**
- * Removes the conversation from every list and makes it unreachable by id. The assistant can no longer find it either — neither by searching past conversations nor by reading one back.
- *
- * Deleting is not the same as archiving, and the two are not degrees of the same thing. An archived conversation is still there and still readable, it just takes no new input; a deleted one is gone from view. Archiving can be undone; this cannot.
- *
- * What survives is the record itself, because a conversation with this assistant is an account of what was done to real infrastructure — which machine was changed, which disk was removed. That record is kept even though nobody can reach it here.
- *
- * Fails while a turn is running: stop it first. Deleting an already deleted conversation succeeds and changes nothing.
- * @summary Delete a conversation
- */
-export const DeleteThreadParams = zod.strictObject({
-    thread: zod.string(),
-});
-/**
- * The batch id comes from the conversation document's `wait`. This is idempotent: submitting the same batch again neither changes a decision already in effect nor reports an error. Returns 404 when the batch does not belong to that conversation.
- * @summary Approve or decline a batch of tool calls
- */
-export const DecideApprovalParams = zod.strictObject({
-    thread: zod.string(),
-    batch: zod.string(),
-});
-export const DecideApprovalBody = DecideRequestBody;
-/**
- * The first render only carries the latest stretch of a conversation; anything above it is fetched here, one stretch at a time. Pass the document's earlier.before as `before`; the `earlier` in the response is the cursor for the stretch above that, and null means the top has been reached. The entries have the same shape and the same order (oldest first) as `items` in the document, so they can be prepended as they are.
- * @summary Fetch earlier parts of a conversation
- */
-export const ListEarlierItemsParams = zod.strictObject({
-    thread: zod.string(),
-});
-export const listEarlierItemsQueryBeforeMin = 0;
-export const ListEarlierItemsQueryParams = zod.strictObject({
-    before: zod
-        .int()
-        .min(listEarlierItemsQueryBeforeMin)
-        .describe("From the document's earlier.before; returns entries before this ordinal"),
-});
-/**
- * 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 InterruptThreadParams = zod.strictObject({
-    thread: zod.string(),
-});
-/**
- * Returns a turnId immediately without waiting for execution — a turn can run for tens of minutes. Progress arrives on the live stream the conversation document's `stream` points at, not in this response. Sending while the assistant is still working is allowed: the message is put in line and `queued` comes back true, to be read at the next step of the turn already running — so the editor should stay open rather than blocking on a busy conversation.
- * @summary Send a message and start a turn
- */
-export const SendMessageParams = zod.strictObject({
-    thread: zod.string(),
-});
-export const SendMessageBody = SendMessageRequestBody;
-/**
- * The question id comes from the conversation document's `wait`. An already-answered question also returns 204 — another tab may have submitted first, or the auto-answer window may have expired, and in both cases the turn has already continued with an answer.
- * @summary Answer the assistant's questions
- */
-export const AnswerQuestionParams = zod.strictObject({
-    thread: zod.string(),
-    item: zod.string(),
-});
-export const AnswerQuestionBody = AnswerRequestBody;
-/**
- * @summary Mark a conversation as read
- */
-export const MarkThreadReadParams = zod.strictObject({
-    thread: zod.string(),
-});
-/**
- * Reverts the entry at `ordinal` and everything after it. Reverted entries stay in the transcript marked `reverted`, and ordinals are not renumbered. Returns how many were actually reverted.
- * @summary Revert from a given point
- */
-export const RevertThreadParams = zod.strictObject({
-    thread: zod.string(),
-});
-export const RevertThreadBody = RevertRequestBody;