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

package/dist/assistant/v1/generated/validators/threadTurnListResponseBody.zod.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Assistant API
+ * Conversations with agents that operate the Leaflow platform, plus their folders, tasks, files and
+ * chat-app channels.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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";
+export declare const ThreadTurnListResponseBody: zod.ZodObject<{
+    turns: zod.ZodArray<zod.ZodObject<{
+        id: zod.ZodString;
+        threadId: zod.ZodString;
+        type: zod.ZodEnum<{
+            message: "message";
+            compaction: "compaction";
+        }>;
+        status: zod.ZodEnum<{
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            declined: "declined";
+            cancelled: "cancelled";
+        }>;
+        firstOrdinal: zod.ZodNullable<zod.ZodInt>;
+        lastOrdinal: zod.ZodNullable<zod.ZodInt>;
+        preview: zod.ZodNullable<zod.ZodString>;
+        modelId: zod.ZodString;
+        reasoningEffort: zod.ZodUnion<readonly [zod.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+        }>, zod.ZodNull]>;
+        approvalMode: zod.ZodEnum<{
+            manual: "manual";
+            guardian: "guardian";
+            yolo: "yolo";
+        }>;
+        failureCode: zod.ZodNullable<zod.ZodString>;
+        toolCalls: zod.ZodInt;
+        usage: zod.ZodObject<{
+            inputTokens: zod.ZodInt;
+            cachedInputTokens: zod.ZodInt;
+            cacheWriteTokens: zod.ZodInt;
+            outputTokens: zod.ZodInt;
+            reasoningTokens: zod.ZodInt;
+            totalTokens: zod.ZodInt;
+            requests: zod.ZodInt;
+            complete: zod.ZodBoolean;
+        }, zod.z.core.$strict>;
+        startedAt: zod.z.ZodISODateTime;
+        firstTokenAt: zod.ZodNullable<zod.z.ZodISODateTime>;
+        completedAt: zod.ZodNullable<zod.z.ZodISODateTime>;
+    }, zod.z.core.$strict>>;
+    nextCursor: zod.ZodNullable<zod.ZodString>;
+}, zod.z.core.$strict>;
+export type ThreadTurnListResponseBody = zod.input<typeof ThreadTurnListResponseBody>;
+export type ThreadTurnListResponseBodyOutput = zod.output<typeof ThreadTurnListResponseBody>;

package/dist/assistant/v1/generated/validators/threadTurnListResponseBody.zod.js

@@ -0,0 +1,30 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Assistant API
+ * Conversations with agents that operate the Leaflow platform, plus their folders, tasks, files and
+ * chat-app channels.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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 { ThreadTurnResource } from "./threadTurnResource.zod.js";
+export const ThreadTurnListResponseBody = zod.strictObject({
+    turns: zod.array(ThreadTurnResource).describe("Newest first."),
+    nextCursor: zod.string().nullable(),
+});

package/dist/assistant/v1/generated/validators/threadTurnResource.zod.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Assistant API
+ * Conversations with agents that operate the Leaflow platform, plus their folders, tasks, files and
+ * chat-app channels.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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";
+export declare const threadTurnResourceToolCallsMin = 0;
+export declare const ThreadTurnResource: zod.ZodObject<{
+    id: zod.ZodString;
+    threadId: zod.ZodString;
+    type: zod.ZodEnum<{
+        message: "message";
+        compaction: "compaction";
+    }>;
+    status: zod.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        declined: "declined";
+        cancelled: "cancelled";
+    }>;
+    firstOrdinal: zod.ZodNullable<zod.ZodInt>;
+    lastOrdinal: zod.ZodNullable<zod.ZodInt>;
+    preview: zod.ZodNullable<zod.ZodString>;
+    modelId: zod.ZodString;
+    reasoningEffort: zod.ZodUnion<readonly [zod.ZodEnum<{
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>, zod.ZodNull]>;
+    approvalMode: zod.ZodEnum<{
+        manual: "manual";
+        guardian: "guardian";
+        yolo: "yolo";
+    }>;
+    failureCode: zod.ZodNullable<zod.ZodString>;
+    toolCalls: zod.ZodInt;
+    usage: zod.ZodObject<{
+        inputTokens: zod.ZodInt;
+        cachedInputTokens: zod.ZodInt;
+        cacheWriteTokens: zod.ZodInt;
+        outputTokens: zod.ZodInt;
+        reasoningTokens: zod.ZodInt;
+        totalTokens: zod.ZodInt;
+        requests: zod.ZodInt;
+        complete: zod.ZodBoolean;
+    }, zod.z.core.$strict>;
+    startedAt: zod.z.ZodISODateTime;
+    firstTokenAt: zod.ZodNullable<zod.z.ZodISODateTime>;
+    completedAt: zod.ZodNullable<zod.z.ZodISODateTime>;
+}, zod.z.core.$strict>;
+export type ThreadTurnResource = zod.input<typeof ThreadTurnResource>;
+export type ThreadTurnResourceOutput = zod.output<typeof ThreadTurnResource>;

