@leaflow/sdk 0.108.0 → 0.110.0

package/dist/assistant/v1/generated/models.d.ts

@@ -0,0 +1,1310 @@
+/**
+ * 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.
+ *
+ * ## A conversation
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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
+ */
+export type ModelResourceInputModalitiesItem = (typeof ModelResourceInputModalitiesItem)[keyof typeof ModelResourceInputModalitiesItem];
+export declare const ModelResourceInputModalitiesItem: {
+    readonly text: "text";
+    readonly image: "image";
+};
+/**
+ * A read-only view of a Canopy model. No model definition is created or edited through Assistant.
+ */
+export interface ModelResource {
+    /**
+     * Canopy model id, used unchanged in settings, conversation preferences and inference. There is no second assistant model id.
+     * @minLength 1
+     * @maxLength 128
+     */
+    id: string;
+    /** The display_name maintained in Canopy */
+    displayName: string;
+    /**
+     * The context_length maintained in Canopy. The assistant reserves room for instructions, tools and an answer rather than using this entire window for history.
+     * @minimum 1
+     */
+    contextWindow: number;
+    /**
+     * The max_output_tokens maintained in Canopy. Answer and summary budgets must respect this limit and the remaining context capacity.
+     * @minimum 1
+     */
+    maxOutputTokens: number;
+    /** Canopy supports_tools. Must be true before the model can be allowed for Assistant. */
+    supportsTools: boolean;
+    /** Canopy supports_reasoning. False requires reasoning_effort to be omitted. */
+    supportsReasoning: boolean;
+    /** Levels reported by Canopy reasoning_tiers. An empty list requires reasoning_effort to be omitted. List order does not imply reasoning strength. */
+    reasoningTiers: string[];
+    /**
+     * Contains text, and also image when Canopy reports supports_vision. Other attachments remain accessible through file tools.
+     * @minItems 1
+     */
+    inputModalities: ModelResourceInputModalitiesItem[];
+}
+export interface ModelListResponseBody {
+    /** Whether users can set a non-null model preference. When false, hide the selector and use the platform default for new turns. */
+    allowModelSelection: boolean;
+    /**
+     * The default Canopy model id, present in models when non-null. Null means no usable default is known from the current allowlist and capability snapshot; it does not report live provider health.
+     * @minLength 1
+     * @maxLength 128
+     * @nullable
+     */
+    defaultModelId: string | null;
+    /** Allowed, usable Canopy choices, or only the default when selection is disabled. Empty is an empty array, never null. */
+    models: ModelResource[];
+}
+/**
+ * What a given `code` carries alongside the message. The keys depend on the code,
+ * and a client that does not recognise one ignores it.
+ */
+export type ErrorMeta = {
+    [key: string]: unknown;
+};
+export interface Error {
+    code?: string;
+    message: string;
+    /**
+     * What a given `code` carries alongside the message. The keys depend on the code,
+     * and a client that does not recognise one ignores it.
+     */
+    meta?: ErrorMeta;
+    status: number;
+}
+/**
+ * How the assistant will see this file.
+ *
+ * - `image` — read directly, and only by models that accept image input
+ * - `text` — placed inline in the message when small enough, otherwise read on demand
+ * - `binary` — never read directly; the assistant downloads it onto a cloud instance to work with it
+ */
+export type UploadedResourceKind = (typeof UploadedResourceKind)[keyof typeof UploadedResourceKind];
+export declare const UploadedResourceKind: {
+    readonly image: "image";
+    readonly text: "text";
+    readonly binary: "binary";
+};
+export interface UploadedResource {
+    /** Size of what was stored. For an image that has been resized, this is the resized size, not what was uploaded. */
+    byteSize: number;
+    /**
+     * When this upload gets cleared if no message ever references it. Sending a message with this id makes it permanent and this stops applying — a file that belongs to a conversation is kept as long as the conversation is.
+     *
+     * It is here so the editor can say so before it happens. An attachment chip that quietly stops working a week later reads as a bug, and the person who hits it has no way to tell that what they are seeing is a draft being collected.
+     */
+    draftExpiresAt: string;
+    filename: string;
+    /**
+     * Null unless kind is image.
+     * @nullable
+     */
+    height: number | null;
+    id: string;
+    /**
+     * How the assistant will see this file.
+     *
+     * - `image` — read directly, and only by models that accept image input
+     * - `text` — placed inline in the message when small enough, otherwise read on demand
+     * - `binary` — never read directly; the assistant downloads it onto a cloud instance to work with it
+     */
+    kind: UploadedResourceKind;
+    /**
+     * Null unless kind is image.
+     * @nullable
+     */
+    width: number | null;
+}
+export type BindingResourceConnState = (typeof BindingResourceConnState)[keyof typeof BindingResourceConnState];
+export declare const BindingResourceConnState: {
+    readonly logged_out: "logged_out";
+    readonly qr_pending: "qr_pending";
+    readonly online: "online";
+    readonly expired: "expired";
+};
+export type BindingResourceStatus = (typeof BindingResourceStatus)[keyof typeof BindingResourceStatus];
+export declare const BindingResourceStatus: {
+    readonly pending: "pending";
+    readonly active: "active";
+    readonly revoked: "revoked";
+};
+export interface BindingResource {
+    channelId: string;
+    connState: BindingResourceConnState;
+    createdAt: string;
+    id: string;
+    peerName: string;
+    platform: string;
+    status: BindingResourceStatus;
+    /** @nullable */
+    verifiedAt: string | null;
+}
+export interface LengthAwarePageBindingResource {
+    /** The entries on this page */
+    items: BindingResource[];
+    /** The page size, echoing what was requested */
+    limit: number;
+    /** How many were skipped, echoing what was requested */
+    offset: number;
+    /** How many match in total, not just on this page */
+    total: number;
+}
+/**
+ * How far this channel is from working. Only `online` receives messages and can issue binding codes
+ */
+export type ChannelResourceConnState = (typeof ChannelResourceConnState)[keyof typeof ChannelResourceConnState];
+export declare const ChannelResourceConnState: {
+    readonly logged_out: "logged_out";
+    readonly qr_pending: "qr_pending";
+    readonly online: "online";
+    readonly expired: "expired";
+};
+/**
+ * The state of the long-lived connection right now. Always `stopped` for webhook platforms
+ */
+export type ChannelResourceRuntimeState = (typeof ChannelResourceRuntimeState)[keyof typeof ChannelResourceRuntimeState];
+export declare const ChannelResourceRuntimeState: {
+    readonly stopped: "stopped";
+    readonly running: "running";
+};
+export type ChannelResourceSenderPolicy = (typeof ChannelResourceSenderPolicy)[keyof typeof ChannelResourceSenderPolicy];
+export declare const ChannelResourceSenderPolicy: {
+    readonly bound_only: "bound_only";
+    readonly open: "open";
+};
+export type ChannelResourceStatus = (typeof ChannelResourceStatus)[keyof typeof ChannelResourceStatus];
+export declare const ChannelResourceStatus: {
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly disabled: "disabled";
+};
+export interface ChannelResource {
+    /** @nullable */
+    allowFrom: string[] | null;
+    /** How far this channel is from working. Only `online` receives messages and can issue binding codes */
+    connState: ChannelResourceConnState;
+    createdAt: string;
+    id: string;
+    name: string;
+    platform: string;
+    /** The state of the long-lived connection right now. Always `stopped` for webhook platforms */
+    runtimeState: ChannelResourceRuntimeState;
+    senderPolicy: ChannelResourceSenderPolicy;
+    status: ChannelResourceStatus;
+    updatedAt: string;
+    /** The webhook path, for gateway configuration and for diagnosis */
+    webhookPath: string;
+    /**
+     * The webhook address to paste into that platform's console. Null when the deployment declares no public entry point
+     * @nullable
+     */
+    webhookUrl: string | null;
+}
+export interface LengthAwarePageChannelResource {
+    /** The entries on this page */
+    items: ChannelResource[];
+    /** The page size, echoing what was requested */
+    limit: number;
+    /** How many were skipped, echoing what was requested */
+    offset: number;
+    /** How many match in total, not just on this page */
+    total: number;
+}
+/**
+ * Credentials for that platform. Write-only: they cannot be read back after creation
+ */
+export type CreateChannelRequestBodyCredentials = {
+    [key: string]: string;
+};
+export type CreateChannelRequestBodySenderPolicy = (typeof CreateChannelRequestBodySenderPolicy)[keyof typeof CreateChannelRequestBodySenderPolicy];
+export declare const CreateChannelRequestBodySenderPolicy: {
+    readonly bound_only: "bound_only";
+    readonly open: "open";
+};
+export interface CreateChannelRequestBody {
+    /** @nullable */
+    allowFrom?: string[] | null;
+    /** Credentials for that platform. Write-only: they cannot be read back after creation */
+    credentials?: CreateChannelRequestBodyCredentials;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+    /** @minLength 1 */
+    platform: string;
+    senderPolicy?: CreateChannelRequestBodySenderPolicy;
+    /** Required for platforms that generate the secret themselves (secretSource=supplied). Must be absent for `generated` ones, where the secret we make is returned once in webhookSecret on this response */
+    webhookSecret?: string;
+}
+/**
+ * How far this channel is from working. Only `online` receives messages and can issue binding codes
+ */
+export type ChannelWithSecretResponseBodyConnState = (typeof ChannelWithSecretResponseBodyConnState)[keyof typeof ChannelWithSecretResponseBodyConnState];
+export declare const ChannelWithSecretResponseBodyConnState: {
+    readonly logged_out: "logged_out";
+    readonly qr_pending: "qr_pending";
+    readonly online: "online";
+    readonly expired: "expired";
+};
+/**
+ * The state of the long-lived connection right now. Always `stopped` for webhook platforms
+ */
+export type ChannelWithSecretResponseBodyRuntimeState = (typeof ChannelWithSecretResponseBodyRuntimeState)[keyof typeof ChannelWithSecretResponseBodyRuntimeState];
+export declare const ChannelWithSecretResponseBodyRuntimeState: {
+    readonly stopped: "stopped";
+    readonly running: "running";
+};
+export type ChannelWithSecretResponseBodySenderPolicy = (typeof ChannelWithSecretResponseBodySenderPolicy)[keyof typeof ChannelWithSecretResponseBodySenderPolicy];
+export declare const ChannelWithSecretResponseBodySenderPolicy: {
+    readonly bound_only: "bound_only";
+    readonly open: "open";
+};
+export type ChannelWithSecretResponseBodyStatus = (typeof ChannelWithSecretResponseBodyStatus)[keyof typeof ChannelWithSecretResponseBodyStatus];
+export declare const ChannelWithSecretResponseBodyStatus: {
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly disabled: "disabled";
+};
+export interface ChannelWithSecretResponseBody {
+    /** @nullable */
+    allowFrom: string[] | null;
+    /** How far this channel is from working. Only `online` receives messages and can issue binding codes */
+    connState: ChannelWithSecretResponseBodyConnState;
+    createdAt: string;
+    id: string;
+    name: string;
+    platform: string;
+    /** The state of the long-lived connection right now. Always `stopped` for webhook platforms */
+    runtimeState: ChannelWithSecretResponseBodyRuntimeState;
+    senderPolicy: ChannelWithSecretResponseBodySenderPolicy;
+    status: ChannelWithSecretResponseBodyStatus;
+    updatedAt: string;
+    /** The webhook path, for gateway configuration and for diagnosis */
+    webhookPath: string;
+    /**
+     * The webhook secret we generated, to paste into that platform's console. **It cannot be retrieved again** — the only way forward is rotating to a new one. Null when the platform generates the secret (secretSource=supplied) or does not use webhooks at all
+     * @nullable
+     */
+    webhookSecret: string | null;
+    /**
+     * The webhook address to paste into that platform's console. Null when the deployment declares no public entry point
+     * @nullable
+     */
+    webhookUrl: string | null;
+}
+/**
+ * Replaced wholesale rather than merged key by key. Absent means unchanged
+ */
+export type UpdateChannelRequestBodyCredentials = {
+    [key: string]: string;
+};
+/**
+ * Only when this is sent is allowFrom replaced along with it
+ */
+export type UpdateChannelRequestBodySenderPolicy = (typeof UpdateChannelRequestBodySenderPolicy)[keyof typeof UpdateChannelRequestBodySenderPolicy];
+export declare const UpdateChannelRequestBodySenderPolicy: {
+    readonly bound_only: "bound_only";
+    readonly open: "open";
+};
+export interface UpdateChannelRequestBody {
+    /**
+     * The allow list. Only applied when senderPolicy is sent as well
+     * @nullable
+     */
+    allowFrom?: string[] | null;
+    /** Replaced wholesale rather than merged key by key. Absent means unchanged */
+    credentials?: UpdateChannelRequestBodyCredentials;
+    enabled?: boolean;
+    /** @maxLength 128 */
+    name?: string;
+    /** Only when this is sent is allowFrom replaced along with it */
+    senderPolicy?: UpdateChannelRequestBodySenderPolicy;
+}
+export interface BindingCodeResponseBody {
+    code: string;
+    expiresAt: string;
+}
+export type PartResourceType = (typeof PartResourceType)[keyof typeof PartResourceType];
+export declare const PartResourceType: {
+    readonly text: "text";
+    readonly file: "file";
+};
+export interface PartResource {
+    /**
+     * For `file` parts. Points at one of this entry's `attachments`.
+     * @nullable
+     */
+    attachmentId?: string | null;
+    /**
+     * Addresses this part in the live stream — text arrives as `append` frames pointing at
+     * `/items/{item}/parts/{id}/text`.
+     *
+     * Not an array index. It looks like one today because parts are only ever appended, and a
+     * client that treats it as one keeps working right up until that stops being true.
+     */
+    id: string;
+    /**
+     * For `text` parts. Grows as the answer is written.
+     * @nullable
+     */
+    text?: string | null;
+    type: PartResourceType;
+}
+export interface RejectionResource {
+    at: string;
+    peerId: string;
+    peerName: string;
+    peerUsername: string;
+    platform: string;
+    textLength: number;
+    verdict: string;
+}
+export interface RejectionListResponseBody {
+    /** @nullable */
+    rejections: RejectionResource[] | null;
+}
+export interface RotateSecretRequestBody {
+    /** Required for platforms that generate the secret themselves (secretSource=supplied). Must be absent for `generated` ones */
+    webhookSecret?: string;
+}
+export interface WebhookSecretResponseBody {
+    webhookSecret: string;
+}
+export type SenderCheckResourceVerdict = (typeof SenderCheckResourceVerdict)[keyof typeof SenderCheckResourceVerdict];
+export declare const SenderCheckResourceVerdict: {
+    readonly ALLOWED_BY_BINDING: "ALLOWED_BY_BINDING";
+    readonly ALLOWED_BY_ALLOW_FROM: "ALLOWED_BY_ALLOW_FROM";
+    readonly ALLOWED_BY_POLICY: "ALLOWED_BY_POLICY";
+    readonly REJECTED_NOT_ALLOWED: "REJECTED_NOT_ALLOWED";
+};
+export interface SenderCheckResource {
+    /** @nullable */
+    allowFrom: string[] | null;
+    allowed: boolean;
+    /** @nullable */
+    bindingId: string | null;
+    senderPolicy: string;
+    verdict: SenderCheckResourceVerdict;
+}
+export type LoginResourceStatus = (typeof LoginResourceStatus)[keyof typeof LoginResourceStatus];
+export declare const LoginResourceStatus: {
+    readonly wait: "wait";
+    readonly scanned: "scanned";
+    readonly confirmed: "confirmed";
+    readonly expired: "expired";
+    readonly error: "error";
+    readonly need_verify_code: "need_verify_code";
+};
+export interface LoginResource {
+    /** When this login flow expires. Past that, stop polling and start a new one */
+    expiresAt: string;
+    id: string;
+    /** The text to encode and render as a QR code by the client — not an image address and not a data URI. When a code expires this flow issues another and keeps waiting, so each poll may return a new string */
+    qrcodeData: string;
+    /** Why it failed. Present only when status is error or expired */
+    reason: string;
+    status: LoginResourceStatus;
+}
+export interface CredentialFieldResource {
+    help: string;
+    key: string;
+    label: string;
+    required: boolean;
+    secret: boolean;
+}
+export type PlatformResourceSecretSource = (typeof PlatformResourceSecretSource)[keyof typeof PlatformResourceSecretSource];
+export declare const PlatformResourceSecretSource: {
+    readonly generated: "generated";
+    readonly supplied: "supplied";
+    readonly none: "none";
+};
+export type PlatformResourceSetupChallenge = (typeof PlatformResourceSetupChallenge)[keyof typeof PlatformResourceSetupChallenge];
+export declare const PlatformResourceSetupChallenge: {
+    readonly none: "none";
+    readonly webhook: "webhook";
+    readonly scan: "scan";
+};
+export type PlatformResourceSetupMethod = (typeof PlatformResourceSetupMethod)[keyof typeof PlatformResourceSetupMethod];
+export declare const PlatformResourceSetupMethod: {
+    readonly credentials: "credentials";
+    readonly scan: "scan";
+};
+export interface PlatformResource {
+    /** @nullable */
+    credentialFields: CredentialFieldResource[] | null;
+    name: string;
+    resident: boolean;
+    secretSource: PlatformResourceSecretSource;
+    setupChallenge: PlatformResourceSetupChallenge;
+    setupMethod: PlatformResourceSetupMethod;
+    /** The webhook path template; {channel} is replaced with the channel id */
+    webhookPath: string;
+    /**
+     * The full webhook address template. Null when the deployment declares no public entry point
+     * @nullable
+     */
+    webhookUrlTemplate: string | null;
+}
+export interface PlatformListResponseBody {
+    /** @nullable */
+    platforms: PlatformResource[] | null;
+}
+export interface VerifyCodeRequestBody {
+    /** @minLength 1 */
+    code: string;
+}
+/**
+ * Path to contents, `SKILL.md` among them. Only returned by `get-skill`; the list leaves it out.
+ * @nullable
+ */
+export type SkillResourceFiles = {
+    [key: string]: string;
+} | null;
+/**
+ * `builtin` — provided by the platform and read-only here.
+ * `project` — written for this project and editable by anyone in it.
+ */
+export type SkillResourceOrigin = (typeof SkillResourceOrigin)[keyof typeof SkillResourceOrigin];
+export declare const SkillResourceOrigin: {
+    readonly builtin: "builtin";
+    readonly project: "project";
+};
+export interface SkillResource {
+    /**
+     * True when the assistant wrote this skill during a conversation rather than a person
+     * writing it here.
+     *
+     * Which conversation is deliberately not returned: skills are shared across the project
+     * while conversations belong to one person, so naming one would tell everybody in the
+     * project that a particular colleague had it.
+     */
+    authoredByAssistant: boolean;
+    /** Why the assistant would open this skill. It sits in every request, so it is the one field worth writing carefully. */
+    description: string;
+    enabled: boolean;
+    /**
+     * Path to contents, `SKILL.md` among them. Only returned by `get-skill`; the list leaves it out.
+     * @nullable
+     */
+    files?: SkillResourceFiles;
+    name: string;
+    /**
+     * `builtin` — provided by the platform and read-only here.
+     * `project` — written for this project and editable by anyone in it.
+     */
+    origin: SkillResourceOrigin;
+    /** @nullable */
+    shortDescription: string | null;
+    /**
+     * Null for built-in skills, which have no edit history here.
+     * @nullable
+     */
+    updatedAt: string | null;
+}
+export interface SkillListResponseBody {
+    skills: SkillResource[];
+}
+/**
+ * Path to contents. `SKILL.md` is required; anything else it references goes alongside it.
+ *
+ * Paths are relative to the skill and cannot leave it. At most 32 files, 256 KiB each and
+ * 1 MiB in total.
+ */
+export type SkillRequestBodyFiles = {
+    [key: string]: string;
+};
+export interface SkillRequestBody {
+    /**
+     * Why the assistant would open this skill. It sits in every request; write it as the answer to "when do I need this", not "what does it contain".
+     * @minLength 1
+     * @maxLength 1024
+     */
+    description: string;
+    enabled?: boolean;
+    /**
+     * Path to contents. `SKILL.md` is required; anything else it references goes alongside it.
+     *
+     * Paths are relative to the skill and cannot leave it. At most 32 files, 256 KiB each and
+     * 1 MiB in total.
+     */
+    files: SkillRequestBodyFiles;
+    /**
+     * Also how the assistant refers to it, so renaming is deleting and writing again.
+     * @minLength 1
+     * @maxLength 64
+     */
+    name: string;
+    /** @maxLength 1024 */
+    shortDescription?: string;
+}
+export interface SkillEnabledRequestBody {
+    enabled: boolean;
+}
+export type ThreadSummaryResourceApprovalMode = (typeof ThreadSummaryResourceApprovalMode)[keyof typeof ThreadSummaryResourceApprovalMode];
+export declare const ThreadSummaryResourceApprovalMode: {
+    readonly guardian: "guardian";
+    readonly manual: "manual";
+    readonly yolo: "yolo";
+};
+export interface ThreadSummaryResource {
+    approvalMode: ThreadSummaryResourceApprovalMode;
+    archived: boolean;
+    createdAt: string;
+    /**
+     * The folder this conversation is filed under, or null when it is in none
+     * @nullable
+     */
+    folderId: string | null;
+    id: string;
+    /**
+     * The actual Canopy model id for the running turn, or the first candidate for the next turn when idle. Null when no model can be selected. This can differ from preferredModelId after fallback or while selection is disabled.
+     * @nullable
+     */
+    model: string | null;
+    /**
+     * The saved preferred Canopy model id, independent of the model actually used. Null follows the platform default. Kept when selection is disabled, the model is removed, or a request falls back.
+     * @minLength 1
+     * @maxLength 128
+     * @nullable
+     */
+    preferredModelId: string | null;
+    /** @nullable */
+    title: string | null;
+    unread: boolean;
+    updatedAt: string;
+}
+export interface ThreadListResponseBody {
+    /**
+     * Pass this back as `cursor` for the next page. Null means this was the last one — it is only set when there is genuinely more, so an empty final page never happens.
+     * @nullable
+     */
+    nextCursor: string | null;
+    /** @nullable */
+    threads: ThreadSummaryResource[] | null;
+}
+/**
+ * Absent uses the platform's default approval mode
+ */
+export type CreateThreadRequestBodyApprovalMode = (typeof CreateThreadRequestBodyApprovalMode)[keyof typeof CreateThreadRequestBodyApprovalMode];
+export declare const CreateThreadRequestBodyApprovalMode: {
+    readonly guardian: "guardian";
+    readonly manual: "manual";
+    readonly yolo: "yolo";
+};
+export interface CreateThreadRequestBody {
+    /** Absent uses the platform's default approval mode */
+    approvalMode?: CreateThreadRequestBodyApprovalMode;
+    /**
+     * A Canopy model id to prefer. Omit or pass null to follow the platform default. Non-null requires allowModelSelection; a disallowed, retired or removed id falls back to the default without clearing the preference.
+     * @minLength 1
+     * @maxLength 128
+     * @nullable
+     */
+    preferredModelId?: string | null;
+}
+export interface ContextResource {
+    /** @nullable */
+    compactAt: number | null;
+    /**
+     * What kinds of input the model behind this conversation accepts, as modality names: text, image.
+     *
+     * This governs images and nothing else. Text and binary attachments reach every model: a small text file is placed inline, a large one is read on demand, and a binary is downloaded onto a cloud instance — none of which asks the model to see a picture. So this decides whether pasting a screenshot does anything, not whether the attach control exists. Hiding file upload on a text-only model takes away something that would have worked.
+     *
+     * This describes the effective model, including a replacement chosen through fallback, rather than the saved preference. An empty list means no effective model is available to describe; it is not a claim that every model rejects files.
+     */
+    inputModalities: string[];
+    /**
+     * The effective Canopy model id, matching the conversation summary's model. Null when no model can be selected; window and compactAt are then null and inputModalities is empty.
+     * @nullable
+     */
+    model: string | null;
+    /** @nullable */
+    used: number | null;
+    warnAt: number;
+    /** @nullable */
+    window: number | null;
+}
+export interface EarlierResource {
+    before: number;
+    foldedAbove: boolean;
+}
+/**
+ * What this attachment is. A client renders an image in place and everything else as a file to download.
+ */
+export type AttachmentResourceKind = (typeof AttachmentResourceKind)[keyof typeof AttachmentResourceKind];
+export declare const AttachmentResourceKind: {
+    readonly image: "image";
+    readonly text: "text";
+    readonly binary: "binary";
+};
+export interface AttachmentResource {
+    byteSize: number;
+    filename: string;
+    /**
+     * Null unless kind is image. Width and height are here so a client can hold the space before the image itself has loaded.
+     * @nullable
+     */
+    height: number | null;
+    id: string;
+    /** What this attachment is. A client renders an image in place and everything else as a file to download. */
+    kind: AttachmentResourceKind;
+    /**
+     * Null unless kind is image.
+     * @nullable
+     */
+    width: number | null;
+}
+/**
+ * @nullable
+ */
+export type ItemResourceApproval = (typeof ItemResourceApproval)[keyof typeof ItemResourceApproval] | null;
+export declare const ItemResourceApproval: {
+    readonly approved: "approved";
+    readonly declined: "declined";
+    readonly auto_approved: "auto_approved";
+    readonly unreviewed: "unreviewed";
+};
+export type ItemResourceStatus = (typeof ItemResourceStatus)[keyof typeof ItemResourceStatus];
+export declare const ItemResourceStatus: {
+    readonly pending: "pending";
+    readonly in_progress: "in_progress";
+    readonly completed: "completed";
+    readonly failed: "failed";
+    readonly declined: "declined";
+    readonly interrupted: "interrupted";
+};
+/**
+ * Determines which fields this entry carries
+ */
+export type ItemResourceType = (typeof ItemResourceType)[keyof typeof ItemResourceType];
+export declare const ItemResourceType: {
+    readonly user_message: "user_message";
+    readonly agent_message: "agent_message";
+    readonly reasoning: "reasoning";
+    readonly dynamic_tool_call: "dynamic_tool_call";
+    readonly context_compaction: "context_compaction";
+    readonly token_budget_reminder: "token_budget_reminder";
+    readonly turn_failure: "turn_failure";
+};
+export type ClientContextPartData = {
+    [key: string]: unknown;
+};
+/**
+ * A `data-*` part as it was sent.
+ */
+export interface ClientContextPart {
+    data: ClientContextPartData;
+    type: string;
+}
+/**
+ * What the call did to the file
+ */
+export type FileDiffResourceStatus = (typeof FileDiffResourceStatus)[keyof typeof FileDiffResourceStatus];
+export declare const FileDiffResourceStatus: {
+    readonly added: "added";
+    readonly modified: "modified";
+    readonly deleted: "deleted";
+};
+/**
+ * The change a tool call applied to a single file.
+ *
+ * Populated once the call has completed successfully. It is absent while the call is pending
+ * or awaiting approval, as the file's prior contents are read during execution. To preview an
+ * edit awaiting approval, derive it from the call's `old_string` and `new_string` arguments.
+ */
+export interface FileDiffResource {
+    /** Lines added. Complete even when `unified` is null */
+    added: number;
+    /** Absolute path of the file on the instance */
+    path: string;
+    /** Lines removed. Complete even when `unified` is null */
+    removed: number;
+    /** What the call did to the file */
+    status: FileDiffResourceStatus;
+    /**
+     * The change as a unified diff with three lines of context. A file created by the call is
+     * diffed against `/dev/null`.
+     *
+     * Null when the change exceeds the service's size limit. The diff is omitted in full
+     * rather than truncated; `added` and `removed` remain complete.
+     * @nullable
+     */
+    unified?: string | null;
+}
+/**
+ * Determines which of the remaining fields is populated
+ */
+export type PresentationResourceKind = (typeof PresentationResourceKind)[keyof typeof PresentationResourceKind];
+export declare const PresentationResourceKind: {
+    readonly file_diff: "file_diff";
+};
+/**
+ * Structured detail produced by a tool call, in addition to the single-line `detail`. Null
+ * when the call produced none.
+ *
+ * `kind` determines which of the remaining fields is populated.
+ */
+export interface PresentationResource {
+    fileDiff?: FileDiffResource | null;
+    /** Determines which of the remaining fields is populated */
+    kind: PresentationResourceKind;
+}
+export interface ItemResource {
+    /** @nullable */
+    approval?: ItemResourceApproval;
+    /** @nullable */
+    approvalReason?: string | null;
+    arguments?: string;
+    /** @nullable */
+    attachments?: AttachmentResource[] | null;
+    /**
+     * The context blocks the client attached to this message.
+     *
+     * **Not part of what the operator wrote** — `text` is. Render the message from `text` and
+     * leave these out of the bubble; they are here so a client that did not send them, or one
+     * that reloaded, can still read what the assistant was given.
+     *
+     * The actions declared alongside them are not returned: they are re-declared as they
+     * change and would make every fetch of the conversation carry them again.
+     * @nullable
+     */
+    clientContext?: ClientContextPart[] | null;
+    createdAt: string;
+    /** @nullable */
+    detail?: string | null;
+    presentation?: PresentationResource | null;
+    /** @nullable */
+    durationMs?: number | null;
+    id: string;
+    /**
+     * The Canopy model id that actually produced this entry, including after fallback. Never replaced by the conversation's preference or rewritten when the model is retired or removed from the allowlist. Null for messages the user sent.
+     * @nullable
+     */
+    model: string | null;
+    /** @nullable */
+    namespace?: string | null;
+    ordinal: number;
+    reverted: boolean;
+    status: ItemResourceStatus;
+    /** @nullable */
+    target?: string | null;
+    /**
+     * The content of this entry, in the order it was written. A message that is only text is a
+     * single part, which is most of them.
+     *
+     * An attachment belongs where it was written, so render these in order rather than putting
+     * them all at the end.
+     * @nullable
+     */
+    parts?: PartResource[] | null;
+    /** @nullable */
+    tool?: string | null;
+    /** Determines which fields this entry carries */
+    type: ItemResourceType;
+}
+export interface StreamResource {
+    path: string;
+    ticket: string;
+}
+export type TurnResourceApprovalMode = (typeof TurnResourceApprovalMode)[keyof typeof TurnResourceApprovalMode];
+export declare const TurnResourceApprovalMode: {
+    readonly guardian: "guardian";
+    readonly manual: "manual";
+    readonly yolo: "yolo";
+};
+export interface TurnResource {
+    approvalMode: TurnResourceApprovalMode;
+}
+export interface Choice {
+    description: string;
+    label: string;
+}
+export interface Question {
+    /** @nullable */
+    choices: Choice[] | null;
+    header: string;
+    id: string;
+    question: string;
+}
+export type WaitResourceKind = (typeof WaitResourceKind)[keyof typeof WaitResourceKind];
+export declare const WaitResourceKind: {
+    readonly tool_approval: "tool_approval";
+    readonly user_input: "user_input";
+};
+export interface WaitResource {
+    autoResolutionMs?: number;
+    batchId?: string;
+    itemId?: string;
+    /** @nullable */
+    itemIds?: string[] | null;
+    kind: WaitResourceKind;
+    /** @nullable */
+    questions?: Question[] | null;
+    turnId: string;
+}
+/**
+ * Where this step stands. At most one item is in_progress at any time.
+ */
+export type TodoResourceStatus = (typeof TodoResourceStatus)[keyof typeof TodoResourceStatus];
+export declare const TodoResourceStatus: {
+    readonly pending: "pending";
+    readonly in_progress: "in_progress";
+    readonly completed: "completed";
+};
+export interface TodoResource {
+    /** The same step phrased as happening now — "Installing nginx". Show this one while the item is in progress. */
+    activeForm: string;
+    /** The step as an instruction — "Install nginx". */
+    content: string;
+    /** Where this step stands. At most one item is in_progress at any time. */
+    status: TodoResourceStatus;
+}
+export interface DocumentResource {
+    context: ContextResource;
+    /** @nullable */
+    cursor: string | null;
+    earlier: EarlierResource | null;
+    /** @nullable */
+    items: ItemResource[] | null;
+    status: string;
+    stream: StreamResource | null;
+    turn: TurnResource | null;
+    /** The assistant's checklist for the work in this conversation, in the order it intends to do it. Empty when it has not written one — short tasks do not get a list. It is rewritten in full each time, so what is here is the current state. */
+    todos?: TodoResource[];
+    /** @nullable */
+    turnId: string | null;
+    wait: WaitResource | null;
+}
+export type UpdateThreadRequestBodyApprovalMode = (typeof UpdateThreadRequestBodyApprovalMode)[keyof typeof UpdateThreadRequestBodyApprovalMode];
+export declare const UpdateThreadRequestBodyApprovalMode: {
+    readonly guardian: "guardian";
+    readonly manual: "manual";
+    readonly yolo: "yolo";
+};
+export interface UpdateThreadRequestBody {
+    approvalMode?: UpdateThreadRequestBodyApprovalMode;
+    archived?: boolean;
+    /**
+     * Switch this existing conversation's model. Omit to keep the preference; null clears it and follows the platform default; a string sets it for the next turn. The transcript is preserved and saving the preference does not start a turn.
+     *
+     * Non-null requires allowModelSelection. A disallowed, retired or removed Canopy id is retained and uses the default when needed. The preference can be changed while a turn is running or waiting, but that turn and messages queued into it keep their captured model choices.
+     * @minLength 1
+     * @maxLength 128
+     * @nullable
+     */
+    preferredModelId?: string | null;
+    /**
+     * File this conversation into a folder, or `null` to take it out of the one it is in. Omit the field to leave it where it is.
+     *
+     * Filing does not move the conversation in the list. The order answers "which conversation has something new in it", and putting one away is not that.
+     * @maxLength 64
+     * @nullable
+     */
+    folderId?: string | null;
+    /**
+     * Rename this conversation.
+     *
+     * A conversation names itself: the first message gives it a working title, and the assistant replaces that with a better one once it has answered. Setting this stops both — a name somebody chose is never overwritten by one that was generated.
+     *
+     * Renaming does not move the conversation in the list. The order answers "which conversation has something new in it", and editing a title is not that.
+     * @minLength 1
+     * @maxLength 255
+     */
+    title?: string;
+}
+export interface DecideRequestBody {
+    approved: boolean;
+    reason?: string;
+}
+export interface EarlierResponseBody {
+    earlier: EarlierResource;
+    /** @nullable */
+    items: ItemResource[] | null;
+}
+/**
+ * The MCP and Anthropic spelling of `parameters`. Give one or the other, not both.
+ * @nullable
+ */
+export type ClientFunctionRequestInputSchema = {
+    [key: string]: unknown;
+} | null;
+/**
+ * JSON Schema for the arguments. Omit for an action that takes none.
+ * @nullable
+ */
+export type ClientFunctionRequestParameters = {
+    [key: string]: unknown;
+} | null;
+/**
+ * The function object from the OpenAI tools format.
+ */
+export interface ClientFunctionRequest {
+    /**
+     * What the action does, written for the model. An action without one can only be guessed at from its name. The 1024 ceiling is OpenAI's own limit on `tools[].function.description`, not a number chosen here: over it the upstream call fails with `string_above_max_length`, and refusing at submission is the clearer of the two places to refuse. It was 500, which ran out at about six enumerated entries — an action that must list what it accepts had nowhere to put the list.
+     * @minLength 1
+     * @maxLength 1024
+     */
+    description: string;
+    /**
+     * The MCP and Anthropic spelling of `parameters`. Give one or the other, not both.
+     * @nullable
+     */
+    inputSchema?: ClientFunctionRequestInputSchema;
+    /**
+     * @minLength 1
+     * @maxLength 64
+     */
+    name: string;
+    /**
+     * JSON Schema for the arguments. Omit for an action that takes none.
+     * @nullable
+     */
+    parameters?: ClientFunctionRequestParameters;
+}
+/**
+ * Only functions are supported.
+ */
+export type ClientActionRequestType = (typeof ClientActionRequestType)[keyof typeof ClientActionRequestType];
+export declare const ClientActionRequestType: {
+    readonly function: "function";
+};
+/**
+ * The shape of a tool in the OpenAI Chat Completions API, plus `readOnly` and `timeoutMs`.
+ */
+export interface ClientActionRequest {
+    function: ClientFunctionRequest;
+    /** True when the action changes nothing outside the client. Anything else goes through this conversation's approval before it runs. */
+    readOnly: boolean;
+    /**
+     * How long the assistant should wait for this action. Omit for the default; longer values are capped.
+     * @minimum 0
+     */
+    timeoutMs?: number;
+    /** Only functions are supported. */
+    type?: ClientActionRequestType;
+}
+/**
+ * Which client this is and what it can do, so the assistant can ask it to do those things
+ * while it answers. What the operator is looking at travels as `data-*` parts on the message.
+ *
+ * Send `actions` only when they differ from the last message on this conversation. Sending the
+ * block without `actions` keeps whatever was declared before.
+ */
+export interface ClientContextRequest {
+    /**
+     * The actions on offer right now.
+     *
+     * Omit it when nothing changed since the last message. Send `[]` to say there is nothing
+     * on offer — those are different: a client that moves off the page it was attached to has
+     * to be able to say so, or the assistant keeps calling actions that no longer make sense.
+     * @maxItems 32
+     * @nullable
+     */
+    actions?: ClientActionRequest[] | null;
+    /**
+     * Identifies this client while it stays open. Any stable string; one per tab or process.
+     * @minLength 1
+     * @maxLength 128
+     */
+    clientId: string;
+    /**
+     * How the client calls itself, for example "Leaflow console (web)".
+     * @maxLength 64
+     */
+    label?: string;
+}
+/**
+ * For `data-*` parts. Any object; its keys reach the assistant as they are.
+ * @nullable
+ */
+export type MessagePartData = {
+    [key: string]: unknown;
+} | null;
+/**
+ * One piece of a message. `type` says which of the fields below carries it:
+ *
+ * - `text` — the words, in `text`
+ * - `file` — an attachment uploaded earlier, by id in `attachmentId`
+ * - `data-<something>` — context from the client, in `data`. The name after `data-` is yours;
+ *   it is shown to the assistant so it can tell one kind of block from another.
+ *
+ * Order matters: an attachment belongs where it was written, not at the end.
+ */
+export interface MessagePart {
+    /**
+     * For `file` parts. The attachment must have been uploaded and not yet bound to another message.
+     * @nullable
+     */
+    attachmentId?: string | null;
+    /**
+     * For `data-*` parts. Any object; its keys reach the assistant as they are.
+     * @nullable
+     */
+    data?: MessagePartData;
+    /**
+     * For `text` parts.
+     * @nullable
+     */
+    text?: string | null;
+    /**
+     * @minLength 1
+     * @maxLength 64
+     */
+    type: string;
+}
+export interface SendMessageRequestBody {
+    client?: ClientContextRequest;
+    /**
+     * The message, in the order it was written. A message with nothing but text is a single
+     * text part; that is the ordinary case and nothing else is required.
+     * @minItems 1
+     */
+    parts: MessagePart[];
+}
+export interface MemoryResource {
+    /** The fact itself */
+    body: string;
+    createdAt: string;
+    id: string;
+    /** The name the assistant gave this fact; it overwrites or deletes its own entries by that name */
+    name: string;
+    /** Which conversation the assistant learned it in. That conversation may since have been deleted */
+    sourceThreadId?: string;
+    updatedAt: string;
+}
+export interface MemoryListResponseBody {
+    items: MemoryResource[];
+}
+export interface DynamicCallResultRequestBody {
+    /**
+     * The same value sent with the message. A result from a different client is refused.
+     * @minLength 1
+     */
+    clientId: string;
+    /**
+     * Why it failed, when `ok` is false. It reaches the assistant, so write it for a reader who cannot see the screen.
+     * @maxLength 2000
+     */
+    error?: string;
+    /**
+     * Pass back when there is more to read. The assistant will call again with it.
+     * @maxLength 500
+     */
+    nextCursor?: string;
+    ok: boolean;
+    /** What the action produced. At most 64 KiB; use `nextCursor` for anything larger. */
+    output?: string;
+}
+export interface TurnIDResponseBody {
+    /** True when the assistant was already busy and this message was put in line instead of starting a turn. It is read at the next step of the turn already running, so there is nothing further to do — and turnId is empty in this case. */
+    queued: boolean;
+    /** How many messages were already waiting ahead of this one. Only meaningful when queued is true. */
+    queuedAhead?: number;
+    /** The turn this message started. Empty when the message was queued instead. */
+    turnId: string;
+}
+/**
+ * A map from question id to the answer chosen
+ */
+export type AnswerRequestBodyAnswers = {
+    [key: string]: string;
+};
+export interface AnswerRequestBody {
+    /** A map from question id to the answer chosen */
+    answers: AnswerRequestBodyAnswers;
+}
+export interface RevertRequestBody {
+    /** The starting ordinal; that entry and everything after it is reverted */
+    ordinal: number;
+}
+export interface RevertedCountResponseBody {
+    reverted: number;
+}
+export interface FolderResource {
+    createdAt: string;
+    id: string;
+    name: string;
+    /** How many conversations are filed here and would show up in the default list. Archived and deleted ones are not counted, so this is exactly what `GET /api/v1/threads?folder=<id>` returns. */
+    threadCount: number;
+    updatedAt: string;
+}
+export interface FolderListResponseBody {
+    /** @nullable */
+    folders: FolderResource[] | null;
+}
+export interface CreateFolderRequestBody {
+    /**
+     * @minLength 1
+     * @maxLength 64
+     */
+    name: string;
+}
+export interface UpdateFolderRequestBody {
+    /**
+     * @minLength 1
+     * @maxLength 64
+     */
+    name: string;
+}
+/**
+ * Pagination metadata for stable numbered pages. total_count is returned only when the operation can determine it without an unbounded scan.
+ */
+export interface OffsetPagination {
+    /** @minimum 1 */
+    page: number;
+    /** @minimum 1 */
+    page_size: number;
+    /** @minimum 0 */
+    total_count?: number;
+}
+/**
+ * Pagination metadata for keyset traversal. Pass next_cursor as cursor to read the following page; null means there is no following page.
+ */
+export interface CursorPagination {
+    /** @minimum 1 */
+    page_size: number;
+    /** @nullable */
+    next_cursor?: string | null;
+}
+export type UploadAttachmentParams = {
+    /**
+     * The name to show and to give the assistant. Images do not need one; anything else does, because the name is most of what says what the file is. Falls back to a generated name.
+     * @maxLength 255
+     */
+    filename?: string;
+};
+export type ListBindingsParams = {
+    /**
+     * Items returned in this page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    limit?: number;
+    /**
+     * Items to skip. Defaults to 0; at most 10000.
+     * @minimum 0
+     * @maximum 10000
+     */
+    offset?: number;
+    platform?: string;
+    channelId?: string;
+    /**
+     * Return only bindings that are active
+     */
+    active?: boolean;
+};
+export type ListChannelsParams = {
+    /**
+     * Items returned in this page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    limit?: number;
+    /**
+     * Items to skip. Defaults to 0; at most 10000.
+     * @minimum 0
+     * @maximum 10000
+     */
+    offset?: number;
+    platform?: string;
+    /**
+     * Return only channels that are enabled
+     */
+    active?: boolean;
+};
+export type ListChannelRejectionsParams = {
+    /**
+     * @minimum 0
+     * @maximum 100
+     */
+    limit?: number;
+};
+export type CheckSenderParams = {
+    /**
+     * That person's id on the platform, the same value bindings and rejections carry
+     */
+    peerId: string;
+    /**
+     * Only platforms with usernames, such as Telegram, can supply this. Without the @. Empty means there is no username
+     */
+    username?: string;
+};
+export type ListThreadsParams = {
+    /**
+     * Search titles, case-insensitively. Empty returns the most recent conversations
+     * @maxLength 100
+     */
+    q?: string;
+    /**
+     * When true, returns **only** archived conversations; otherwise only unarchived ones
+     */
+    archived?: boolean;
+    /**
+     * A folder id, or empty for the conversations in no folder
+     * @maxLength 64
+     */
+    folder?: string;
+    /**
+     * The next_cursor returned by the previous page. Omit it for the first page.
+     * @minLength 1
+     * @maxLength 1024
+     */
+    cursor?: string;
+    /**
+     * Items returned in this page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    limit?: number;
+};
+export type ListEarlierItemsParams = {
+    /**
+     * From the document's earlier.before; returns entries before this ordinal
+     * @minimum 0
+     */
+    before: number;
+};