withruntime 0.33.3 → 0.35.0

package/dist/products/agents.d.ts

@@ -51,6 +51,11 @@ export type AgentDefinition = {
      * GEMINI_API_KEY, OPENROUTER_API_KEY, or an OpenAI-compatible endpoint's
      * key with env.OPENAI_BASE_URL). */
     secrets?: string[];
+    /** Claude accounts, 1 to 16 egress secrets' names: subscription tokens,
+     * or API keys for a name holding API_KEY. Each session takes the one with
+     * the most usage left; the review template moves to the next when one is
+     * out of usage, and waits for the soonest reset when all are. */
+    pool?: string[];
     /** MCP servers the harness may reach. */
     mcp?: {
         name: string;
@@ -130,12 +135,90 @@ export type AgentEvent = {
     } & Record<string, unknown>;
     createdAt: string;
 };
+export type AgentAskState = "open" | "answered" | "expired" | "withdrawn" | "closed";
+/** One row of the account's inbox: a question a session's harness needs
+ * answered to go on. Asks of one agent's sessions sharing a memory, with the same `step` are
+ * one row while it is open, and one answer reaches every session asking. */
+export type AgentAsk = {
+    id: string;
+    /** The agent of the session that asked first. */
+    agentId: string;
+    /** What it waits on, in the asker's words. */
+    step: string | null;
+    question: string;
+    /** Why it matters. */
+    why: string | null;
+    options: {
+        label: string;
+        detail?: string;
+    }[];
+    /** The recommended option's label; taken as the answer when it expires. */
+    pick: string | null;
+    /** Who sees it: its agent's labels with the ask's own over them. */
+    labels: Record<string, string>;
+    state: AgentAskState;
+    /** An option's label and/or words; `expired` when the pick was taken at
+     * expiry. */
+    answer: {
+        option?: string;
+        text?: string;
+        expired?: boolean;
+    } | null;
+    /** A key's principal id, or `runtime` for a pick taken at expiry. */
+    answeredBy: string | null;
+    /** The sessions asking it, each with its ask event's seq and the answer
+     * event that woke it. */
+    sessions: {
+        sessionId: string;
+        state: "asking" | "answered" | "expired" | "withdrawn" | "ended";
+        seq: number;
+        answerSeq: number | null;
+    }[];
+    expiresAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    closedAt: string | null;
+};
+export type ListAgentAsks = {
+    /** Open by default. */
+    state?: AgentAskState[];
+    agent?: string;
+    /** Asks carrying every one of these labels: who sees an ask. */
+    labels?: Record<string, string>;
+    cursor?: string;
+    limit?: number;
+};
+/** An option's label, words, or both. */
+export type AnswerAgentAsk = {
+    option?: string;
+    text?: string;
+};
 export type AgentTriggerKind = "slack" | "github" | "schedule" | "webhook";