package/dist/assistant/v1/generated/validators/threadTurnResource.zod.js

@@ -0,0 +1,69 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Assistant API
+ * Conversations with agents that operate the Leaflow platform, plus their folders, tasks, files and
+ * chat-app channels.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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 { ApprovalMode } from "./approvalMode.zod.js";
+import { ReasoningEffort } from "./reasoningEffort.zod.js";
+import { TurnStatus } from "./turnStatus.zod.js";
+import { TurnType } from "./turnType.zod.js";
+import { Usage } from "./usage.zod.js";
+export const threadTurnResourceToolCallsMin = 0;
+export const ThreadTurnResource = zod
+    .strictObject({
+    id: zod.string(),
+    threadId: zod.string(),
+    type: TurnType,
+    status: TurnStatus,
+    firstOrdinal: zod
+        .int()
+        .nullable()
+        .describe("The first item the turn wrote. Null before it has written one."),
+    lastOrdinal: zod.int().nullable().describe("The last item the turn wrote so far."),
+    preview: zod
+        .string()
+        .nullable()
+        .describe("The beginning of the message that started the turn. Null for compaction turns and turns started by the assistant itself."),
+    modelId: zod.string(),
+    reasoningEffort: zod.union([ReasoningEffort, zod.null()]),
+    approvalMode: ApprovalMode,
+    failureCode: zod
+        .string()
+        .nullable()
+        .describe("Why the turn failed. Null unless status is failed."),
+    toolCalls: zod
+        .int()
+        .min(threadTurnResourceToolCallsMin)
+        .describe("How many tools the turn called."),
+    usage: Usage.describe("Tokens used by every model request of this turn, including title generation, review and compaction."),
+    startedAt: zod.iso.datetime({ offset: true }),
+    firstTokenAt: zod.iso
+        .datetime({ offset: true })
+        .nullable()
+        .describe("When the first output token arrived. Null until then."),
+    completedAt: zod.iso
+        .datetime({ offset: true })
+        .nullable()
+        .describe("Null while the turn is running."),
+})
+    .describe("One run of the agent, from the message that started it until it stopped.");

package/dist/assistant/v1/generated/validators/todoResource.zod.d.ts

@@ -2,58 +2,34 @@
  * 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";
 export declare const TodoResource: zod.ZodObject<{
-    activeForm: zod.ZodString;
     content: zod.ZodString;
+    activeForm: zod.ZodString;
     status: zod.ZodEnum<{
+        completed: "completed";
         pending: "pending";
         in_progress: "in_progress";
-        completed: "completed";
     }>;
 }, zod.z.core.$strict>;
 export type TodoResource = zod.input<typeof TodoResource>;

package/dist/assistant/v1/generated/validators/todoResource.zod.js

@@ -2,57 +2,33 @@
  * 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";
 export const TodoResource = zod.strictObject({
+    content: zod.string().describe('The step as an instruction — "Install nginx".'),
     activeForm: zod
         .string()
-        .describe('The same step phrased as happening now — "Installing nginx". Show this one while the item is in progress.'),
-    content: zod.string().describe('The step as an instruction — "Install nginx".'),
+        .describe('The same step phrased as happening now — "Installing nginx". Show this one while the step is in progress.'),
     status: zod
         .enum(["pending", "in_progress", "completed"])
-        .describe("Where this step stands. At most one item is in_progress at any time."),
+        .describe("Where this step stands. At most one step is in_progress at any time."),
 });

package/dist/assistant/v1/generated/validators/toolCallResource.zod.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Assistant API
+ * Conversations with agents that operate the Leaflow platform, plus their folders, tasks, files and
+ * chat-app channels.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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";
+export declare const ToolCallResource: zod.ZodObject<{
+    namespace: zod.ZodString;
+    tool: zod.ZodString;
+    arguments: zod.ZodString;
+    target: zod.ZodNullable<zod.ZodString>;
+    detail: zod.ZodNullable<zod.ZodString>;
+    presentation: zod.ZodUnion<readonly [zod.ZodObject<{
+        type: zod.ZodEnum<{
+            file_diff: "file_diff";
+        }>;
+        fileDiff: zod.ZodUnion<readonly [zod.ZodObject<{
+            path: zod.ZodString;
+            status: zod.ZodEnum<{
+                added: "added";
+                modified: "modified";
+                deleted: "deleted";
+            }>;
+            added: zod.ZodInt;
+            removed: zod.ZodInt;
+            unified: zod.ZodNullable<zod.ZodString>;
+        }, zod.z.core.$strict>, zod.ZodNull]>;
+    }, zod.z.core.$strict>, zod.ZodNull]>;
+    approvalStatus: zod.ZodNullable<zod.ZodUnion<readonly [zod.ZodLiteral<"pending">, zod.ZodLiteral<"reviewing">, zod.ZodLiteral<"approved">, zod.ZodLiteral<"auto_approved">, zod.ZodLiteral<"declined">, zod.ZodLiteral<"unreviewed">, zod.ZodLiteral<null>]>>;
+    approvalReason: zod.ZodNullable<zod.ZodString>;
+    decidedAt: zod.ZodNullable<zod.z.ZodISODateTime>;
+    questions: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
+        id: zod.ZodString;
+        header: zod.ZodString;
+        question: zod.ZodString;
+        choices: zod.ZodArray<zod.ZodObject<{
+            label: zod.ZodString;
+            description: zod.ZodString;
+        }, zod.z.core.$strict>>;
+    }, zod.z.core.$strict>>>;
+    answers: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodString>>;
+    autoAnswerMs: zod.ZodNullable<zod.ZodInt>;
+}, zod.z.core.$strict>;
+export type ToolCallResource = zod.input<typeof ToolCallResource>;
+export type ToolCallResourceOutput = zod.output<typeof ToolCallResource>;

