@swarm-agent/sdk 0.1.52 → 0.1.53

package/dist/auth.d.ts

@@ -1,6 +1,6 @@
 import { SwarmCredentialsNamespace, SwarmCodexAuthNamespace } from './provider-auth.js';
 import type { SwarmTransport } from './transport.js';
-import type { CreateScopedTokenParams, CreateScopedTokenResult, DesktopSessionBootstrap, ScopedTokenRecord } from './types.js';
+import type { CreateKeyParams, CreateScopedTokenParams, CreateScopedTokenResult, DesktopSessionBootstrap, ScopedTokenRecord } from './types.js';
 export declare class SwarmAuthNamespace {
     readonly credentials: SwarmCredentialsNamespace;
     readonly codex: SwarmCodexAuthNamespace;
@@ -18,6 +18,8 @@ export declare class SwarmAuthNamespace {
     }): Promise<DesktopSessionBootstrap>;
     /**
      * Creates a new scoped deploy token with granular permission scopes.
+     * Every key works while it is used and stops after 90 days unused;
+     * `expires_in_seconds` adds an optional fixed end date (at most 365 days).
      * Returns the plaintext token (prefixed with 'swk_') along with the token record.
      * Store the token securely—it cannot be retrieved again in plaintext!
      */
@@ -29,8 +31,9 @@ export declare class SwarmAuthNamespace {
      * their own browser); neither may approve tool calls or manage anything. `full`
      * keys are for an AI the owner trusts to run the box: they also approve
      * tool calls and manage models, workers, limits, custom agents and client app
