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

package/dist/assistant/v1/generated/validators/statusReportResource.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";
+import { ApprovalMode } from "./approvalMode.zod.js";
+import { ContextUsageResource } from "./contextUsageResource.zod.js";
+import { ReasoningEffort } from "./reasoningEffort.zod.js";
+import { ThreadStatus } from "./threadStatus.zod.js";
+import { ThreadTurnResource } from "./threadTurnResource.zod.js";
+import { Usage } from "./usage.zod.js";
+export const StatusReportResource = zod
+    .strictObject({
+    threadId: zod.string(),
+    modelId: zod.string(),
+    modelName: zod
+        .string()
+        .describe("The model's display name in the Canopy catalogue. Falls back to modelId."),
+    reasoningEffort: zod.union([ReasoningEffort, zod.null()]),
+    approvalMode: ApprovalMode,
+    status: ThreadStatus,
+    context: ContextUsageResource,
+    usage: Usage.describe("Token usage over the whole conversation."),
+    lastTurn: zod
+        .union([ThreadTurnResource, zod.null()])
+        .describe("The most recent turn with its own usage. Null before the first message."),
+})
+    .describe("The conversation's configuration and resource use, as shown by /status.");

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

@@ -0,0 +1,33 @@
+/**
+ * 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 subagentCountResourceTotalMin = 0;
+export declare const subagentCountResourceRunningMin = 0;
+export declare const SubagentCountResource: zod.ZodObject<{
+    total: zod.ZodInt;
+    running: zod.ZodInt;
+}, zod.z.core.$strict>;
+export type SubagentCountResource = zod.input<typeof SubagentCountResource>;
+export type SubagentCountResourceOutput = zod.output<typeof SubagentCountResource>;

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

@@ -0,0 +1,31 @@
+/**
+ * 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 subagentCountResourceTotalMin = 0;
+export const subagentCountResourceRunningMin = 0;
+export const SubagentCountResource = zod.strictObject({
+    total: zod.int().min(subagentCountResourceTotalMin),
+    running: zod.int().min(subagentCountResourceRunningMin),
+});

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

@@ -0,0 +1,41 @@
+/**
+ * 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 taskActionPromptMax = 20000;
+export declare const taskActionCommandMax = 20000;
+export declare const taskActionTimeoutSecondsDefault = 3600;
+export declare const taskActionTimeoutSecondsMax = 3600;
+export declare const TaskAction: zod.ZodObject<{
+    type: zod.ZodEnum<{
+        prompt: "prompt";
+        command: "command";
+    }>;
+    prompt: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    instanceId: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    command: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    timeoutSeconds: zod.ZodDefault<zod.ZodInt>;
+}, zod.z.core.$strict>;
+export type TaskAction = zod.input<typeof TaskAction>;
+export type TaskActionOutput = zod.output<typeof TaskAction>;

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

@@ -0,0 +1,51 @@
+/**
+ * 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 taskActionPromptMax = 20000;
+export const taskActionCommandMax = 20000;
+export const taskActionTimeoutSecondsDefault = 3600;
+export const taskActionTimeoutSecondsMax = 3600;
+export const TaskAction = zod
+    .strictObject({
+    type: zod.enum(["prompt", "command"]),
+    prompt: zod
+        .string()
+        .max(taskActionPromptMax)
+        .nullish()
+        .describe("For `prompt`. Sent to the conversation as a message from the task."),
+    instanceId: zod.string().nullish().describe("For `command`. The instance that runs it."),
+    command: zod
+        .string()
+        .max(taskActionCommandMax)
+        .nullish()
+        .describe("For `command`. A shell command."),
+    timeoutSeconds: zod
+        .int()
+        .min(1)
+        .max(taskActionTimeoutSecondsMax)
+        .default(taskActionTimeoutSecondsDefault)
+        .describe("For `command`. The run fails with status timed_out after this long."),
+})
+    .describe("What a run does. `type` determines which fields apply.");

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

@@ -0,0 +1,89 @@
+/**
+ * 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 TaskListResponseBody: zod.ZodObject<{
+    tasks: zod.ZodArray<zod.ZodObject<{
+        id: zod.ZodString;
+        threadId: zod.ZodString;
+        name: zod.ZodString;
+        status: zod.ZodEnum<{
+            completed: "completed";
+            cancelled: "cancelled";
+            active: "active";
+            paused: "paused";
+        }>;
+        trigger: zod.ZodObject<{
+            type: zod.ZodEnum<{
+                at: "at";
+                now: "now";
+                interval: "interval";
+                cron: "cron";
+            }>;
+            runAt: zod.ZodOptional<zod.ZodNullable<zod.z.ZodISODateTime>>;
+            intervalSeconds: zod.ZodOptional<zod.ZodNullable<zod.ZodInt>>;
+            anchorAt: zod.ZodOptional<zod.ZodNullable<zod.z.ZodISODateTime>>;
+            cron: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            timezone: zod.ZodDefault<zod.ZodString>;
+            overlapPolicy: zod.ZodDefault<zod.ZodEnum<{
+                skip: "skip";
+                buffer_one: "buffer_one";
+            }>>;
+            catchupSeconds: zod.ZodDefault<zod.ZodInt>;
+        }, zod.z.core.$strict>;
+        action: zod.ZodObject<{
+            type: zod.ZodEnum<{
+                prompt: "prompt";
+                command: "command";
+            }>;
+            prompt: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            instanceId: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            command: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            timeoutSeconds: zod.ZodDefault<zod.ZodInt>;
+        }, zod.z.core.$strict>;
+        nextRunAt: zod.ZodNullable<zod.z.ZodISODateTime>;
+        lastRun: zod.ZodUnion<readonly [zod.ZodObject<{
+            id: zod.ZodString;
+            taskId: zod.ZodString;
+            status: zod.ZodEnum<{
+                running: "running";
+                completed: "completed";
+                failed: "failed";
+                cancelled: "cancelled";
+                queued: "queued";
+                timed_out: "timed_out";
+            }>;
+            startedAt: zod.ZodNullable<zod.z.ZodISODateTime>;
+            finishedAt: zod.ZodNullable<zod.z.ZodISODateTime>;
+            exitCode: zod.ZodNullable<zod.ZodInt>;
+            output: zod.ZodNullable<zod.ZodString>;
+            errorCode: zod.ZodNullable<zod.ZodString>;
+        }, zod.z.core.$strict>, zod.ZodNull]>;
+        createdAt: zod.z.ZodISODateTime;
+        updatedAt: zod.z.ZodISODateTime;
+    }, zod.z.core.$strict>>;
+    nextCursor: zod.ZodNullable<zod.ZodString>;
+}, zod.z.core.$strict>;
+export type TaskListResponseBody = zod.input<typeof TaskListResponseBody>;
+export type TaskListResponseBodyOutput = zod.output<typeof TaskListResponseBody>;

package/dist/assistant/v1/generated/validators/taskListResponseBody.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 { TaskResource } from "./taskResource.zod.js";
+export const TaskListResponseBody = zod.strictObject({
+    tasks: zod.array(TaskResource),
+    nextCursor: zod.string().nullable(),
+});

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

@@ -0,0 +1,86 @@
+/**
+ * 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 TaskResource: zod.ZodObject<{
+    id: zod.ZodString;
+    threadId: zod.ZodString;
+    name: zod.ZodString;
+    status: zod.ZodEnum<{
+        completed: "completed";
+        cancelled: "cancelled";
+        active: "active";
+        paused: "paused";
+    }>;
+    trigger: zod.ZodObject<{
+        type: zod.ZodEnum<{
+            at: "at";
+            now: "now";
+            interval: "interval";
+            cron: "cron";
+        }>;
+        runAt: zod.ZodOptional<zod.ZodNullable<zod.z.ZodISODateTime>>;
+        intervalSeconds: zod.ZodOptional<zod.ZodNullable<zod.ZodInt>>;
+        anchorAt: zod.ZodOptional<zod.ZodNullable<zod.z.ZodISODateTime>>;
+        cron: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        timezone: zod.ZodDefault<zod.ZodString>;
+        overlapPolicy: zod.ZodDefault<zod.ZodEnum<{
+            skip: "skip";
+            buffer_one: "buffer_one";
+        }>>;
+        catchupSeconds: zod.ZodDefault<zod.ZodInt>;
+    }, zod.z.core.$strict>;
+    action: zod.ZodObject<{
+        type: zod.ZodEnum<{
+            prompt: "prompt";
+            command: "command";
+        }>;
+        prompt: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        instanceId: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        command: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        timeoutSeconds: zod.ZodDefault<zod.ZodInt>;
+    }, zod.z.core.$strict>;
+    nextRunAt: zod.ZodNullable<zod.z.ZodISODateTime>;
+    lastRun: zod.ZodUnion<readonly [zod.ZodObject<{
+        id: zod.ZodString;
+        taskId: zod.ZodString;
+        status: zod.ZodEnum<{
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            queued: "queued";
+            timed_out: "timed_out";
+        }>;
+        startedAt: zod.ZodNullable<zod.z.ZodISODateTime>;
+        finishedAt: zod.ZodNullable<zod.z.ZodISODateTime>;
+        exitCode: zod.ZodNullable<zod.ZodInt>;
+        output: zod.ZodNullable<zod.ZodString>;
+        errorCode: zod.ZodNullable<zod.ZodString>;
+    }, zod.z.core.$strict>, zod.ZodNull]>;
+    createdAt: zod.z.ZodISODateTime;
+    updatedAt: zod.z.ZodISODateTime;
+}, zod.z.core.$strict>;
+export type TaskResource = zod.input<typeof TaskResource>;
+export type TaskResourceOutput = zod.output<typeof TaskResource>;

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

@@ -0,0 +1,45 @@
+/**
+ * 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 { TaskAction } from "./taskAction.zod.js";
+import { TaskRunResource } from "./taskRunResource.zod.js";
+import { TaskTrigger } from "./taskTrigger.zod.js";
+export const TaskResource = zod.strictObject({
+    id: zod.string(),
+    threadId: zod.string().describe("The conversation the task reports to."),
+    name: zod.string(),
+    status: zod
+        .enum(["active", "paused", "completed", "cancelled"])
+        .describe("`completed` is a one-time task whose run has ended."),
+    trigger: TaskTrigger,
+    action: TaskAction,
+    nextRunAt: zod.iso
+        .datetime({ offset: true })
+        .nullable()
+        .describe("When the trigger starts the next run. Null when it will not."),
+    lastRun: zod.union([TaskRunResource, zod.null()]),
+    createdAt: zod.iso.datetime({ offset: true }),
+    updatedAt: zod.iso.datetime({ offset: true }),
+});

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

@@ -0,0 +1,47 @@
+/**
+ * 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 TaskRunListResponseBody: zod.ZodObject<{
+    runs: zod.ZodArray<zod.ZodObject<{
+        id: zod.ZodString;
+        taskId: zod.ZodString;
+        status: zod.ZodEnum<{
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            queued: "queued";
+            timed_out: "timed_out";
+        }>;
+        startedAt: zod.ZodNullable<zod.z.ZodISODateTime>;
+        finishedAt: zod.ZodNullable<zod.z.ZodISODateTime>;
+        exitCode: zod.ZodNullable<zod.ZodInt>;
+        output: zod.ZodNullable<zod.ZodString>;
+        errorCode: zod.ZodNullable<zod.ZodString>;
+    }, zod.z.core.$strict>>;
+    nextCursor: zod.ZodNullable<zod.ZodString>;
+}, zod.z.core.$strict>;
+export type TaskRunListResponseBody = zod.input<typeof TaskRunListResponseBody>;
+export type TaskRunListResponseBodyOutput = zod.output<typeof TaskRunListResponseBody>;

package/dist/assistant/v1/generated/validators/taskRunListResponseBody.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 { TaskRunResource } from "./taskRunResource.zod.js";
+export const TaskRunListResponseBody = zod.strictObject({
+    runs: zod.array(TaskRunResource),
+    nextCursor: zod.string().nullable(),
+});

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

@@ -0,0 +1,44 @@
+/**
+ * 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 TaskRunResource: zod.ZodObject<{
+    id: zod.ZodString;
+    taskId: zod.ZodString;
+    status: zod.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+        queued: "queued";
+        timed_out: "timed_out";
+    }>;
+    startedAt: zod.ZodNullable<zod.z.ZodISODateTime>;
+    finishedAt: zod.ZodNullable<zod.z.ZodISODateTime>;
+    exitCode: zod.ZodNullable<zod.ZodInt>;
+    output: zod.ZodNullable<zod.ZodString>;
+    errorCode: zod.ZodNullable<zod.ZodString>;
+}, zod.z.core.$strict>;
+export type TaskRunResource = zod.input<typeof TaskRunResource>;
+export type TaskRunResourceOutput = zod.output<typeof TaskRunResource>;

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

@@ -0,0 +1,38 @@
+/**
+ * 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 TaskRunResource = zod.strictObject({
+    id: zod.string(),
+    taskId: zod.string(),
+    status: zod.enum(["queued", "running", "completed", "failed", "cancelled", "timed_out"]),
+    startedAt: zod.iso.datetime({ offset: true }).nullable(),
+    finishedAt: zod.iso.datetime({ offset: true }).nullable(),
+    exitCode: zod.int().nullable().describe("For commands. Null until the command exits."),
+    output: zod
+        .string()
+        .nullable()
+        .describe("The last 16 KiB of a command's output. Empty for prompts; null in lists, read the run for it."),
+    errorCode: zod.string().nullable().describe("Why the run failed. Null unless status is failed."),
+});