package/dist/assistant/v1/generated/validators/toolCallResource.zod.js

@@ -0,0 +1,71 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Assistant API
+ * Conversations with agents that operate the Leaflow platform, plus their folders, tasks, files and
+ * chat-app channels.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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 { PresentationResource } from "./presentationResource.zod.js";
+import { QuestionResource } from "./questionResource.zod.js";
+export const ToolCallResource = zod.strictObject({
+    namespace: zod
+        .string()
+        .describe("The tool's group, for example `instance`, `leaflow`, `agent` or `client`. Empty for tools without one."),
+    tool: zod.string(),
+    arguments: zod
+        .string()
+        .describe("The arguments as JSON text. Cut in lists when long; then it is no longer valid JSON."),
+    target: zod
+        .string()
+        .nullable()
+        .describe("What the call acts on, for display, such as a file path or an instance name."),
+    detail: zod.string().nullable().describe("A one-line description of what the call did."),
+    presentation: zod.union([PresentationResource, zod.null()]),
+    approvalStatus: zod
+        .union([
+        zod.literal("pending"),
+        zod.literal("reviewing"),
+        zod.literal("approved"),
+        zod.literal("auto_approved"),
+        zod.literal("declined"),
+        zod.literal("unreviewed"),
+        zod.literal(null),
+    ])
+        .nullable()
+        .describe("Whether the call needed a decision before it ran. Null for calls that need none.\n`auto_approved` was approved by the automatic reviewer."),
+    approvalReason: zod.string().nullable(),
+    decidedAt: zod.iso
+        .datetime({ offset: true })
+        .nullable()
+        .describe("When a person or the reviewer decided the call or answered its questions."),
+    questions: zod
+        .array(QuestionResource)
+        .nullable()
+        .describe("The questions of an `ask` call. Null for other calls."),
+    answers: zod
+        .record(zod.string(), zod.string())
+        .nullable()
+        .describe("The answers given so far, by question id. Null for other calls."),
+    autoAnswerMs: zod
+        .int()
+        .nullable()
+        .describe("How long an `ask` call waits before it continues with its default answers. Null when it waits indefinitely."),
+});

package/dist/assistant/v1/generated/validators/toolResultRequestBody.zod.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Assistant API
+ * Conversations with agents that operate the Leaflow platform, plus their folders, tasks, files and
+ * chat-app channels.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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";
+export declare const toolResultRequestBodyErrorMax = 2000;
+export declare const toolResultRequestBodyNextCursorMax = 500;
+export declare const ToolResultRequestBody: zod.ZodObject<{
+    clientId: zod.ZodString;
+    ok: zod.ZodBoolean;
+    output: zod.ZodOptional<zod.ZodString>;
+    error: zod.ZodOptional<zod.ZodString>;
+    nextCursor: zod.ZodOptional<zod.ZodString>;
+}, zod.z.core.$strict>;
+export type ToolResultRequestBody = zod.input<typeof ToolResultRequestBody>;
+export type ToolResultRequestBodyOutput = zod.output<typeof ToolResultRequestBody>;

package/dist/assistant/v1/generated/validators/toolResultRequestBody.zod.js

@@ -0,0 +1,48 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Assistant API
+ * Conversations with agents that operate the Leaflow platform, plus their folders, tasks, files and
+ * chat-app channels.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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";
+export const toolResultRequestBodyErrorMax = 2000;
+export const toolResultRequestBodyNextCursorMax = 500;
+export const ToolResultRequestBody = zod.strictObject({
+    clientId: zod
+        .string()
+        .min(1)
+        .describe("The client that declared the action. A result from another client is refused."),
+    ok: zod.boolean(),
+    output: zod
+        .string()
+        .optional()
+        .describe("What the action produced. At most 64 KiB; use `nextCursor` for more."),
+    error: zod
+        .string()
+        .max(toolResultRequestBodyErrorMax)
+        .optional()
+        .describe("Why it failed, when `ok` is false. Written for the assistant, which cannot see the screen."),
+    nextCursor: zod
+        .string()
+        .max(toolResultRequestBodyNextCursorMax)
+        .optional()
+        .describe("Pass when there is more to read; the assistant calls again with it."),
+});