+/** A trigger's rules, each optional. */
+export type AgentTriggerRules = {
+    /** Queue order of its sessions when the agent's maxConcurrent is full:
+     * -100 to 100, higher first, then oldest. Default 0. */
+    priority?: number;
+    /** Sessions it may start in an hour; a call past it is held for you.
+     * Joining an open session is never capped. Default none. */
+    maxStartsPerHour?: number;
+    /** A call whose key's last session has ended: "start" a new one (the
+     * default), "note" it in the ended session's log and run nothing, or
+     * "ask" you (the call is held until you start it). */
+    onEnded?: "start" | "note" | "ask";
+    /** Where a held call is told: "email" to who added the trigger (the
+     * default), or "webhook", the account's webhooks' agent.call.held alone. */
+    notify?: "email" | "webhook";
+    /** A webhook's only: the key of a call that sends none, from its JSON's
+     * fields: "{cause}", "{alert.host}:{check}". */
+    key?: string;
+};
 export type AgentTrigger = {
     id: string;
     agentId: string;
     kind: AgentTriggerKind;
     config: Record<string, unknown>;
+    rules: AgentTriggerRules;
     pausedAt: string | null;
     pausedWhy: string | null;
     createdAt: string;
@@ -157,7 +240,7 @@ export type StartAgentSession = {
     key?: string;
     labels?: Record<string, string>;
 };
-export type CreateAgentTrigger = {
+export type CreateAgentTrigger = ({
     kind: "slack";
     config: {
         team: string;
@@ -180,9 +263,48 @@ export type CreateAgentTrigger = {
 } | {
     kind: "webhook";
     config: Record<string, never>;
+}) & {
+    rules?: AgentTriggerRules;
+};
+/** One call to a webhook trigger: its words, and the key and labels of the
+ * session it starts or joins. */
+export type AgentTriggerCall = {
+    text: string;
+    key?: string;
+    labels?: Record<string, string>;
+};
+/** What a call did: started a session, joined its key's open one, was
+ * noted in its key's ended one, or was held for you (`why`). */
+export type AgentTriggerCallOutcome = {
+    outcome: "started" | "joined" | "noted" | "held";
+    sessionId: string | null;
+    seq: number | null;
+    callId: string | null;
+    why: AgentHeldCall["why"] | null;
+    replayed: boolean;
+};
+/** A call a trigger held for you because no session could take it. None is
+ * ever dropped. */
+export type AgentHeldCall = {
+    id: string;
+    triggerId: string;
+    agentId: string;
+    key: string | null;
+    text: string;
+    labels: Record<string, string>;
+    /** The trigger was paused; it had started maxStartsPerHour sessions this
+     * hour; its key's session had ended and onEnded is "ask"; the agent's day
+     * budget was spent; the account's sessions were at their limit; Agents
+     * was closed to the account. */
+    why: "paused" | "rate" | "ended" | "budget" | "quota" | "closed";
+    state: "held" | "started" | "dismissed";
+    sessionId: string | null;
+    notify: "email" | "webhook";
+    createdAt: string;
+    resolvedAt: string | null;
 };
-/** The five harnesses' names, so `templates["claude-code"]` is known to be there. */
-export type AgentTemplateKey = "claude-code" | "codex" | "gemini-cli" | "claude-agent-sdk" | "openai-agents-sdk";
+/** The harnesses' names, so `templates["claude-code"]` is known to be there. */
+export type AgentTemplateKey = "claude-code" | "codex" | "gemini-cli" | "claude-agent-sdk" | "openai-agents-sdk" | "review" | "judge";
 /** A file of an agent's memory (`memory.list`). `scope` is whose: empty for
  * the shared memory, which every session reads (one keeping memory per key
  * reads what you wrote there, and never changes it), or a session key
@@ -240,9 +362,8 @@ export type AgentTemplate = {
     /** How your own subscription logs it in, for your own team's agents, or
      * null when it takes an API key alone. */
     subscription: string | null;
-    definition: {
+    definition: Pick<AgentDefinition, "secrets" | "pool" | "vcpu" | "memoryMiB" | "maxSessionSeconds"> & {
         command: string;
-        secrets: string[];
     };
 };
 /** A use: what an agent is for, merged into a template's definition. */
@@ -257,7 +378,7 @@ export type AgentUse = {
         template: "support" | "team";
     };
 };
-/** The five harnesses (agents-contract.md); tests/agents.test.ts holds them
+/** The harnesses (agents-contract.md); tests/agents.test.ts holds them
  * to packages/cloud-guide/agent-templates.json. */
 export declare const AGENT_TEMPLATES: Readonly<Record<AgentTemplateKey, AgentTemplate>>;
 /** A harness by a key read from a file or a flag, or undefined. */
@@ -321,13 +442,45 @@ export declare function agents(t: Transport): {
          * (`session_open`): stop it first. */
         delete: (id: string, options?: RequestOptions) => Promise<void>;
     };
+    /** The account's inbox: the questions its agents' sessions need answered
+     * to go on, one row per step however many sessions ask it. */
+    asks: {
+        /** Newest first; open ones unless `state` says otherwise. */
+        list: (query?: ListAgentAsks, options?: RequestOptions) => Promise<Page<AgentAsk>>;
+        get: (id: string, options?: RequestOptions) => Promise<AgentAsk>;
+        /** Every session asking it reads the answer next, and wakes. An ask no
+         * longer open is refused with `ask_closed`. */
+        answer: (id: string, answer: AnswerAgentAsk, options?: RequestOptions) => Promise<AgentAsk>;
+    };
     triggers: {
         create: (agent: string, input: CreateAgentTrigger, options?: RequestOptions) => Promise<AgentTrigger>;
         list: (agent: string, options?: RequestOptions) => Promise<AgentTrigger[]>;
-        /** Its events are refused, saying `why`; nothing else is held. */
+        /** Held: a webhook's calls are kept for you (see `held`), saying
+         * `why`; nothing else is held. */
         pause: (id: string, why: string, options?: RequestOptions) => Promise<AgentTrigger>;
         resume: (id: string, options?: RequestOptions) => Promise<AgentTrigger>;
         delete: (id: string, options?: RequestOptions) => Promise<void>;
+        /** Its rules, whole, in place: its secret stays. `{}` is every default. */
+        setRules: (id: string, rules: AgentTriggerRules, options?: RequestOptions) => Promise<AgentTrigger>;
+        /** A webhook trigger's call, as its sender makes it: by the trigger's
+         * secret, never your key. A call with the key of an open session joins
+         * it. Pass `idempotencyKey` to make a retry the same call. */
+        call: (id: string, secret: string, call: AgentTriggerCall, options?: RequestOptions) => Promise<AgentTriggerCallOutcome>;
+        /** Calls it held for you, newest first. */
+        held: (trigger: string, query?: {
+            state?: AgentHeldCall["state"][];
+            cursor?: string;
+            limit?: number;
+        }, options?: RequestOptions) => Promise<Page<AgentHeldCall>>;
+        /** Start a held call: one session with it and every call held for its
+         * key since, oldest first. */
+        startHeld: (id: string, call: string, options?: RequestOptions) => Promise<{
+            session: AgentSession;
+            joined: boolean;
+            calls: number;
+        }>;
+        /** Dismiss a held call: nothing runs. */
+        dismissHeld: (id: string, call: string, options?: RequestOptions) => Promise<AgentHeldCall>;
     };
     /** Its built-in memory: text files kept across sessions, which the
      * agent reads, writes and searches from inside its sessions. A scope is
@@ -363,7 +516,8 @@ export declare function agents(t: Transport): {
         }, options?: RequestOptions) => Promise<boolean>;
     };
     /** The harnesses, as data: claude-code, codex, gemini-cli,
-     * claude-agent-sdk, openai-agents-sdk. */
+     * claude-agent-sdk, openai-agents-sdk, review (a CI/CD agent step's
+     * reviewer) and judge (an agent step held to your instructions alone). */
     templates: Readonly<Record<AgentTemplateKey, AgentTemplate>>;
     /** The uses, as data: support (your customers) and team (your team). */
     uses: Readonly<Record<"team" | "support", AgentUse>>;

package/dist/products/agents.js

@@ -22,7 +22,9 @@ import { Page } from "../page.js";
 const START = 'npx -y @anthropic-ai/claude-code --dangerously-skip-permissions --mcp-config ~/.runtime-agent/mcp.json -p "$(cat ~/.runtime-agent/start.md)"';
 const CODEX = 'npx -y @openai/codex exec --dangerously-bypass-approvals-and-sandbox "$(cat ~/.runtime-agent/start.md)"';
 const GEMINI = 'npx -y @google/gemini-cli --yolo -p "$(cat ~/.runtime-agent/start.md)"';
-/** The five harnesses (agents-contract.md); tests/agents.test.ts holds them
+const REVIEW = "python3 ~/.runtime-agent/runtime-agent review";
+const JUDGE = "python3 ~/.runtime-agent/runtime-agent judge";
+/** The harnesses (agents-contract.md); tests/agents.test.ts holds them
  * to packages/cloud-guide/agent-templates.json. */
 export const AGENT_TEMPLATES = {
     "claude-code": {
@@ -70,6 +72,36 @@ export const AGENT_TEMPLATES = {
         subscription: null,
         definition: { command: "python3 ~/agent.py", secrets: ["OPENAI_API_KEY"] },
     },
+    review: {
+        key: "review",
+        title: "Code review",
+        command: REVIEW,
+        apiKeySecret: "ANTHROPIC_API_KEY",
+        apiKeyHost: "api.anthropic.com",
+        subscription: "a token per account: run `claude setup-token` on your own computer (Pro/Max) for each, store each with `runtime secrets set CLAUDE_1` scoped to api.anthropic.com, then name them all in pool (--pool CLAUDE_1 --pool CLAUDE_2)",
+        definition: {
+            command: REVIEW,
+            pool: ["ANTHROPIC_API_KEY"],
+            vcpu: 2,
+            memoryMiB: 2048,
+            maxSessionSeconds: 1800,
+        },
+    },
+    judge: {
+        key: "judge",
+        title: "Your rules",
+        command: JUDGE,
+        apiKeySecret: "ANTHROPIC_API_KEY",
+        apiKeyHost: "api.anthropic.com",
+        subscription: "a token per account, as for review: `runtime secrets set CLAUDE_1` scoped to api.anthropic.com for each, then name them all in pool; its instructions are the rules that block",
+        definition: {
+            command: JUDGE,
+            pool: ["ANTHROPIC_API_KEY"],
+            vcpu: 2,
+            memoryMiB: 2048,
+            maxSessionSeconds: 1800,
+        },
+    },
 };
 /** A harness by a key read from a file or a flag, or undefined. */
 export function agentTemplate(key) {
@@ -166,6 +198,28 @@ export function agents(t) {
         });
         return new Page(page.data, page.nextCursor, (cursor) => listSessions({ ...query, cursor }, options));
     };
+    const listAsks = async (query = {}, options) => {
+        const { labels, ...rest } = query;
+        const page = await t.json({
+            method: "GET",
+            path: "/v1/agents/asks",
+            query: {
+                ...rest,
+                ...(labels ? { label: Object.entries(labels).map(([k, v]) => `${k}:${v}`) } : {}),
+            },
+            ...options,
+        });
+        return new Page(page.data, page.nextCursor, (cursor) => listAsks({ ...query, cursor }, options));
+    };
+    const listHeld = async (trigger, query = {}, options) => {
+        const page = await t.json({
+            method: "GET",
+            path: `/v1/agents/triggers/${enc(trigger)}/held`,
+            query,
+            ...options,
+        });
+        return new Page(page.data, page.nextCursor, (cursor) => listHeld(trigger, { ...query, cursor }, options));
+    };
     const listMemory = async (agent, query = {}, options) => {
         const page = await t.json({
             method: "GET",
@@ -227,6 +281,21 @@ export function agents(t) {
                 });
             },
         },
+        /** The account's inbox: the questions its agents' sessions need answered
+         * to go on, one row per step however many sessions ask it. */
+        asks: {
+            /** Newest first; open ones unless `state` says otherwise. */
+            list: listAsks,
+            get: (id, options) => t.json({ method: "GET", path: `/v1/agents/asks/${enc(id)}`, ...options }),
+            /** Every session asking it reads the answer next, and wakes. An ask no
+             * longer open is refused with `ask_closed`. */
+            answer: (id, answer, options) => t.json({
+                method: "POST",
+                path: `/v1/agents/asks/${enc(id)}/answer`,
+                body: answer,
+                ...options,
+            }),
+        },
         triggers: {
             create: (agent, input, options) => t.json({
                 method: "POST",
@@ -239,7 +308,8 @@ export function agents(t) {
                 path: `/v1/agents/${enc(agent)}/triggers`,
                 ...options,
             })).data,
-            /** Its events are refused, saying `why`; nothing else is held. */
+            /** Held: a webhook's calls are kept for you (see `held`), saying
+             * `why`; nothing else is held. */
             pause: (id, why, options) => t.json({
                 method: "POST",
                 path: `/v1/agents/triggers/${enc(id)}/pause`,
@@ -259,6 +329,40 @@ export function agents(t) {
                     ...options,
                 });
             },
+            /** Its rules, whole, in place: its secret stays. `{}` is every default. */
+            setRules: (id, rules, options) => t.json({
+                method: "PATCH",
+                path: `/v1/agents/triggers/${enc(id)}`,
+                body: { rules },
+                ...options,
+            }),
+            /** A webhook trigger's call, as its sender makes it: by the trigger's
+             * secret, never your key. A call with the key of an open session joins
+             * it. Pass `idempotencyKey` to make a retry the same call. */
+            call: (id, secret, call, options) => t.json({
+                method: "POST",
+                path: `/v1/agents/triggers/${enc(id)}/calls`,
+                body: call,
+                bearer: secret,
+                ...options,
+            }),
+            /** Calls it held for you, newest first. */
+            held: listHeld,
+            /** Start a held call: one session with it and every call held for its
+             * key since, oldest first. */
+            startHeld: (id, call, options) => t.json({
+                method: "POST",
+                path: `/v1/agents/triggers/${enc(id)}/held/${enc(call)}/start`,
+                body: {},
+                ...options,
+            }),
+            /** Dismiss a held call: nothing runs. */
+            dismissHeld: (id, call, options) => t.json({
+                method: "POST",
+                path: `/v1/agents/triggers/${enc(id)}/held/${enc(call)}/dismiss`,
+                body: {},
+                ...options,
+            }),
         },
         /** Its built-in memory: text files kept across sessions, which the
          * agent reads, writes and searches from inside its sessions. A scope is
@@ -292,7 +396,8 @@ export function agents(t) {
             })).deleted,
         },
         /** The harnesses, as data: claude-code, codex, gemini-cli,
-         * claude-agent-sdk, openai-agents-sdk. */
+         * claude-agent-sdk, openai-agents-sdk, review (a CI/CD agent step's
+         * reviewer) and judge (an agent step held to your instructions alone). */
         templates: AGENT_TEMPLATES,
         /** The uses, as data: support (your customers) and team (your team). */
         uses: AGENT_USES,

package/dist/products/apps.d.ts

@@ -39,7 +39,42 @@ export type StatefulSettings = {
     /** Seconds a stopped copy has after SIGTERM to exit. */
     stopGraceSeconds: number;
 };
-export type App = AppSettings & StatefulSettings & {
+/** How an App's new version goes live: every copy together (at_once, the
+ * default), or staged: one copy of it beside the live version's, then about
+ * 10%, 50% and all of them, each stage judged on its visitors' errors and
+ * speed before the next. A stage that does worse goes back: its copies
+ * finish their requests and stop, then the deploy fails (deploy_stage_failed)
+ * and the live version never stops serving. */
+export type ReleaseStages = "at_once" | "staged";
+export type ReleaseSettings = {
+    releaseStages: ReleaseStages;
+    /** 60 to 3600 seconds; defaults to 300. How long each stage runs once its
+     * copies serve before it is judged. */
+    releaseSoakSeconds: number;
+};
+/** An App's staged release under way, or its last. */
+export type StagedRelease = {
+    version: number;
+    /** The version live when it began, serving beside it. */
+    from: number;
+    /** rolling: its stages go live; back: a stage did worse and its copies
+     * leave; done: every copy runs it; failed: it went back (or its copies
+     * failed their health check) and the version failed; ended: another
+     * deploy or a rollback took its place. */
+    state: "rolling" | "back" | "done" | "failed" | "ended";
+    stage: number;
+    stages: number;
+    /** Copies of the new version the stage serves beside the old version's. */
+    copies: number;
+    /** Copies the release walks to. */
+    of: number;
+    soakSeconds: number;
+    /** Its last step, in words. */
+    detail: string;
+    startedAt: number;
+    updatedAt: number;
+};
+export type App = AppSettings & StatefulSettings & ReleaseSettings & {
     id: string;
     name: string | null;
     /** Its address for life, its name then its account's:
@@ -58,6 +93,8 @@ export type App = AppSettings & StatefulSettings & {
     } | null;
     liveVersion: number | null;
     previousVersion: number | null;
+    /** Its staged release under way, or its last; null before its first. */
+    stagedRelease: StagedRelease | null;
     /** While a copy waits for room in its region: its account's lane, its
      * place in line (1 is next), how many wait ahead by lane, and why.
      * Higher lanes get room first. Absent while nothing of it waits. */
@@ -69,7 +106,7 @@ export type AppLine = {
     ahead: Record<string, number>;
     words: string;
 };
-export type RuntimeFunction = Omit<App, "minCopies" | keyof StatefulSettings> & {
+export type RuntimeFunction = Omit<App, "minCopies" | keyof StatefulSettings | keyof ReleaseSettings | "stagedRelease"> & {
     minCopies: 0;
     /** 250 to 5000 ms: at most how long a copy stays awake after its last request ends. */
     sleepAfterMs: number;
@@ -125,14 +162,18 @@ export type CreateApp = Omit<CreateFunction, "minCopies" | "sleepAfterMs"> & {
     volume?: AppVolume;
     /** 0 to 900; defaults to 30. */
     stopGraceSeconds?: number;
+    /** Defaults to "at_once"; see ReleaseStages. */
+    releaseStages?: ReleaseStages;
+    /** 60 to 3600; defaults to 300. */
+    releaseSoakSeconds?: number;
 };
-export type UpdateApp = Partial<AppSettings & StatefulSettings> & {
+export type UpdateApp = Partial<AppSettings & StatefulSettings & ReleaseSettings> & {
     name?: string | null;
     labels?: Record<string, string>;
     /** Only Functions sleep on this rule; an App is refused it. */
     sleepAfterMs?: never;
 };
-export type UpdateFunction = Omit<UpdateApp, "minCopies" | "sleepAfterMs" | keyof StatefulSettings> & {
+export type UpdateFunction = Omit<UpdateApp, "minCopies" | "sleepAfterMs" | keyof StatefulSettings | keyof ReleaseSettings> & {
     minCopies?: never;
     /** 250 to 5000 ms; see CreateFunction.sleepAfterMs. */
     sleepAfterMs?: number;
@@ -159,7 +200,7 @@ export type AppDeploy = {
 } | {
     state: "failed" | "superseded";
     error: {
-        code: "deploy_build_failed" | "deploy_health_failed" | "deploy_stop_failed" | "deploy_switch_failed" | "deploy_superseded";
+        code: "deploy_build_failed" | "deploy_health_failed" | "deploy_stop_failed" | "deploy_stage_failed" | "deploy_switch_failed" | "deploy_superseded";
         message: string;
         hint: string;
         lastOutput: string;

package/dist/products/browsers.d.ts

@@ -40,6 +40,28 @@ export type BrowserInfo = {
     liveViewUrl?: string;
     hint?: string;
 };
+export type BrowserScreenshot = {
+    /** An http(s) address, opened in a new tab that is closed after. */
+    url?: string;
+    /** The whole page, not only the window. */
+    fullPage?: boolean;
+    format?: "png" | "jpeg";
+    /** 0 to 10000 ms after the page loads, for late scripts. */
+    waitMs?: number;
+};
+export type BrowserScreenshotResult = {
+    /** Where the page ended, after redirects. */
+    url: string;
+    title: string;
+    /** The page's HTTP status; null for the page already shown. */
+    status: number | null;
+    mimeType: "image/png" | "image/jpeg";
+    bytes: number;
+    width: number | null;
+    height: number | null;
+    /** The image. */
+    base64: string;
+};
 export type BrowserConnectOptions = {
     playwright: [endpointURL: string, options: {
         headers: Record<string, string>;
@@ -66,6 +88,10 @@ export declare function browsers(t: Transport): {
     list: (query?: ListBrowsers, options?: RequestOptions) => Promise<Page<Browser>>;
     /** Change a browser's name or labels without changing its compute settings. */
     update(id: string, input: UpdateBrowser, options?: RequestOptions): Promise<Browser>;
+    /** Open `url` in a new tab and shoot it once it loads (without `url`, what
+     * the browser shows now); the image is `base64`, its page's url, title
+     * and HTTP status beside it. Runs inside the browser's own sandbox. */
+    screenshot(id: string, input?: BrowserScreenshot, options?: RequestOptions): Promise<BrowserScreenshotResult>;
     /** End a browser by id; pass RequestOptions to bound or deduplicate the request. */
     delete: (id: string, options?: RequestOptions) => Promise<void>;
 };

package/dist/products/browsers.js

@@ -96,6 +96,17 @@ export function browsers(t) {
                 ...options,
             }));
         },
+        /** Open `url` in a new tab and shoot it once it loads (without `url`, what
+         * the browser shows now); the image is `base64`, its page's url, title
+         * and HTTP status beside it. Runs inside the browser's own sandbox. */
+        screenshot(id, input = {}, options) {
+            return t.json({
+                method: "POST",
+                path: `${path(id)}:screenshot`,
+                body: input,
+                ...options,
+            });
+        },
         /** End a browser by id; pass RequestOptions to bound or deduplicate the request. */
         delete: remove,
     };

package/dist/products/ci.d.ts

@@ -144,7 +144,8 @@ export type CiReviewFinding = {
     /** What would put it right. */
     fix: string;
 };
-/** A review step's verdict on one commit: it passes only with no findings. */
+/** An agent step's verdict on one commit (`review:` is its short form): it
+ * passes only with no findings. */
 export type CiReview = {
     verdict: "pass" | "block";
     summary: string;
@@ -155,10 +156,11 @@ export type CiReview = {
         line: number;
         what: string;
     }[];
-    /** The Runtime Agent that reviewed, the account it ran on and its model. */
+    /** The Runtime Agent that judged, and the model the step asked for. */
     agent: string;
-    account: string;
-    model: string;
+    model: string | null;
+    /** The Claude account a verdict before agent steps ran on. */
+    account?: string;
     /** The agent session that gave the verdict. */
     session: string;
     /** True when the diff was too long and its end was not read. */
@@ -353,6 +355,10 @@ export declare function ci(t: Transport): {
          * are let go. A check that has ended is answered as it is; to a key
          * that may cancel it but not read it, with its id and state alone. */
         cancel: (id: string, options?: RequestOptions) => Promise<CiCheckDetail | CiCancelled>;
+        /** Run a check again, as GitHub's Re-run does: a new check of the
+         * same commit (a pull request's as it would land now), trusted only as
+         * the commit's last check was. A check still going is answered as it is. */
+        rerun: (id: string, options?: RequestOptions) => Promise<CiCheckDetail | CiCancelled>;
     };
     jobs: {
         /** A job with the tail of its log and the sandboxes it ran in. */

package/dist/products/ci.js

@@ -92,6 +92,14 @@ export function ci(t) {
                 path: `${at("/v1/ci/checks", id)}:cancel`,
                 ...options,
             }),
+            /** Run a check again, as GitHub's Re-run does: a new check of the
+             * same commit (a pull request's as it would land now), trusted only as
+             * the commit's last check was. A check still going is answered as it is. */
+            rerun: (id, options) => t.json({
+                method: "POST",
+                path: `${at("/v1/ci/checks", id)}:rerun`,
+                ...options,
+            }),
         },
         jobs: {
             /** A job with the tail of its log and the sandboxes it ran in. */

package/dist/products/desktops.d.ts

@@ -0,0 +1,71 @@
+/** Desktops: a Linux desktop on its own sandbox, billed at the sandbox rates
+ * (packages/cloud/src/api/products/desktops.ts), at /v1/desktops, with a
+ * private live view and computer use: screenshot and act. In a private beta:
+ * an account outside it is refused with product_in_beta (403), and retrying
+ * does not change it. */
+import type { RequestOptions, Transport } from "../transport.js";
+import { type ResourceRecord } from "./resources.js";
+export type DesktopState = "starting" | "running" | "paused" | "stopped" | "failed" | "deleted";
+export type Desktop = ResourceRecord & {
+    name: string | null;
+    labels: Record<string, string>;
+    state: DesktopState;
+    sandboxId: string;
+    createdAt: number;
+    updatedAt: number;
+    deletedAt: number | null;
+    memoryMiB: number;
+    vcpu: number;
+    width: number;
+    height: number;
+    timeoutSeconds: number;
+    idlePauseSeconds: number;
+    /** Opens the live desktop in a browser; carries a private preview token. */
+    liveViewUrl?: string;
+    /** When liveViewUrl's token ends; get the desktop again for a fresh one. */
+    expiresAt: string | null;
+    actions: {
+        screenshot: string;
+        act: string;
+        record: string;
+    };
+};
+export type CreateDesktop = {
+    /** 1024–16384 MiB; the server defaults to 2048. */
+    memoryMiB?: number;
+    /** The server defaults to 2 vCPU. */
+    vcpu?: number;
+    /** The screen, 640x480 to 3840x2160; 1280x800 by default. */
+    width?: number;
+    height?: number;
+    timeoutSeconds?: number;
+    idlePauseSeconds?: number;
+    name?: string;
+    labels?: Record<string, string>;
+};
+/** Only the name and labels change; a null name clears it. */
+export type UpdateDesktop = {
+    name?: string | null;
+    labels?: Record<string, string>;
+};
+/** One computer-use step, as POST /v1/desktops/{id}:act takes it. */
+export type DesktopAct = {
+    action: string;
+} & Record<string, unknown>;
+export declare function desktops(t: Transport): {
+    /** The screen as PNG (or JPEG) bytes. A write: it runs in the desktop's
+     * sandbox and wakes a paused one, so a read-only key is refused it. */
+    screenshot(id: string, shot?: {
+        format?: "png" | "jpeg";
+        quality?: number;
+    }, options?: RequestOptions): Promise<Uint8Array<ArrayBufferLike>>;
+    /** Move, click, drag, scroll, type, press keys, open a URL or launch a program. */
+    act(id: string, step: DesktopAct, options?: RequestOptions): Promise<Record<string, unknown>>;
+    base: string;
+    create: (input: CreateDesktop, options?: RequestOptions) => Promise<Desktop>;
+    get: (id: string, options?: import("./resources.js").ResourceGetOptions<"paused" | "stopped" | "starting" | "running" | "deleted" | "failed">) => Promise<Desktop>;
+    list: (query?: import("./resources.js").ResourceListQuery<"paused" | "stopped" | "starting" | "running" | "deleted" | "failed">, options?: RequestOptions) => Promise<import("../page.js").Page<Desktop>>;
+    update: (id: string, input: UpdateDesktop, options?: RequestOptions) => Promise<Desktop>;
+    wait: (id: string, target: "paused" | "stopped" | "starting" | "running" | "deleted" | "failed", options?: import("./resources.js").ResourceWaitOptions) => Promise<Desktop>;
+    delete: (id: string, options?: import("./resources.js").ResourceDeleteOptions) => Promise<Desktop>;
+};