@onesi/genesis 0.2.7 → 0.2.8

package/README.md

@@ -3,7 +3,7 @@
 The TypeScript SDK for OneOS. One typed client for every Genesis service, through the Genesis API at `https://os.one.ml/api`.
 
 ```sh
-npm install @onesi/genesis@0.2.7
+npm install @onesi/genesis@0.2.8
 ```
 
 ```ts

package/dist/client.js

@@ -266,7 +266,7 @@ export class GenesisClient {
         const url = this.url(operationId, input);
         const headers = {
             accept: 'application/json',
-            'user-agent': this.opts.userAgent ?? '@onesi/genesis/0.2.7',
+            'user-agent': this.opts.userAgent ?? '@onesi/genesis/0.2.8',
             ...this.opts.headers, ...init.headers,
         };
         if (op.service === 'blinds' && !['GET', 'HEAD', 'OPTIONS'].includes(op.method))

package/dist/context.d.ts

@@ -6,7 +6,7 @@ export type GenesisContextSelection = {
     platformId: 'pf_console';
     workspaceId: string;
     fleetId: null;
-    environmentId: 'sandbox';
+    environmentId: 'sandbox' | 'live';
 };
 export interface GenesisContextSession {
     principal: {

package/dist/context.js

@@ -78,7 +78,7 @@ export async function selectGenesisContext(selection, options) {
     const requested = { ...selection };
     const keys = Object.keys(requested), full = 'projectId' in requested;
     if (!id(requested.organizationId, 'o') || keys.some(k => !(full ? ['organizationId', 'projectId', 'platformId', 'workspaceId', 'fleetId', 'environmentId'] : ['organizationId']).includes(k))
-        || (full && (!id(requested.projectId, 'pr') || !id(requested.workspaceId, 'w') || requested.platformId !== 'pf_console' || requested.fleetId !== null || requested.environmentId !== 'sandbox')))
+        || (full && (!id(requested.projectId, 'pr') || !id(requested.workspaceId, 'w') || requested.platformId !== 'pf_console' || requested.fleetId !== null || (requested.environmentId !== 'sandbox' && requested.environmentId !== 'live'))))
         return fail(400);
     const controller = new AbortController(), cancel = () => controller.abort();
     options.signal?.addEventListener('abort', cancel, { once: true });

package/dist/fleets.d.ts

@@ -10,6 +10,11 @@ export interface FleetsInstanceOptions {
     idempotencyKey?: string;
     signal?: AbortSignal;
 }
+type SeatHireInput = NonNullable<OperationInput<'fleets_hireSeat'>['body']>;
+type SeatUpdateInput = NonNullable<OperationInput<'fleets_updateSeat'>['body']>;
+type SeatTaskInput = NonNullable<OperationInput<'fleets_submitSeatTask'>['body']>;
+type PoolCreateInput = NonNullable<OperationInput<'fleets_createPool'>['body']>;
+type PoolTopUpInput = NonNullable<OperationInput<'fleets_topUpPool'>['body']>;
 /** Managed Henry instances and tasks scoped to the credential's verified org. */
 export declare function fleetsModule(client: GenesisClient): {
     agents: {
@@ -155,6 +160,309 @@ export declare function fleetsModule(client: GenesisClient): {
             updated_at?: number;
         }>;
     };
+    /** Agent seats: a persistent Henry agent with a credit purse and a computer entitlement. Plan prices are display data. */
+    seats: {
+        plans: () => Promise<{
+            plans: import("./index.js").components["schemas"]["Fleets.SeatPlan"][];
+            credit?: {
+                unit?: string;
+                value_usd?: number;
+                meaning?: string;
+            };
+        }>;
+        list: () => Promise<{
+            seats: import("./index.js").components["schemas"]["Fleets.Seat"][];
+        }>;
+        /** Hire a seat. idempotency_key is required; reuse it on retry. fund: false opens an empty purse for top-up. */
+        hire: (body: SeatHireInput) => Promise<{
+            id: string;
+            object: "fleets.seat";
+            type: import("./index.js").components["schemas"]["Fleets.SeatType"];
+            name?: string;
+            state: "active" | "paused" | "held" | "killed" | "releasing" | "released";
+            pause_reason?: string;
+            agent_id?: string | null;
+            pool_id?: string | null;
+            purse: import("./index.js").components["schemas"]["Fleets.Purse"];
+            computer: import("./index.js").components["schemas"]["Fleets.Computer"];
+            release?: import("./index.js").components["schemas"]["Fleets.SeatRelease"];
+            created_at?: string;
+            updated_at?: string;
+        }>;
+        get: (seat_id: string) => Promise<{
+            id: string;
+            object: "fleets.seat";
+            type: import("./index.js").components["schemas"]["Fleets.SeatType"];
+            name?: string;
+            state: "active" | "paused" | "held" | "killed" | "releasing" | "released";
+            pause_reason?: string;
+            agent_id?: string | null;
+            pool_id?: string | null;
+            purse: import("./index.js").components["schemas"]["Fleets.Purse"];
+            computer: import("./index.js").components["schemas"]["Fleets.Computer"];
+            release?: import("./index.js").components["schemas"]["Fleets.SeatRelease"];
+            created_at?: string;
+            updated_at?: string;
+        }>;
+        update: (seat_id: string, body: SeatUpdateInput) => Promise<{
+            id: string;
+            object: "fleets.seat";
+            type: import("./index.js").components["schemas"]["Fleets.SeatType"];
+            name?: string;
+            state: "active" | "paused" | "held" | "killed" | "releasing" | "released";
+            pause_reason?: string;
+            agent_id?: string | null;
+            pool_id?: string | null;
+            purse: import("./index.js").components["schemas"]["Fleets.Purse"];
+            computer: import("./index.js").components["schemas"]["Fleets.Computer"];
+            release?: import("./index.js").components["schemas"]["Fleets.SeatRelease"];
+            created_at?: string;
+            updated_at?: string;
+        }>;
+        /** Add credits; overdraft is repaid first. Computer minutes come from the plan (upgrade, or use a pool). A pooled seat answers 409 pooled_seat: top up the pool. */
+        topUp: (seat_id: string, credits: number, idempotency_key: string) => Promise<{
+            id: string;
+            object: "fleets.seat";
+            type: import("./index.js").components["schemas"]["Fleets.SeatType"];
+            name?: string;
+            state: "active" | "paused" | "held" | "killed" | "releasing" | "released";
+            pause_reason?: string;
+            agent_id?: string | null;
+            pool_id?: string | null;
+            purse: import("./index.js").components["schemas"]["Fleets.Purse"];
+            computer: import("./index.js").components["schemas"]["Fleets.Computer"];
+            release?: import("./index.js").components["schemas"]["Fleets.SeatRelease"];
+            created_at?: string;
+            updated_at?: string;
+        }>;
+        /** Move to a larger plan; there is no downgrade. */
+        upgrade: (seat_id: string, type: "helper" | "operator" | "always_on") => Promise<{
+            id: string;
+            object: "fleets.seat";
+            type: import("./index.js").components["schemas"]["Fleets.SeatType"];
+            name?: string;
+            state: "active" | "paused" | "held" | "killed" | "releasing" | "released";
+            pause_reason?: string;
+            agent_id?: string | null;
+            pool_id?: string | null;
+            purse: import("./index.js").components["schemas"]["Fleets.Purse"];
+            computer: import("./index.js").components["schemas"]["Fleets.Computer"];
+            release?: import("./index.js").components["schemas"]["Fleets.SeatRelease"];
+            created_at?: string;
+            updated_at?: string;
+        }>;
+        hold: (seat_id: string) => Promise<{
+            id: string;
+            object: "fleets.seat";
+            type: import("./index.js").components["schemas"]["Fleets.SeatType"];
+            name?: string;
+            state: "active" | "paused" | "held" | "killed" | "releasing" | "released";
+            pause_reason?: string;
+            agent_id?: string | null;
+            pool_id?: string | null;
+            purse: import("./index.js").components["schemas"]["Fleets.Purse"];
+            computer: import("./index.js").components["schemas"]["Fleets.Computer"];
+            release?: import("./index.js").components["schemas"]["Fleets.SeatRelease"];
+            created_at?: string;
+            updated_at?: string;
+        } & {
+            cancelled_tasks: string[];
+            agent_state?: string;
+        }>;
+        resume: (seat_id: string) => Promise<{
+            id: string;
+            object: "fleets.seat";
+            type: import("./index.js").components["schemas"]["Fleets.SeatType"];
+            name?: string;
+            state: "active" | "paused" | "held" | "killed" | "releasing" | "released";
+            pause_reason?: string;
+            agent_id?: string | null;
+            pool_id?: string | null;
+            purse: import("./index.js").components["schemas"]["Fleets.Purse"];
+            computer: import("./index.js").components["schemas"]["Fleets.Computer"];
+            release?: import("./index.js").components["schemas"]["Fleets.SeatRelease"];
+            created_at?: string;
+            updated_at?: string;
+        }>;
+        kill: (seat_id: string) => Promise<{
+            id: string;
+            object: "fleets.seat";
+            type: import("./index.js").components["schemas"]["Fleets.SeatType"];
+            name?: string;
+            state: "active" | "paused" | "held" | "killed" | "releasing" | "released";
+            pause_reason?: string;
+            agent_id?: string | null;
+            pool_id?: string | null;
+            purse: import("./index.js").components["schemas"]["Fleets.Purse"];
+            computer: import("./index.js").components["schemas"]["Fleets.Computer"];
+            release?: import("./index.js").components["schemas"]["Fleets.SeatRelease"];
+            created_at?: string;
+            updated_at?: string;
+        } & {
+            cancelled_tasks: string[];
+            agent_state?: string;
+        }>;
+        /** Settle the purse and delete the agent (terminal); answers returned_credits, returned_computer_minutes, unpaid_overdraft_credits, spent_credits. */
+        release: (seat_id: string) => Promise<{
+            id: string;
+            object: "fleets.seat.release";
+            seat_id?: string;
+            state: "released";
+            returned_credits: number;
+            returned_computer_minutes: number;
+            unpaid_overdraft_credits?: number;
+            spent_credits?: number;
+            pool_id?: string | null;
+            agent_deleted?: boolean;
+            released_at?: string;
+        }>;
+        ledger: (seat_id: string) => Promise<{
+            id?: string;
+            entries: import("./index.js").components["schemas"]["Fleets.SeatLedgerEntry"][];
+        }>;
+        tasks: {
+            list: (seat_id: string) => Promise<{
+                tasks: import("./index.js").components["schemas"]["Fleets.SeatTask"][];
+            }>;
+            /** 402 purse_empty when parked, 403 computer_not_entitled for a helper's computer task, 409 when held, killed or released. */
+            submit: (seat_id: string, body: SeatTaskInput) => Promise<{
+                task_id: string;
+                object?: "fleets.seat.task";
+                seat_id: string;
+                kind: "research" | "computer";
+                state: "pending" | "running" | "awaiting_approval" | "completed" | "failed" | "cancelled" | "timed_out";
+                output?: string | null;
+                error?: string | null;
+                approvals?: import("./index.js").components["schemas"]["Fleets.SeatApproval"][];
+                credits?: {
+                    reserved?: number;
+                    charged?: number | null;
+                    borrowed?: number;
+                };
+                computer_minutes?: number;
+                computer_minutes_allowed?: number;
+                settled?: boolean;
+                receipt_url?: string;
+                submitted_at?: string;
+                completed_at?: string | null;
+            }>;
+            get: (seat_id: string, task_id: string) => Promise<{
+                task_id: string;
+                object?: "fleets.seat.task";
+                seat_id: string;
+                kind: "research" | "computer";
+                state: "pending" | "running" | "awaiting_approval" | "completed" | "failed" | "cancelled" | "timed_out";
+                output?: string | null;
+                error?: string | null;
+                approvals?: import("./index.js").components["schemas"]["Fleets.SeatApproval"][];
+                credits?: {
+                    reserved?: number;
+                    charged?: number | null;
+                    borrowed?: number;
+                };
+                computer_minutes?: number;
+                computer_minutes_allowed?: number;
+                settled?: boolean;
+                receipt_url?: string;
+                submitted_at?: string;
+                completed_at?: string | null;
+            }>;
+            decide: (seat_id: string, task_id: string, approval_id: string, decision: "approve" | "deny") => Promise<{
+                task_id: string;
+                object?: "fleets.seat.task";
+                seat_id: string;
+                kind: "research" | "computer";
+                state: "pending" | "running" | "awaiting_approval" | "completed" | "failed" | "cancelled" | "timed_out";
+                output?: string | null;
+                error?: string | null;
+                approvals?: import("./index.js").components["schemas"]["Fleets.SeatApproval"][];
+                credits?: {
+                    reserved?: number;
+                    charged?: number | null;
+                    borrowed?: number;
+                };
+                computer_minutes?: number;
+                computer_minutes_allowed?: number;
+                settled?: boolean;
+                receipt_url?: string;
+                submitted_at?: string;
+                completed_at?: string | null;
+            }>;
+        };
+    };
+    /** Seat pools: a shared purse and computer minutes that seats hired with pool_id draw on. */
+    pools: {
+        list: () => Promise<{
+            pools: import("./index.js").components["schemas"]["Fleets.Pool"][];
+        }>;
+        create: (body: PoolCreateInput) => Promise<{
+            id: string;
+            object: "fleets.pool";
+            name?: string;
+            state?: string;
+            purse: import("./index.js").components["schemas"]["Fleets.Purse"];
+            computer: import("./index.js").components["schemas"]["Fleets.Computer"];
+            seats?: string[];
+            release?: import("./index.js").components["schemas"]["Fleets.PoolRelease"];
+            created_at?: string;
+            updated_at?: string;
+        }>;
+        get: (pool_id: string) => Promise<{
+            id: string;
+            object: "fleets.pool";
+            name?: string;
+            state?: string;
+            purse: import("./index.js").components["schemas"]["Fleets.Purse"];
+            computer: import("./index.js").components["schemas"]["Fleets.Computer"];
+            seats?: string[];
+            release?: import("./index.js").components["schemas"]["Fleets.PoolRelease"];
+            created_at?: string;
+            updated_at?: string;
+        }>;
+        topUp: (pool_id: string, body: PoolTopUpInput) => Promise<{
+            id: string;
+            object: "fleets.pool";
+            name?: string;
+            state?: string;
+            purse: import("./index.js").components["schemas"]["Fleets.Purse"];
+            computer: import("./index.js").components["schemas"]["Fleets.Computer"];
+            seats?: string[];
+            release?: import("./index.js").components["schemas"]["Fleets.PoolRelease"];
+            created_at?: string;
+            updated_at?: string;
+        }>;
+        ledger: (pool_id: string) => Promise<{
+            id?: string;
+            entries: import("./index.js").components["schemas"]["Fleets.SeatLedgerEntry"][];
+        }>;
+        /** Settle the pool (terminal); answers returned_credits and returned_computer_minutes. 409 pool_has_seats while seats remain. */
+        release: (pool_id: string) => Promise<{
+            id: string;
+            object: "fleets.pool.release";
+            pool_id?: string;
+            state: "released";
+            returned_credits: number;
+            returned_computer_minutes: number;
+            unpaid_overdraft_credits?: number;
+            spent_credits?: number;
+            released_at?: string;
+        }>;
+    };
+    /** The organization key seat computer tasks use for Panes and Shells; KMS-encrypted, never returned. */
+    computerConnection: {
+        get: () => Promise<{
+            connected: boolean;
+            updated_at?: number;
+        }>;
+        set: (api_key: string) => Promise<{
+            connected: boolean;
+            updated_at?: number;
+        }>;
+        delete: () => Promise<{
+            connected: boolean;
+            updated_at?: number;
+        }>;
+    };
     usage: {
         /** Task lifecycle and execution-time usage events, paged by task like tasks.list. */
         events: (query?: OperationInput<"fleets_listUsageEvents">) => Promise<{

package/dist/fleets.js

@@ -94,6 +94,92 @@ const cursor = (value, operation, max) => {
         throw invalid(operation, 'after must be a non-negative integer cursor (next_after).');
     }
 };
+const SEAT_TYPES = ['helper', 'operator', 'always_on'];
+const MAX_CREDITS = 100_000_000;
+/** Seat, pool, task and approval IDs: one path segment of Fleets' own ID characters. */
+const seatPathId = (value, operation, what) => {
+    if (typeof value !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/.test(value))
+        throw invalid(operation, `Invalid ${what} ID.`);
+};
+const bodyKey = (value, operation) => {
+    if (typeof value !== 'string' || !/^[!-~]{1,128}$/.test(value))
+        throw invalid(operation, 'idempotency_key is required: 1–128 visible ASCII characters, reused on retry.');
+};
+const whole = (value, operation, field, min) => {
+    if (!Number.isSafeInteger(value) || value < min || value > MAX_CREDITS) {
+        throw invalid(operation, `${field} must be a whole number of at least ${min}.`);
+    }
+};
+const seatName = (value, operation) => {
+    if (typeof value !== 'string' || !value.trim() || byteLength(value) > 128)
+        throw invalid(operation, 'Seat name must contain 1–128 UTF-8 bytes.');
+};
+const seatType = (value, operation) => {
+    if (typeof value !== 'string' || !SEAT_TYPES.includes(value))
+        throw invalid(operation, 'Seat type must be helper, operator or always_on.');
+};
+const plainBody = (body, operation, allowed) => {
+    if (!body || typeof body !== 'object' || Array.isArray(body))
+        throw invalid(operation, 'Provide a JSON object body.');
+    const extra = Object.keys(body).find(key => !allowed.includes(key));
+    if (extra)
+        throw invalid(operation, `Unknown field ${extra}.`);
+};
+function validateSeatHire(body) {
+    const op = 'fleets_hireSeat';
+    plainBody(body, op, ['type', 'name', 'borrow_ceiling_credits', 'pool_id', 'fund', 'idempotency_key']);
+    seatType(body.type, op);
+    if (body.name !== undefined)
+        seatName(body.name, op);
+    if (body.borrow_ceiling_credits !== undefined)
+        whole(body.borrow_ceiling_credits, op, 'borrow_ceiling_credits', 0);
+    if (body.pool_id !== undefined)
+        seatPathId(body.pool_id, op, 'pool');
+    if (body.fund !== undefined && typeof body.fund !== 'boolean')
+        throw invalid(op, 'fund must be true or false.');
+    bodyKey(body.idempotency_key, op);
+}
+function validateSeatUpdate(body) {
+    const op = 'fleets_updateSeat';
+    plainBody(body, op, ['name', 'borrow_ceiling_credits']);
+    if (!Object.keys(body).length)
+        throw invalid(op, 'Provide name or borrow_ceiling_credits.');
+    if (body.name !== undefined)
+        seatName(body.name, op);
+    if (body.borrow_ceiling_credits !== undefined)
+        whole(body.borrow_ceiling_credits, op, 'borrow_ceiling_credits', 0);
+}
+function validateSeatTask(body) {
+    const op = 'fleets_submitSeatTask';
+    plainBody(body, op, ['input', 'kind', 'timeout_seconds', 'approve_computer', 'idempotency_key']);
+    if (typeof body.input !== 'string' || !body.input || byteLength(body.input) > 65536 || body.input.includes('\0')) {
+        throw invalid(op, 'Task input must contain 1–65536 UTF-8 bytes without NUL.');
+    }
+    if (body.kind !== undefined && body.kind !== 'research' && body.kind !== 'computer')
+        throw invalid(op, 'Task kind must be research or computer (default research).');
+    if (body.timeout_seconds !== undefined && (!Number.isInteger(body.timeout_seconds) || body.timeout_seconds < 1 || body.timeout_seconds > 3600)) {
+        throw invalid(op, 'Timeout must be 1–3600 seconds.');
+    }
+    if (body.approve_computer !== undefined && typeof body.approve_computer !== 'boolean')
+        throw invalid(op, 'approve_computer must be true or false.');
+    bodyKey(body.idempotency_key, op);
+}
+function validatePool(body, op) {
+    plainBody(body, op, op === 'fleets_createPool' ? ['name', 'credits', 'computer_minutes', 'idempotency_key'] : ['credits', 'computer_minutes', 'idempotency_key']);
+    if (op === 'fleets_topUpPool' && body.credits === 0 && !body.computer_minutes)
+        throw invalid(op, 'Add credits or computer_minutes.');
+    if (op === 'fleets_createPool' && body.name !== undefined)
+        seatName(body.name, op);
+    whole(body.credits, op, 'credits', 0);
+    if (body.computer_minutes !== undefined)
+        whole(body.computer_minutes, op, 'computer_minutes', 0);
+    bodyKey(body.idempotency_key, op);
+}
+function validateComputerKey(apiKey) {
+    if (typeof apiKey !== 'string' || !apiKey || byteLength(apiKey) > 4096 || /[\r\n\0]/.test(apiKey)) {
+        throw invalid('fleets_putComputerConnection', 'Computer key must contain 1–4096 UTF-8 bytes without CR, LF or NUL.');
+    }
+}
 /** Managed Henry instances and tasks scoped to the credential's verified org. */
 export function fleetsModule(client) {
     return {
@@ -174,6 +260,120 @@ export function fleetsModule(client) {
             },
             delete: () => client.request('fleets_deleteConnection', {}),
         },
+        /** Agent seats: a persistent Henry agent with a credit purse and a computer entitlement. Plan prices are display data. */
+        seats: {
+            plans: () => client.request('fleets_listSeatPlans', {}),
+            list: () => client.request('fleets_listSeats', {}),
+            /** Hire a seat. idempotency_key is required; reuse it on retry. fund: false opens an empty purse for top-up. */
+            hire: async (body) => {
+                validateSeatHire(body);
+                return client.request('fleets_hireSeat', { body });
+            },
+            get: async (seat_id) => {
+                seatPathId(seat_id, 'fleets_getSeat', 'seat');
+                return client.request('fleets_getSeat', { seat_id });
+            },
+            update: async (seat_id, body) => {
+                seatPathId(seat_id, 'fleets_updateSeat', 'seat');
+                validateSeatUpdate(body);
+                return client.request('fleets_updateSeat', { seat_id, body });
+            },
+            /** Add credits; overdraft is repaid first. Computer minutes come from the plan (upgrade, or use a pool). A pooled seat answers 409 pooled_seat: top up the pool. */
+            topUp: async (seat_id, credits, idempotency_key) => {
+                seatPathId(seat_id, 'fleets_topUpSeat', 'seat');
+                whole(credits, 'fleets_topUpSeat', 'credits', 1);
+                bodyKey(idempotency_key, 'fleets_topUpSeat');
+                return client.request('fleets_topUpSeat', { seat_id, body: { credits, idempotency_key } });
+            },
+            /** Move to a larger plan; there is no downgrade. */
+            upgrade: async (seat_id, type) => {
+                seatPathId(seat_id, 'fleets_upgradeSeat', 'seat');
+                seatType(type, 'fleets_upgradeSeat');
+                return client.request('fleets_upgradeSeat', { seat_id, body: { type } });
+            },
+            hold: async (seat_id) => {
+                seatPathId(seat_id, 'fleets_holdSeat', 'seat');
+                return client.request('fleets_holdSeat', { seat_id });
+            },
+            resume: async (seat_id) => {
+                seatPathId(seat_id, 'fleets_resumeSeat', 'seat');
+                return client.request('fleets_resumeSeat', { seat_id });
+            },
+            kill: async (seat_id) => {
+                seatPathId(seat_id, 'fleets_killSeat', 'seat');
+                return client.request('fleets_killSeat', { seat_id });
+            },
+            /** Settle the purse and delete the agent (terminal); answers returned_credits, returned_computer_minutes, unpaid_overdraft_credits, spent_credits. */
+            release: async (seat_id) => {
+                seatPathId(seat_id, 'fleets_releaseSeat', 'seat');
+                return client.request('fleets_releaseSeat', { seat_id });
+            },
+            ledger: async (seat_id) => {
+                seatPathId(seat_id, 'fleets_getSeatLedger', 'seat');
+                return client.request('fleets_getSeatLedger', { seat_id });
+            },
+            tasks: {
+                list: async (seat_id) => {
+                    seatPathId(seat_id, 'fleets_listSeatTasks', 'seat');
+                    return client.request('fleets_listSeatTasks', { seat_id });
+                },
+                /** 402 purse_empty when parked, 403 computer_not_entitled for a helper's computer task, 409 when held, killed or released. */
+                submit: async (seat_id, body) => {
+                    seatPathId(seat_id, 'fleets_submitSeatTask', 'seat');
+                    validateSeatTask(body);
+                    return client.request('fleets_submitSeatTask', { seat_id, body });
+                },
+                get: async (seat_id, task_id) => {
+                    seatPathId(seat_id, 'fleets_getSeatTask', 'seat');
+                    seatPathId(task_id, 'fleets_getSeatTask', 'task');
+                    return client.request('fleets_getSeatTask', { seat_id, task_id });
+                },
+                decide: async (seat_id, task_id, approval_id, decision) => {
+                    const op = 'fleets_decideSeatTaskApproval';
+                    seatPathId(seat_id, op, 'seat');
+                    seatPathId(task_id, op, 'task');
+                    seatPathId(approval_id, op, 'approval');
+                    if (decision !== 'approve' && decision !== 'deny')
+                        throw invalid(op, 'Decision must be approve or deny.');
+                    return client.request(op, { seat_id, task_id, approval_id, body: { decision } });
+                },
+            },
+        },
+        /** Seat pools: a shared purse and computer minutes that seats hired with pool_id draw on. */
+        pools: {
+            list: () => client.request('fleets_listPools', {}),
+            create: async (body) => {
+                validatePool(body, 'fleets_createPool');
+                return client.request('fleets_createPool', { body });
+            },
+            get: async (pool_id) => {
+                seatPathId(pool_id, 'fleets_getPool', 'pool');
+                return client.request('fleets_getPool', { pool_id });
+            },
+            topUp: async (pool_id, body) => {
+                seatPathId(pool_id, 'fleets_topUpPool', 'pool');
+                validatePool(body, 'fleets_topUpPool');
+                return client.request('fleets_topUpPool', { pool_id, body });
+            },
+            ledger: async (pool_id) => {
+                seatPathId(pool_id, 'fleets_getPoolLedger', 'pool');
+                return client.request('fleets_getPoolLedger', { pool_id });
+            },
+            /** Settle the pool (terminal); answers returned_credits and returned_computer_minutes. 409 pool_has_seats while seats remain. */
+            release: async (pool_id) => {
+                seatPathId(pool_id, 'fleets_releasePool', 'pool');
+                return client.request('fleets_releasePool', { pool_id });
+            },
+        },
+        /** The organization key seat computer tasks use for Panes and Shells; KMS-encrypted, never returned. */
+        computerConnection: {
+            get: () => client.request('fleets_getComputerConnection', {}),
+            set: async (api_key) => {
+                validateComputerKey(api_key);
+                return client.request('fleets_putComputerConnection', { body: { api_key } });
+            },
+            delete: () => client.request('fleets_deleteComputerConnection', {}),
+        },
         usage: {
             /** Task lifecycle and execution-time usage events, paged by task like tasks.list. */
             events: (query = {}) => client.request('fleets_listUsageEvents', query),