-     * keys. Every level reaches only `/mcp`. Lifetime
-     * defaults to 30 days (at most 365). Owner only.
+     * keys. Every level reaches only `/mcp`. The key works while it is used and
+     * stops after 90 days unused; `expires_in_seconds` adds an optional fixed
+     * end date (at most 365 days). Owner only.
      */
     createAIKey(params: {
         name: string;
@@ -42,6 +45,18 @@ export declare class SwarmAuthNamespace {
      * Secret hashes are masked; hints (e.g. 'swk_...abcd') are displayed.
      */
     listScopedTokens(): Promise<ScopedTokenRecord[]>;
+    /**
+     * Makes a key of one of the three kinds (see CreateKeyParams) and returns it
+     * once with its record (key_kind, lapses_at, lapse_reason). Owner only.
+     */
+    createKey(params: CreateKeyParams): Promise<CreateScopedTokenResult>;
+    /**
+     * Every key that reaches this box, with its kind, state, last use and where
+     * from, and when it stops working on its own. Owner only.
+     */
+    listKeys(): Promise<ScopedTokenRecord[]>;
+    /** Stops a key working now, and every key made with it. Owner only. */
+    revokeKey(keyId: string): Promise<ScopedTokenRecord>;
     /**
      * Revokes a scoped token by ID.
      * The token immediately ceases to authenticate requests.

package/dist/auth.js

@@ -38,6 +38,8 @@ export class SwarmAuthNamespace {
     }
     /**
      * Creates a new scoped deploy token with granular permission scopes.
+     * Every key works while it is used and stops after 90 days unused;
+     * `expires_in_seconds` adds an optional fixed end date (at most 365 days).
      * Returns the plaintext token (prefixed with 'swk_') along with the token record.
      * Store the token securely—it cannot be retrieved again in plaintext!
      */
@@ -61,8 +63,9 @@ export class SwarmAuthNamespace {
      * their own browser); neither may approve tool calls or manage anything. `full`
      * keys are for an AI the owner trusts to run the box: they also approve
      * tool calls and manage models, workers, limits, custom agents and client app
-     * keys. Every level reaches only `/mcp`. Lifetime
-     * defaults to 30 days (at most 365). Owner only.
+     * keys. Every level reaches only `/mcp`. The key works while it is used and
+     * stops after 90 days unused; `expires_in_seconds` adds an optional fixed
+     * end date (at most 365 days). Owner only.
      */
     async createAIKey(params) {
         const res = await this.transport.request('/v3/auth/tokens', {
@@ -81,6 +84,31 @@ export class SwarmAuthNamespace {
         });
         return res.data?.tokens ?? [];
     }
+    /**
+     * Makes a key of one of the three kinds (see CreateKeyParams) and returns it
+     * once with its record (key_kind, lapses_at, lapse_reason). Owner only.
+     */
+    async createKey(params) {
+        const { kind, name, access, expires_in_seconds, ...rest } = params;
+        const body = { kind, name, ...rest };
+        if (kind === 'ai')
+            body.ai_access = access;
+        if (expires_in_seconds !== undefined)
+            body.expires_in_seconds = expires_in_seconds;
+        const res = await this.transport.request('/v3/auth/tokens', { method: 'POST', body });
+        return res.data;
+    }
+    /**
+     * Every key that reaches this box, with its kind, state, last use and where
+     * from, and when it stops working on its own. Owner only.
+     */
+    async listKeys() {
+        return this.listScopedTokens();
+    }
+    /** Stops a key working now, and every key made with it. Owner only. */
+    async revokeKey(keyId) {
+        return this.revokeScopedToken(keyId);
+    }
     /**
      * Revokes a scoped token by ID.
      * The token immediately ceases to authenticate requests.

package/dist/client.d.ts

@@ -1,3 +1,4 @@
+import { SwarmLimitsNamespace } from './limits.js';
 import { SwarmAgentsNamespace } from './agents.js';
 import { SwarmAppsNamespace } from './apps.js';
 import { SwarmChatNamespace } from './chat.js';
@@ -13,6 +14,8 @@ import { SwarmDeliverablesNamespace } from './deliverables.js';
 import { SwarmDeployNamespace } from './deploy/index.js';
 import { SwarmNotificationsNamespace } from './notifications.js';
 import { SwarmSignalsNamespace } from './signals.js';
+import { SwarmJobAutomationsNamespace } from './job-automations.js';
+import { SwarmActivityNamespace } from './activity.js';
 import { SwarmBoxNamespace } from './box.js';
 import { SwarmProjectsNamespace } from './projects.js';
 import { SwarmRemoteNamespace } from './remote.js';
@@ -39,6 +42,7 @@ export declare class SwarmClient {
      * revisions, attached automations, and portable import/export definitions over /v3/workers.
      */
     readonly workers: SwarmWorkersNamespace;
+    readonly limits: SwarmLimitsNamespace;
     readonly usage: SwarmUsageNamespace;
     readonly deliverables: SwarmDeliverablesNamespace;
     /** Convenient alias for deliverables namespace: mailbox */
@@ -58,6 +62,13 @@ export declare class SwarmClient {
     readonly inbox: SwarmNotificationsNamespace;
     /** Machine signal feed: blocked agents, failures, refused keys, reported events. */
     readonly signals: SwarmSignalsNamespace;
+    /**
+     * Workflows: steps Swarm runs when a task of its own agents or a worker job
+     * ends (/v3/workflows, /v3/job-deliveries). Not the legacy `automations`
+     * namespace.
+     */
+    readonly workflows: SwarmJobAutomationsNamespace;
+    readonly activity: SwarmActivityNamespace;
     /** Machine state for monitors: sandbox, blocked sessions, failing workers, usage. */
     readonly box: SwarmBoxNamespace;
     readonly storage: SwarmStorageNamespace;

package/dist/client.js

@@ -1,3 +1,4 @@
+import { SwarmLimitsNamespace } from './limits.js';
 import { SwarmAgentsNamespace } from './agents.js';
 import { SwarmAppsNamespace } from './apps.js';
 import { SwarmChatNamespace } from './chat.js';
@@ -13,6 +14,8 @@ import { SwarmDeliverablesNamespace } from './deliverables.js';
 import { SwarmDeployNamespace } from './deploy/index.js';
 import { SwarmNotificationsNamespace } from './notifications.js';
 import { SwarmSignalsNamespace } from './signals.js';
+import { SwarmJobAutomationsNamespace } from './job-automations.js';
+import { SwarmActivityNamespace } from './activity.js';
 import { SwarmBoxNamespace } from './box.js';
 import { SwarmProjectsNamespace } from './projects.js';
 import { SwarmRemoteNamespace } from './remote.js';
@@ -39,6 +42,7 @@ export class SwarmClient {
      * revisions, attached automations, and portable import/export definitions over /v3/workers.
      */
     workers;
+    limits;
     usage;
     deliverables;
     /** Convenient alias for deliverables namespace: mailbox */
@@ -58,6 +62,13 @@ export class SwarmClient {
     inbox;
     /** Machine signal feed: blocked agents, failures, refused keys, reported events. */
     signals;
+    /**
+     * Workflows: steps Swarm runs when a task of its own agents or a worker job
+     * ends (/v3/workflows, /v3/job-deliveries). Not the legacy `automations`
+     * namespace.
+     */
+    workflows;
+    activity;
     /** Machine state for monitors: sandbox, blocked sessions, failing workers, usage. */
     box;
     storage;
@@ -88,6 +99,7 @@ export class SwarmClient {
         this.realtime = new SwarmRealtimeNamespace(this.transport);
         this.automations = new SwarmAutomationsNamespace(this.transport);
         this.workers = new SwarmWorkersNamespace(this.transport);
+        this.limits = new SwarmLimitsNamespace(this.transport);
         this.usage = new SwarmUsageNamespace(this.transport);
         this.deliverables = new SwarmDeliverablesNamespace(this.transport);
         this.mailbox = this.deliverables;
@@ -102,6 +114,8 @@ export class SwarmClient {
         this.notifications = new SwarmNotificationsNamespace(this.transport);
         this.inbox = this.notifications;
         this.signals = new SwarmSignalsNamespace(this.transport);
+        this.workflows = new SwarmJobAutomationsNamespace(this.transport);
+        this.activity = new SwarmActivityNamespace(this.transport);
         this.box = new SwarmBoxNamespace(this.transport);
         this.agents = new SwarmAgentsNamespace(this.transport);
         this.storage = new SwarmStorageNamespace(this.transport);

package/dist/index.d.ts

@@ -8,6 +8,8 @@ export * from './deliverables.js';
 export * from './deploy/index.js';
 export * from './notifications.js';
 export * from './signals.js';
+export * from './job-automations.js';
+export * from './activity.js';
 export * from './box.js';
 export * from './sessions.js';
 export * from './projects.js';
@@ -32,3 +34,5 @@ export * from './realtime.js';
 export * from './websocket.js';
 export * from './browser.js';
 export type { ApplicationResults, ApplicationResultsOptions } from './app-results.js';
+export { SwarmLimitsNamespace } from './limits.js';
+export type { BoxLimits } from './limits.js';

package/dist/index.js

@@ -8,6 +8,8 @@ export * from './deliverables.js';
 export * from './deploy/index.js';
 export * from './notifications.js';
 export * from './signals.js';
+export * from './job-automations.js';
+export * from './activity.js';
 export * from './box.js';
 export * from './sessions.js';
 export * from './projects.js';
@@ -29,3 +31,4 @@ export * from './provider-auth.js';
 export * from './realtime.js';
 export * from './websocket.js';
 export * from './browser.js';
+export { SwarmLimitsNamespace } from './limits.js';

package/dist/job-automations.d.ts

@@ -0,0 +1,343 @@
+import type { SwarmTransport } from './transport.js';
+/**
+ * Job automations: the steps Swarm runs when a job ends. Swarm gives
+ * primitives, never a built-in path: with no automation a job ends with its
+ * branch and the person integrates it by hand. Reading needs
+ * `automations:read`; changing needs `automations:write`.
+ * See docs/automations.md.
+ */
+export type JobAutomationWhen = 'succeeded' | 'failed' | 'always';
+export type JobAutomationStepType = 'run' | 'agent' | 'reopen' | 'deliver';
+/**
+ * Where a deliver step hands deliverables over. `folder`: copied into `path`,
+ * a directory inside the folder (a different existing file is never
+ * overwritten). `merge`: the work's branch merged into the folder's branch.
+ * `publish`: a pull request through the folder's publish rule. `outbox`: the
+ * machine's bucket, with a manifest at
+ * `machines/<machine>/deliveries/<delivery>/<step>.json`.
+ */
+export type JobDeliverTarget = 'folder' | 'merge' | 'publish' | 'outbox';
+/** What a deliverable is. */
+export type JobDeliverableKind = 'branch' | 'file' | 'media' | 'report';
+/**
+ * What a workflow's work must hand over: a file (`path`, relative to the
+ * folder) or media file, the report, or the branch. When the work did not
+ * produce it, an agent step with `produce: true` writes it.
+ */
+export interface JobResultSpec {
+    kind: JobDeliverableKind;
+    path?: string;
+    /** What it must be or contain, for the producing agent and the reviewer. */
+    describe?: string;
+}
+/** One thing a job (or a produce step) made that a deliver step can hand over. */
+export interface JobDeliverable {
+    name: string;
+    kind: JobDeliverableKind;
+    path?: string;
+    branch?: string;
+    head?: string;
+    sha256?: string;
+    size?: number;
+    type?: string;
+    /** Where its content is read from: git (at head), folder, media or report. */
+    source?: 'git' | 'folder' | 'media' | 'report';
+    /** "job" for the work's own output, or the id of the step that produced it. */
+    from?: string;
+}
+export type JobDeliveryState = 'pending' | 'running' | 'succeeded' | 'failed' | 'skipped' | 'stopped' | 'blocked';
+export type JobReviewVerdict = 'ok' | 'block';
+/**
+ * An agent step's `fixes` option (reviewer workers only; the only value).
+ * The daemon refuses it for any other worker.
+ */
+export type JobReviewerFixes = 'security';
+/**
+ * Where an agent step's agent works. `same`: a new session in the worktree of
+ * the job the step follows, read-only (a reviewer only). `new`: its own
+ * worktree at the job's head. `none`: the folder itself.
+ */
+export type JobAgentCheckout = 'same' | 'new' | 'none';
+/** The most lines (added plus removed) a reviewer's fix commits may change. */
+export declare const JOB_REVIEWER_FIX_MAX_LINES = 80;
+/**
+ * One condition of a step's `if`, on an earlier step: its status, or (an
+ * agent step) the verdict of the review its job recorded. A missing verdict
+ * never matches.
+ */
+export type JobAutomationCondition = {
+    step: string;
+    status: 'succeeded' | 'failed';
+    verdict?: never;
+} | {
+    step: string;
+    verdict: JobReviewVerdict;
+    status?: never;
+};
+/** Which task and job ends a workflow applies to. */
+export interface JobAutomationScope {
+    /** Absolute path of the project folder. */
+    folder: string;
+    /** Only the tasks this one of Swarm's own agents finished in the folder. */
+    role?: 'swarm' | 'coder' | 'finder' | 'designer';
+    /** Only this worker's jobs (worker id). */
+    worker?: string;
+    /** Only this task or job (`task/<project>/<task>`, `worker/<worker>/<run>`, ...). */
+    job?: string;
+    /** Only the jobs of this schedule (schedule id). */
+    schedule?: string;
+}
+export interface JobAutomationStep {
+    /** Lowercase id; default `step-N`. */
+    id?: string;
+    type: JobAutomationStepType;
+    /** 1 to 3600; default 600. */
+    timeout_seconds?: number;
+    /** Default false: a failed step stops the rest. */
+    continue_on_failure?: boolean;
+    /** Conditions that must all hold for the step to run; otherwise it is skipped and later steps still run. */
+    if?: JobAutomationCondition[];
+    /**
+     * run: the machine owner's script, as an absolute path or a path relative
+     * to the folder (e.g. `deliver/push.sh`). It runs on the host as the
+     * daemon's user, in the folder, with the machine's own credentials, and
+     * only if the file (symlinks resolved) is owned by root and not writable by
+     * group or others. A relative path must resolve to a singly linked file
+     * inside the folder; prefer an absolute path in a directory only root can
+     * write. A run step has no `secrets`: a step that sends them is refused.
+     * Only the machine's owner may save a run step: the local owner or a key
+     * with the `admin` scope; any other key gets 403 and nothing is stored.
+     */
+    command?: string;
+    args?: string[];
+    /**
+     * agent: one of Swarm's own agents (`swarm`, `coder`, `finder`, `designer`),
+     * run as a task in the folder (a coder starts at the work's head); `reviewer`;
+     * or a worker id.
+     */
+    worker?: string;
+    /** agent: the job's brief; the triggering job's result is attached (a reviewer also gets its brief, report, commands run and diff). */
+    brief?: string;
+    /**
+     * agent, reviewer worker only: `security` lets the reviewer commit small,
+     * security-only fixes on a branch at the reviewed head instead of blocking
+     * for them. Its commits move the delivery head only with an OK verdict and
+     * at most {@link JOB_REVIEWER_FIX_MAX_LINES} changed lines; more fails the
+     * step (`reviewer fixes too large`); an OK whose fixes cannot be read from
+     * the reviewer's checkout fails it (`reviewer fixes unreadable`). Without
+     * it a reviewer is read-only.
+     */
+    fixes?: JobReviewerFixes;
+    /**
+     * agent: where the agent works; omit it for the agent's default. A reviewer
+     * reads the reviewed job's own worktree in place (`same`, read-only; it
+     * starts only at exactly the reviewed head with nothing uncommitted, and its
+     * verdict is a block if the worktree changes during the review) or gets its
+     * own checkout (`new`). A reviewer with `fixes`, the coder and any other
+     * worker use `new`; swarm, finder and designer work in the folder (`none`).
+     * The daemon refuses any other combination.
+     */
+    checkout?: JobAgentCheckout;
+    /**
+     * reopen: the earlier agent step whose findings are sent into the triggering
+     * job's own session. Optional when `message` is set.
+     */
+    from?: string;
+    /**
+     * reopen: text placed before the findings, or sent alone when `from`
+     * recorded none (an OK review) or is omitted. `{{steps.<id>.output}}` is
+     * replaced by that earlier step's recorded output line. A reopen needs
+     * `from`, `message` or both; with no findings and no message it fails.
+     */
+    message?: string;
+    /** reopen: reopens allowed before the delivery ends `blocked` (`rounds_exhausted`); 1 to 5, default 2. */
+    max_rounds?: number;
+    /**
+     * agent: the agent writes the workflow's `result` file; Swarm checks it
+     * exists, records its sha256 and hands it over. Not for finder or reviewer.
+     * A reviewer started after it reviews the produced work.
+     */
+    produce?: boolean;
+    /** deliver: where. */
+    to?: JobDeliverTarget;
+    /** deliver to a folder: the directory inside the folder. */
+    path?: string;
+    /** deliver: deliverables by name; default the workflow's result, else what fits the target. */
+    what?: string[];
+}
+export interface JobAutomation {
+    id: string;
+    name: string;
+    scope: JobAutomationScope;
+    when: JobAutomationWhen;
+    enabled: boolean;
+    /** Automatic retries of a failed step, 0 to 3. */
+    retries: number;
+    /** Ordered steps, with their defaults applied (id, timeout_seconds). */
+    steps: JobAutomationStep[];
+    /** What the work must hand over, when the workflow names it. */
+    result?: JobResultSpec;
+    /** Rises on every update; a delivery keeps the revision it started with. */
+    revision: number;
+    created_at: number;
+    updated_at: number;
+    latest_deliveries?: JobDelivery[];
+}
+export interface SetJobAutomationParams {
+    name: string;
+    scope: JobAutomationScope;
+    when?: JobAutomationWhen;
+    enabled?: boolean;
+    retries?: number;
+    steps: JobAutomationStep[];
+    result?: JobResultSpec;
+}
+export interface JobDeliveryStep {
+    id: string;
+    type: JobAutomationStepType;
+    state: JobDeliveryState;
+    attempts: number;
+    started_at?: number;
+    finished_at?: number;
+    next_attempt_at?: number;
+    exit_code?: number;
+    /** The last non-empty line the step printed (a run step), or the job id (an agent step). */
+    output?: string;
+    reason?: string;
+    /** The next allowed action after a failure, e.g. `rerun` or `fix the script`. */
+    next?: string;
+    /**
+     * An agent step's job: `job_id`, `status`, `head`, `report`, `review`, and
+     * `verdict`/`findings` when the job recorded a review (`moved_head` when it
+     * moved the delivery head); with `fixes`, the reviewer's `fix_commits`,
+     * `fix_lines`, `fixes_applied` and `fixes_reason`; a reopen step's
+     * `followup` and `round`.
+     */
+    outcome?: Record<string, unknown>;
+    /** The last 64 KiB of a run step's output (single-delivery reads only). */
+    log_tail?: string;
+}
+/** One (job end, automation revision) pair; runs at most once. */
+export interface JobDelivery {
+    delivery_id: string;
+    automation_id: string;
+    automation: string;
+    automation_revision: number;
+    job_id: string;
+    /** The follow-up this job end belongs to; absent for the job's first run. */
+    followup?: string;
+    /** Reopens that led to this job end: a follow-up a reopen step sent is the previous round + 1. */
+    round: number;
+    state: JobDeliveryState;
+    /** The commit the delivery delivers: the job's head, moved forward by an agent step that committed on top of it. */
+    head?: string;
+    /** Why the delivery ended `blocked`, e.g. `rounds_exhausted`. */
+    blocked_reason?: string;
+    /** The reviewer fix commits the delivery head was moved to (agent steps with `fixes`). */
+    fix_commits?: Array<{
+        sha: string;
+        subject: string;
+    }>;
+    steps: JobDeliveryStep[];
+    created_at: number;
+    started_at?: number;
+    finished_at?: number;
+    reruns?: number;
+    /** The job's result, on single-delivery reads. */
+    result?: JobResult;
+}
+/** The result record a job end produces; a run step gets it on stdin. */
+export interface JobResult {
+    v: number;
+    job_id: string;
+    kind: 'task' | 'worker' | 'media' | 'design';
+    role?: string;
+    worker?: {
+        id: string;
+        name?: string;
+    };
+    run_id: string;
+    followup?: string;
+    project_id?: string;
+    folder?: string;
+    status: 'succeeded' | 'failed' | 'cancelled';
+    job_status?: string;
+    finished_at: number;
+    brief?: string;
+    report?: string;
+    error?: string;
+    request_source?: string;
+    schedule_id?: string;
+    git?: {
+        branch: string;
+        base_branch?: string;
+        base_commit: string;
+        head: string;
+        commits: Array<{
+            sha: string;
+            subject: string;
+        }>;
+        files: string[];
+        worktree?: string;
+    };
+    files?: Array<{
+        path: string;
+        sha256: string;
+        type: string;
+        size?: number;
+    }>;
+    cost?: {
+        tokens: number;
+        estimated_usd?: number;
+        model?: string;
+    };
+    review?: Record<string, unknown>;
+    /** Everything the job made that a deliver step can hand over. */
+    deliverables?: JobDeliverable[];
+}
+export interface JobAutomationStop {
+    stopped: boolean;
+    at?: number;
+    by?: string;
+}
+export interface ListJobDeliveriesParams {
+    jobId?: string;
+    automationId?: string;
+    state?: JobDeliveryState;
+    /** Default 50, at most 200. */
+    limit?: number;
+}
+/** Workflows and their deliveries (`/v3/workflows`, `/v3/job-deliveries`). */
+export declare class SwarmJobAutomationsNamespace {
+    private readonly transport;
+    constructor(transport: SwarmTransport);
+    /** This account's automations, each with its latest deliveries. */
+    list(): Promise<{
+        automations: JobAutomation[];
+        stopped: boolean;
+    }>;
+    get(id: string): Promise<JobAutomation>;
+    /** Creates the automation, or updates the one with this name (its revision rises). */
+    set(params: SetJobAutomationParams): Promise<{
+        automation: JobAutomation;
+        created: boolean;
+    }>;
+    delete(id: string): Promise<void>;
+    /** The machine-wide stop switch. */
+    stopState(): Promise<JobAutomationStop>;
+    /** While stopped, no new step starts on the machine; running steps finish. */
+    setStopped(stopped: boolean): Promise<JobAutomationStop>;
+    /** Deliveries, newest first. */
+    deliveries(params?: ListJobDeliveriesParams): Promise<JobDelivery[]>;
+    /** One delivery with its steps' log tails and the job's result. */
+    delivery(id: string): Promise<JobDelivery>;
+    /**
+     * Re-runs only the delivery's failed or stopped steps (a blocked delivery
+     * runs again from its first step with a new round budget); `rerun` is false
+     * when there were none.
+     */
+    rerun(id: string): Promise<{
+        rerun: boolean;
+        delivery: JobDelivery;
+    }>;
+}

package/dist/job-automations.js

@@ -0,0 +1,74 @@
+/** The most lines (added plus removed) a reviewer's fix commits may change. */
+export const JOB_REVIEWER_FIX_MAX_LINES = 80;
+/** Workflows and their deliveries (`/v3/workflows`, `/v3/job-deliveries`). */
+export class SwarmJobAutomationsNamespace {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** This account's automations, each with its latest deliveries. */
+    async list() {
+        const res = await this.transport.request('/v3/workflows', { method: 'GET' });
+        return { automations: res.data.automations ?? [], stopped: Boolean(res.data.stopped) };
+    }
+    async get(id) {
+        const res = await this.transport.request(`/v3/workflows/${encodeURIComponent(id)}`, { method: 'GET' });
+        return res.data.automation;
+    }
+    /** Creates the automation, or updates the one with this name (its revision rises). */
+    async set(params) {
+        const res = await this.transport.request('/v3/workflows', {
+            method: 'POST',
+            body: params,
+        });
+        return { automation: res.data.automation, created: Boolean(res.data.created) };
+    }
+    async delete(id) {
+        await this.transport.request(`/v3/workflows/${encodeURIComponent(id)}`, { method: 'DELETE' });
+    }
+    /** The machine-wide stop switch. */
+    async stopState() {
+        const res = await this.transport.request('/v3/workflows/stop', { method: 'GET' });
+        return res.data.stop;
+    }
+    /** While stopped, no new step starts on the machine; running steps finish. */
+    async setStopped(stopped) {
+        const res = await this.transport.request('/v3/workflows/stop', {
+            method: 'POST',
+            body: { stopped },
+        });
+        return res.data.stop;
+    }
+    /** Deliveries, newest first. */
+    async deliveries(params = {}) {
+        const q = new URLSearchParams();
+        if (params.jobId)
+            q.set('job_id', params.jobId);
+        if (params.automationId)
+            q.set('automation_id', params.automationId);
+        if (params.state)
+            q.set('state', params.state);
+        if (typeof params.limit === 'number')
+            q.set('limit', String(params.limit));
+        const path = q.toString() ? `/v3/job-deliveries?${q.toString()}` : '/v3/job-deliveries';
+        const res = await this.transport.request(path, { method: 'GET' });
+        return res.data.deliveries ?? [];
+    }
+    /** One delivery with its steps' log tails and the job's result. */
+    async delivery(id) {
+        const res = await this.transport.request(`/v3/job-deliveries/${encodeURIComponent(id)}`, { method: 'GET' });
+        return res.data.delivery;
+    }
+    /**
+     * Re-runs only the delivery's failed or stopped steps (a blocked delivery
+     * runs again from its first step with a new round budget); `rerun` is false
+     * when there were none.
+     */
+    async rerun(id) {
+        const res = await this.transport.request(`/v3/job-deliveries/${encodeURIComponent(id)}/rerun`, {
+            method: 'POST',
+            body: {},
+        });
+        return { rerun: Boolean(res.data.rerun), delivery: res.data.delivery };
+    }
+}

package/dist/limits.d.ts

@@ -0,0 +1,16 @@
+import type { SwarmTransport } from './transport.js';
+export interface BoxLimits {
+    revision: number;
+    worker_job_concurrency: number;
+    job_tokens: number;
+    job_cost_usd: number;
+    delegation_waves: number;
+    active_children: number;
+    swarm_children: number;
+}
+export declare class SwarmLimitsNamespace {
+    private readonly transport;
+    constructor(transport: SwarmTransport);
+    get(): Promise<BoxLimits>;
+    set(expected_revision: number, limits: Omit<BoxLimits, 'revision'>): Promise<BoxLimits>;
+}

package/dist/limits.js

@@ -0,0 +1,12 @@
+export class SwarmLimitsNamespace {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async get() {
+        return (await this.transport.request('/v3/limits', { method: 'GET' })).data;
+    }
+    async set(expected_revision, limits) {
+        return (await this.transport.request('/v3/limits', { method: 'PUT', body: { expected_revision, limits } })).data;
+    }
+}