@anchrd/colab-sdk 0.1.6 → 0.1.8

package/dist/operators/operators.d.ts

@@ -151,7 +151,7 @@ export declare const Credential: z.ZodObject<{
     createdAt: z.ZodISODateTime;
     createdBy: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
     updatedAt: z.ZodISODateTime;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type Credential = z.infer<typeof Credential>;
 export declare const CredentialList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
@@ -177,16 +177,16 @@ export declare const CredentialList: z.ZodObject<{
         createdAt: z.ZodISODateTime;
         createdBy: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
         updatedAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodTemplateLiteral<`credential_${string}`>>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type CredentialList = z.infer<typeof CredentialList>;
 export declare const CredentialTestResult: z.ZodDiscriminatedUnion<[z.ZodObject<{
     ok: z.ZodLiteral<true>;
-}, z.core.$strict>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     ok: z.ZodLiteral<false>;
     error: z.ZodString;
-}, z.core.$strict>], "ok">;
+}, z.core.$strip>], "ok">;
 export type CredentialTestResult = z.infer<typeof CredentialTestResult>;
 export declare const CredentialTested: z.ZodObject<{
     credential: z.ZodObject<{
@@ -212,14 +212,14 @@ export declare const CredentialTested: z.ZodObject<{
         createdAt: z.ZodISODateTime;
         createdBy: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
         updatedAt: z.ZodISODateTime;
-    }, z.core.$strict>;
+    }, z.core.$strip>;
     test: z.ZodDiscriminatedUnion<[z.ZodObject<{
         ok: z.ZodLiteral<true>;
-    }, z.core.$strict>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         ok: z.ZodLiteral<false>;
         error: z.ZodString;
-    }, z.core.$strict>], "ok">;
-}, z.core.$strict>;
+    }, z.core.$strip>], "ok">;
+}, z.core.$strip>;
 export type CredentialTested = z.infer<typeof CredentialTested>;
 export declare const Subagents: z.ZodObject<{
     allowed: z.ZodBoolean;
@@ -516,12 +516,12 @@ export declare const Operator: z.ZodObject<{
     running: z.ZodNullable<z.ZodObject<{
         runId: z.ZodTemplateLiteral<`run_${string}`>;
         startedAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     archivedAt: z.ZodNullable<z.ZodISODateTime>;
     createdAt: z.ZodISODateTime;
     createdBy: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
     updatedAt: z.ZodISODateTime;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type Operator = z.infer<typeof Operator>;
 export declare const OperatorList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
@@ -602,14 +602,14 @@ export declare const OperatorList: z.ZodObject<{
         running: z.ZodNullable<z.ZodObject<{
             runId: z.ZodTemplateLiteral<`run_${string}`>;
             startedAt: z.ZodISODateTime;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
         archivedAt: z.ZodNullable<z.ZodISODateTime>;
         createdAt: z.ZodISODateTime;
         createdBy: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
         updatedAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type OperatorList = z.infer<typeof OperatorList>;
 export declare const OperatorRunId: z.ZodTemplateLiteral<`run_${string}`>;
 export type OperatorRunId = z.infer<typeof OperatorRunId>;
@@ -617,6 +617,7 @@ export declare const OperatorRunStatus: z.ZodEnum<{
     running: "running";
     failed: "failed";
     completed: "completed";
+    stopped: "stopped";
 }>;
 export type OperatorRunStatus = z.infer<typeof OperatorRunStatus>;
 export declare const OperatorRunReason: z.ZodEnum<{
@@ -640,13 +641,24 @@ export declare const OperatorRunTokens: z.ZodObject<{
     output: z.ZodInt;
     cacheRead: z.ZodInt;
     cacheWrite: z.ZodInt;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type OperatorRunTokens = z.infer<typeof OperatorRunTokens>;
 export declare const OperatorRunTouched: z.ZodObject<{
     processes: z.ZodArray<z.ZodString>;
     connectors: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type OperatorRunTouched = z.infer<typeof OperatorRunTouched>;
+export declare const OperatorRunInstructions: z.ZodObject<{
+    version: z.ZodNullable<z.ZodInt>;
+    status: z.ZodNullable<z.ZodString>;
+    cut: z.ZodBoolean;
+}, z.core.$strip>;
+export type OperatorRunInstructions = z.infer<typeof OperatorRunInstructions>;
+export declare const OperatorRunAgents: z.ZodObject<{
+    started: z.ZodInt;
+    running: z.ZodInt;
+}, z.core.$strip>;
+export type OperatorRunAgents = z.infer<typeof OperatorRunAgents>;
 export declare const OperatorRun: z.ZodObject<{
     trigger: z.ZodEnum<{
         schedule: "schedule";
@@ -657,6 +669,7 @@ export declare const OperatorRun: z.ZodObject<{
         running: "running";
         failed: "failed";
         completed: "completed";
+        stopped: "stopped";
     }>;
     reason: z.ZodNullable<z.ZodEnum<{
         error: "error";
@@ -672,7 +685,12 @@ export declare const OperatorRun: z.ZodObject<{
     touched: z.ZodObject<{
         processes: z.ZodArray<z.ZodString>;
         connectors: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>;
+    }, z.core.$strip>;
+    instructions: z.ZodNullable<z.ZodObject<{
+        version: z.ZodNullable<z.ZodInt>;
+        status: z.ZodNullable<z.ZodString>;
+        cut: z.ZodBoolean;
+    }, z.core.$strip>>;
     credentialKind: z.ZodNullable<z.ZodEnum<{
         subscription: "subscription";
         apikey: "apikey";
@@ -684,7 +702,15 @@ export declare const OperatorRun: z.ZodObject<{
         output: z.ZodInt;
         cacheRead: z.ZodInt;
         cacheWrite: z.ZodInt;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
+    agents: z.ZodNullable<z.ZodObject<{
+        started: z.ZodInt;
+        running: z.ZodInt;
+    }, z.core.$strip>>;
+    stoppedBy: z.ZodNullable<z.ZodObject<{
+        userId: z.ZodTemplateLiteral<`user_${string}`>;
+        name: z.ZodString;
+    }, z.core.$strip>>;
     startedAt: z.ZodISODateTime;
     endedAt: z.ZodNullable<z.ZodISODateTime>;
     durationMs: z.ZodNullable<z.ZodInt>;
@@ -692,7 +718,7 @@ export declare const OperatorRun: z.ZodObject<{
     machineName: z.ZodString;
     machineArchivedAt: z.ZodNullable<z.ZodISODateTime>;
     runId: z.ZodTemplateLiteral<`run_${string}`>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type OperatorRun = z.infer<typeof OperatorRun>;
 export declare const OperatorRunListInput: z.ZodObject<{
     machineId: z.ZodOptional<z.ZodTemplateLiteral<`user_${string}`>>;
@@ -705,6 +731,7 @@ export declare const OperatorRunListInput: z.ZodObject<{
         running: "running";
         failed: "failed";
         completed: "completed";
+        stopped: "stopped";
     }>>;
     from: z.ZodOptional<z.ZodISODateTime>;
     to: z.ZodOptional<z.ZodISODateTime>;
@@ -717,6 +744,71 @@ export declare const OperatorRunGetInput: z.ZodObject<{
     runId: z.ZodTemplateLiteral<`run_${string}`>;
 }, z.core.$strict>;
 export type OperatorRunGetInput = z.infer<typeof OperatorRunGetInput>;
+export declare const RunCancelInput: z.ZodObject<{
+    runId: z.ZodTemplateLiteral<`run_${string}`>;
+}, z.core.$strict>;
+export type RunCancelInput = z.infer<typeof RunCancelInput>;
+export declare const OperatorRunStepKind: z.ZodEnum<{
+    error: "error";
+    text: "text";
+    thinking: "thinking";
+    tool: "tool";
+    result: "result";
+    agentstart: "agentstart";
+    agentend: "agentend";
+    truncated: "truncated";
+}>;
+export type OperatorRunStepKind = z.infer<typeof OperatorRunStepKind>;
+export declare const OperatorRunStep: z.ZodObject<{
+    seq: z.ZodInt;
+    at: z.ZodISODateTime;
+    agentId: z.ZodNullable<z.ZodString>;
+    kind: z.ZodEnum<{
+        error: "error";
+        text: "text";
+        thinking: "thinking";
+        tool: "tool";
+        result: "result";
+        agentstart: "agentstart";
+        agentend: "agentend";
+        truncated: "truncated";
+    }>;
+    name: z.ZodNullable<z.ZodString>;
+    callId: z.ZodNullable<z.ZodString>;
+    text: z.ZodString;
+    failed: z.ZodBoolean;
+}, z.core.$strip>;
+export type OperatorRunStep = z.infer<typeof OperatorRunStep>;
+export declare const RunStepListInput: z.ZodObject<{
+    runId: z.ZodTemplateLiteral<`run_${string}`>;
+    agentId: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type RunStepListInput = z.infer<typeof RunStepListInput>;
+export declare const OperatorRunStepList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        seq: z.ZodInt;
+        at: z.ZodISODateTime;
+        agentId: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            error: "error";
+            text: "text";
+            thinking: "thinking";
+            tool: "tool";
+            result: "result";
+            agentstart: "agentstart";
+            agentend: "agentend";
+            truncated: "truncated";
+        }>;
+        name: z.ZodNullable<z.ZodString>;
+        callId: z.ZodNullable<z.ZodString>;
+        text: z.ZodString;
+        failed: z.ZodBoolean;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type OperatorRunStepList = z.infer<typeof OperatorRunStepList>;
 export declare const OperatorRunUsage: z.ZodObject<{
     byMachine: z.ZodArray<z.ZodObject<{
         runs: z.ZodInt;
@@ -726,11 +818,11 @@ export declare const OperatorRunUsage: z.ZodObject<{
             output: z.ZodInt;
             cacheRead: z.ZodInt;
             cacheWrite: z.ZodInt;
-        }, z.core.$strict>;
+        }, z.core.$strip>;
         machineId: z.ZodTemplateLiteral<`user_${string}`>;
         machineName: z.ZodString;
         machineArchivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     byDay: z.ZodArray<z.ZodObject<{
         runs: z.ZodInt;
         costUsd: z.ZodNumber;
@@ -739,9 +831,9 @@ export declare const OperatorRunUsage: z.ZodObject<{
             output: z.ZodInt;
             cacheRead: z.ZodInt;
             cacheWrite: z.ZodInt;
-        }, z.core.$strict>;
+        }, z.core.$strip>;
         day: z.ZodISODate;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     byKind: z.ZodArray<z.ZodObject<{
         runs: z.ZodInt;
         costUsd: z.ZodNumber;
@@ -750,13 +842,13 @@ export declare const OperatorRunUsage: z.ZodObject<{
             output: z.ZodInt;
             cacheRead: z.ZodInt;
             cacheWrite: z.ZodInt;
-        }, z.core.$strict>;
+        }, z.core.$strip>;
         kind: z.ZodEnum<{
             subscription: "subscription";
             apikey: "apikey";
             gateway: "gateway";
         }>;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     byProvider: z.ZodArray<z.ZodObject<{
         runs: z.ZodInt;
         costUsd: z.ZodNumber;
@@ -765,13 +857,13 @@ export declare const OperatorRunUsage: z.ZodObject<{
             output: z.ZodInt;
             cacheRead: z.ZodInt;
             cacheWrite: z.ZodInt;
-        }, z.core.$strict>;
+        }, z.core.$strip>;
         provider: z.ZodEnum<{
             claude: "claude";
             codex: "codex";
             gemini: "gemini";
         }>;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     runs: z.ZodInt;
     costUsd: z.ZodNumber;
     tokens: z.ZodObject<{
@@ -779,8 +871,8 @@ export declare const OperatorRunUsage: z.ZodObject<{
         output: z.ZodInt;
         cacheRead: z.ZodInt;
         cacheWrite: z.ZodInt;
-    }, z.core.$strict>;
-}, z.core.$strict>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export type OperatorRunUsage = z.infer<typeof OperatorRunUsage>;
 export declare const OperatorRunList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
@@ -793,6 +885,7 @@ export declare const OperatorRunList: z.ZodObject<{
             running: "running";
             failed: "failed";
             completed: "completed";
+            stopped: "stopped";
         }>;
         reason: z.ZodNullable<z.ZodEnum<{
             error: "error";
@@ -808,7 +901,12 @@ export declare const OperatorRunList: z.ZodObject<{
         touched: z.ZodObject<{
             processes: z.ZodArray<z.ZodString>;
             connectors: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>;
+        }, z.core.$strip>;
+        instructions: z.ZodNullable<z.ZodObject<{
+            version: z.ZodNullable<z.ZodInt>;
+            status: z.ZodNullable<z.ZodString>;
+            cut: z.ZodBoolean;
+        }, z.core.$strip>>;
         credentialKind: z.ZodNullable<z.ZodEnum<{
             subscription: "subscription";
             apikey: "apikey";
@@ -820,7 +918,15 @@ export declare const OperatorRunList: z.ZodObject<{
             output: z.ZodInt;
             cacheRead: z.ZodInt;
             cacheWrite: z.ZodInt;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
+        agents: z.ZodNullable<z.ZodObject<{
+            started: z.ZodInt;
+            running: z.ZodInt;
+        }, z.core.$strip>>;
+        stoppedBy: z.ZodNullable<z.ZodObject<{
+            userId: z.ZodTemplateLiteral<`user_${string}`>;
+            name: z.ZodString;
+        }, z.core.$strip>>;
         startedAt: z.ZodISODateTime;
         endedAt: z.ZodNullable<z.ZodISODateTime>;
         durationMs: z.ZodNullable<z.ZodInt>;
@@ -828,7 +934,7 @@ export declare const OperatorRunList: z.ZodObject<{
         machineName: z.ZodString;
         machineArchivedAt: z.ZodNullable<z.ZodISODateTime>;
         runId: z.ZodTemplateLiteral<`run_${string}`>;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodTemplateLiteral<`run_${string}`>>;
     usage: z.ZodObject<{
         byMachine: z.ZodArray<z.ZodObject<{
@@ -839,11 +945,11 @@ export declare const OperatorRunList: z.ZodObject<{
                 output: z.ZodInt;
                 cacheRead: z.ZodInt;
                 cacheWrite: z.ZodInt;
-            }, z.core.$strict>;
+            }, z.core.$strip>;
             machineId: z.ZodTemplateLiteral<`user_${string}`>;
             machineName: z.ZodString;
             machineArchivedAt: z.ZodNullable<z.ZodISODateTime>;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
         byDay: z.ZodArray<z.ZodObject<{
             runs: z.ZodInt;
             costUsd: z.ZodNumber;
@@ -852,9 +958,9 @@ export declare const OperatorRunList: z.ZodObject<{
                 output: z.ZodInt;
                 cacheRead: z.ZodInt;
                 cacheWrite: z.ZodInt;
-            }, z.core.$strict>;
+            }, z.core.$strip>;
             day: z.ZodISODate;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
         byKind: z.ZodArray<z.ZodObject<{
             runs: z.ZodInt;
             costUsd: z.ZodNumber;
@@ -863,13 +969,13 @@ export declare const OperatorRunList: z.ZodObject<{
                 output: z.ZodInt;
                 cacheRead: z.ZodInt;
                 cacheWrite: z.ZodInt;
-            }, z.core.$strict>;
+            }, z.core.$strip>;
             kind: z.ZodEnum<{
                 subscription: "subscription";
                 apikey: "apikey";
                 gateway: "gateway";
             }>;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
         byProvider: z.ZodArray<z.ZodObject<{
             runs: z.ZodInt;
             costUsd: z.ZodNumber;
@@ -878,13 +984,13 @@ export declare const OperatorRunList: z.ZodObject<{
                 output: z.ZodInt;
                 cacheRead: z.ZodInt;
                 cacheWrite: z.ZodInt;
-            }, z.core.$strict>;
+            }, z.core.$strip>;
             provider: z.ZodEnum<{
                 claude: "claude";
                 codex: "codex";
                 gemini: "gemini";
             }>;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
         runs: z.ZodInt;
         costUsd: z.ZodNumber;
         tokens: z.ZodObject<{
@@ -892,7 +998,7 @@ export declare const OperatorRunList: z.ZodObject<{
             output: z.ZodInt;
             cacheRead: z.ZodInt;
             cacheWrite: z.ZodInt;
-        }, z.core.$strict>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export type OperatorRunList = z.infer<typeof OperatorRunList>;

package/dist/operators/operators.js

@@ -175,7 +175,7 @@ export const CredentialUpdateInput = z
 export const CredentialTestInput = z.strictObject({ credentialId: CredentialId });
 // "Trennen": the value is deleted at once and without archive. Refused while an Operator uses it.
 export const CredentialRevokeInput = z.strictObject({ credentialId: CredentialId });
-export const Credential = z.strictObject({
+export const Credential = z.object({
     credentialId: CredentialId,
     // Null for a gateway credential, which serves the Operators of every provider (#470).
     provider: OperatorProvider.nullable(),
@@ -193,16 +193,16 @@ export const Credential = z.strictObject({
     createdBy: UserId.nullable(),
     updatedAt: z.iso.datetime(),
 });
-export const CredentialList = z.strictObject({
+export const CredentialList = z.object({
     items: z.array(Credential),
     nextCursor: CredentialId.nullable(),
 });
 // The smallest call at the provider with the stored value. An error names the outcome, never a value.
 export const CredentialTestResult = z.discriminatedUnion("ok", [
-    z.strictObject({ ok: z.literal(true) }),
-    z.strictObject({ ok: z.literal(false), error: z.string() }),
+    z.object({ ok: z.literal(true) }),
+    z.object({ ok: z.literal(false), error: z.string() }),
 ]);
-export const CredentialTested = z.strictObject({
+export const CredentialTested = z.object({
     credential: Credential,
     test: CredentialTestResult,
 });
@@ -270,7 +270,7 @@ export const MachineDisableInput = z.strictObject({ machineId: MachineId });
 export const MachineEnableInput = z.strictObject({ machineId: MachineId });
 // Deleting an Operator archives its machine in `access`; nothing is deleted.
 export const OperatorMachineArchiveInput = z.strictObject({ machineId: MachineId });
-export const Operator = z.strictObject({
+export const Operator = z.object({
     machineId: MachineId,
     // The machine's name in `access`, read now.
     name: z.string(),
@@ -285,13 +285,13 @@ export const Operator = z.strictObject({
     pausedAt: z.iso.datetime().nullable(),
     // "läuft" (#337): the run in progress, beside the state, so a paused Operator can still finish
     // the run it started; null while none runs.
-    running: z.strictObject({ runId: idSchema("run"), startedAt: z.iso.datetime() }).nullable(),
+    running: z.object({ runId: idSchema("run"), startedAt: z.iso.datetime() }).nullable(),
     archivedAt: z.iso.datetime().nullable(),
     createdAt: z.iso.datetime(),
     createdBy: UserId.nullable(),
     updatedAt: z.iso.datetime(),
 });
-export const OperatorList = z.strictObject({
+export const OperatorList = z.object({
     items: z.array(Operator),
     nextCursor: MachineId.nullable(),
 });
@@ -299,8 +299,9 @@ export const OperatorList = z.strictObject({
 // The runs of an Operator (#337, Einstellungen › Operator › Protokoll und Nutzung, E75, E81, E82).
 // A run's id is `run_…` like a run of `intelligence`: both are the resource `run`, in two databases.
 export const OperatorRunId = idSchema("run").describe("The Operator run's id, `run_…`, as operator_run_list returned it.");
-// `running` until the runner reports; then `completed` or `failed` with its reason (E82).
-export const OperatorRunStatus = z.enum(["running", "completed", "failed"]);
+// `running` until the runner reports; then `completed` or `failed` with its reason (E82), or
+// `stopped` when an admin stopped it by hand (E112): no failure, and no run follows for it.
+export const OperatorRunStatus = z.enum(["running", "completed", "failed", "stopped"]);
 // Why a run failed (E82): the container did not start (`container`), the provider refused or was
 // overloaded (`provider`), the longest run was reached (`timeout`), Claude Code crashed or ended with
 // an error (`crash`), it ended without its closing message (`noresult`), the package itself broke
@@ -317,17 +318,28 @@ export const OperatorRunReason = z.enum([
 ]);
 // What woke it: a change after the quiet minutes, a fixed time, or the retry after a failure.
 export const OperatorRunTrigger = z.enum(["change", "schedule", "retry"]);
-export const OperatorRunTokens = z.strictObject({
+export const OperatorRunTokens = z.object({
     input: z.int().min(0),
     output: z.int().min(0),
     cacheRead: z.int().min(0),
     cacheWrite: z.int().min(0),
 });
 // The processes and connectors a run touched, as the runner names them (#338).
-export const OperatorRunTouched = z.strictObject({
+export const OperatorRunTouched = z.object({
     processes: z.array(z.string().max(200)).max(200),
     connectors: z.array(z.string().max(200)).max(200),
 });
+// The INSTRUCTIONS a run got as its system message (#581, E111): the version of the document in the
+// Operator's root folder, its validation status then, and whether it was cut at the limit.
+export const OperatorRunInstructions = z.object({
+    version: z.int().min(1).nullable(),
+    status: z.string().nullable(),
+    cut: z.boolean(),
+});
+export const OperatorRunAgents = z.object({
+    started: z.int().min(0),
+    running: z.int().min(0),
+});
 // Who ran, named by the backend (#448): the machine's name in `access`, archived ones included, and
 // when the Operator was deleted (archived), so a run of a deleted Operator still says whose it was.
 const RunMachine = {
@@ -335,7 +347,7 @@ const RunMachine = {
     machineName: z.string(),
     machineArchivedAt: z.iso.datetime().nullable(),
 };
-export const OperatorRun = z.strictObject({
+export const OperatorRun = z.object({
     runId: OperatorRunId,
     ...RunMachine,
     trigger: OperatorRunTrigger,
@@ -346,6 +358,8 @@ export const OperatorRun = z.strictObject({
     // The summary the Operator wrote at the end itself.
     summary: z.string().nullable(),
     touched: OperatorRunTouched,
+    // Null when the run got none: no text in its INSTRUCTIONS, or a run from before #581.
+    instructions: OperatorRunInstructions.nullable(),
     // The credential's kind decides how the cost reads: `apikey` is cost, `subscription` the API
     // equivalent (E81).
     credentialKind: CredentialKind.nullable(),
@@ -353,6 +367,11 @@ export const OperatorRun = z.strictObject({
     // (#455). Through the Cloudflare AI Gateway the amount of its logs, for every provider (#470).
     costUsd: z.number().nullable(),
     tokens: OperatorRunTokens.nullable(),
+    // The subagents the run started, and how many of them run now (E112); null for a run before
+    // they were counted. Only Claude Code has subagents (E99).
+    agents: OperatorRunAgents.nullable(),
+    // Who stopped it (E112), named by the backend; null unless `status` is `stopped`.
+    stoppedBy: z.object({ userId: UserId, name: z.string() }).nullable(),
     startedAt: z.iso.datetime(),
     endedAt: z.iso.datetime().nullable(),
     durationMs: z.int().nullable(),
@@ -375,6 +394,56 @@ export const OperatorRunListInput = z.strictObject({
     limit: Limit.optional().describe("Runs per page, 1 to 100. Leaving it out gives 50."),
 });
 export const OperatorRunGetInput = z.strictObject({ runId: OperatorRunId });
+// Stopping a run by hand (E112): its container ends, the run ends `stopped`.
+export const RunCancelInput = z.strictObject({ runId: OperatorRunId });
+// One step of a run as its CLI's output showed it (E112): what the model wrote, a tool it called
+// with a short form of the input, the shortened result, a subagent's start and end. `agentId` is
+// the id of the call that started the subagent the step belongs to (`parent_tool_use_id` of Claude
+// Code), null for the main agent. `callId` ties a result to its call and a subagent's end to its
+// start. `at` is the moment Colab read the step, within a few seconds.
+export const OperatorRunStepKind = z.enum([
+    "text",
+    "thinking",
+    "tool",
+    "result",
+    "agentstart",
+    "agentend",
+    "error",
+    "truncated",
+]);
+export const OperatorRunStep = z.object({
+    seq: z.int().min(0),
+    at: z.iso.datetime(),
+    agentId: z.string().nullable(),
+    kind: OperatorRunStepKind,
+    // The tool's name as the CLI called it (`mcp__colab__intelligence_task_get`, `Bash`), or the
+    // subagent's type; null for text.
+    name: z.string().nullable(),
+    callId: z.string().nullable(),
+    // Shortened; never a credential's value, nothing under a key like `token` or `secret`.
+    text: z.string(),
+    failed: z.boolean(),
+});
+// A step's position in its run, as text: the cursor of the next page.
+const StepCursor = z
+    .string()
+    .regex(/^\d{1,6}$/)
+    .describe("The nextCursor of the previous page, for the steps after it; oldest first.");
+export const RunStepListInput = z.strictObject({
+    runId: OperatorRunId,
+    agentId: z
+        .string()
+        .min(1)
+        .max(200)
+        .optional()
+        .describe("Only the steps of this subagent: the callId of its agentstart step. Leaving it out gives every step."),
+    cursor: StepCursor.optional(),
+    limit: Limit.optional().describe("Steps per page, 1 to 100. Leaving it out gives 100."),
+});
+export const OperatorRunStepList = z.object({
+    items: z.array(OperatorRunStep),
+    nextCursor: StepCursor.nullable(),
+});
 const UsageSums = {
     runs: z.int(),
     costUsd: z.number(),
@@ -384,14 +453,14 @@ const UsageSums = {
 // day (UTC), per credential kind, so cost and API equivalent stand apart, and per provider, so the
 // tokens of Codex and Gemini, which report no amount, stand apart from Claude's (#455). `costUsd`
 // sums the runs that carry an amount: Claude's, and every run through the AI Gateway (#470).
-export const OperatorRunUsage = z.strictObject({
+export const OperatorRunUsage = z.object({
     ...UsageSums,
-    byMachine: z.array(z.strictObject({ ...RunMachine, ...UsageSums })),
-    byDay: z.array(z.strictObject({ day: z.iso.date(), ...UsageSums })),
-    byKind: z.array(z.strictObject({ kind: CredentialKind, ...UsageSums })),
-    byProvider: z.array(z.strictObject({ provider: OperatorProvider, ...UsageSums })),
+    byMachine: z.array(z.object({ ...RunMachine, ...UsageSums })),
+    byDay: z.array(z.object({ day: z.iso.date(), ...UsageSums })),
+    byKind: z.array(z.object({ kind: CredentialKind, ...UsageSums })),
+    byProvider: z.array(z.object({ provider: OperatorProvider, ...UsageSums })),
 });
-export const OperatorRunList = z.strictObject({
+export const OperatorRunList = z.object({
     items: z.array(OperatorRun),
     nextCursor: OperatorRunId.nullable(),
     usage: OperatorRunUsage,