@onesi/genesis 0.0.1-stage → 0.2.0

package/dist/flares.d.ts

@@ -0,0 +1,202 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+/** Flares v2 (Sandbox): flares, conversations, commitments, presence, trust and choreography.
+ * Every mutation needs one stable idempotency key; reuse it to replay instead of acting twice. */
+export declare function flaresModule(client: GenesisClient): {
+    list: (q?: In<"flares_listFlares">) => Promise<({
+        id?: string;
+        status?: string;
+        flareType?: string;
+        recipientId?: string;
+        recipientType?: string;
+        priority?: string;
+        channels?: string[];
+        createdAt?: string;
+        updatedAt?: string;
+        deliveryReceipts?: {
+            [key: string]: unknown;
+        };
+    } & {
+        [key: string]: unknown;
+    })[]>;
+    get: (id: string) => Promise<{
+        id?: string;
+        status?: string;
+        flareType?: string;
+        recipientId?: string;
+        recipientType?: string;
+        priority?: string;
+        channels?: string[];
+        createdAt?: string;
+        updatedAt?: string;
+        deliveryReceipts?: {
+            [key: string]: unknown;
+        };
+    } & {
+        [key: string]: unknown;
+    }>;
+    send: (body: In<"flares_sendFlare">["body"], key: string) => Promise<{
+        id?: string;
+        status?: string;
+    }>;
+    sendBatch: (body: In<"flares_sendFlareBatch">["body"], key: string) => Promise<{
+        results?: import("./index.js").components["schemas"]["Flares.SendFlareResponse"][];
+    }>;
+    acknowledge: (id: string, body: In<"flares_acknowledgeFlare">["body"], key: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    act: (id: string, body: In<"flares_actOnFlare">["body"], key: string) => Promise<{
+        [key: string]: unknown;
+    }>;
+    conversations: {
+        list: () => Promise<{
+            [key: string]: unknown;
+        }[]>;
+        get: (id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        create: (body: In<"flares_createConversation">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        send: (id: string, body: In<"flares_sendConversationMessage">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        close: (id: string, key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    commitments: {
+        list: () => Promise<{
+            [key: string]: unknown;
+        }[]>;
+        get: (id: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        create: (body: In<"flares_createCommitment">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        accept: (id: string, key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        start: (id: string, key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        progress: (id: string, body: In<"flares_reportCommitmentProgress">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        fulfill: (id: string, body: In<"flares_fulfillCommitment">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        fail: (id: string, body: In<"flares_failCommitment">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    presence: {
+        list: () => Promise<({
+            did?: string;
+            status?: string;
+            sessionId?: string;
+            sessionCount?: number;
+            lastSeenAt?: string;
+        } & {
+            [key: string]: unknown;
+        })[]>;
+        heartbeat: (body: In<"flares_presenceHeartbeat">["body"], key: string) => Promise<{
+            did?: string;
+            status?: string;
+            sessionId?: string;
+            sessionCount?: number;
+            lastSeenAt?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        get: (did: string) => Promise<{
+            did?: string;
+            status?: string;
+            sessionId?: string;
+            sessionCount?: number;
+            lastSeenAt?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+    trust: {
+        list: () => Promise<({
+            did?: string;
+            score?: number;
+            confidence?: number;
+            dataPoints?: number;
+            computedAt?: string;
+            expiresAt?: string;
+            trustLevel?: string;
+            endorsementCount?: number;
+        } & {
+            [key: string]: unknown;
+        })[]>;
+        score: (did: string) => Promise<{
+            did?: string;
+            score?: number;
+            confidence?: number;
+            dataPoints?: number;
+            computedAt?: string;
+            expiresAt?: string;
+            trustLevel?: string;
+            endorsementCount?: number;
+        } & {
+            [key: string]: unknown;
+        }>;
+        check: (body: In<"flares_checkTrust">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        endorsements: (did: string) => Promise<{
+            [key: string]: unknown;
+        }[]>;
+        endorse: (body: In<"flares_createEndorsement">["body"], key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        revoke: (id: string, key: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    activity: {
+        list: (q?: In<"flares_listActivity">) => Promise<({
+            id?: string;
+            at?: string;
+            action?: string;
+            resourceId?: string | null;
+            actor?: string;
+        } & {
+            [key: string]: unknown;
+        })[]>;
+    };
+    choreography: {
+        workflows: {
+            list: () => Promise<{
+                [key: string]: unknown;
+            }[]>;
+            create: (body: In<"flares_createChoreographyWorkflow">["body"], key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            start: (workflow_id: string, key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+        executions: {
+            list: () => Promise<{
+                [key: string]: unknown;
+            }[]>;
+            get: (execution_id: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            completeStep: (execution_id: string, step_id: string, body: In<"flares_completeChoreographyStep">["body"], key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            failStep: (execution_id: string, step_id: string, body: In<"flares_failChoreographyStep">["body"], key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+            cancel: (execution_id: string, key: string) => Promise<{
+                [key: string]: unknown;
+            }>;
+        };
+    };
+};

package/dist/flares.js

@@ -0,0 +1,61 @@
+import { idempotencyHeaders } from './idempotency.js';
+/** Flares v2 (Sandbox): flares, conversations, commitments, presence, trust and choreography.
+ * Every mutation needs one stable idempotency key; reuse it to replay instead of acting twice. */
+export function flaresModule(client) {
+    const write = async (id, input, idempotencyKey) => client.request(id, input, { headers: idempotencyHeaders(id, idempotencyKey) });
+    return {
+        list: (q = {}) => client.request('flares_listFlares', q),
+        get: (id) => client.request('flares_getFlare', { id }),
+        send: (body, key) => write('flares_sendFlare', { body }, key),
+        sendBatch: (body, key) => write('flares_sendFlareBatch', { body }, key),
+        acknowledge: (id, body, key) => write('flares_acknowledgeFlare', { id, body }, key),
+        act: (id, body, key) => write('flares_actOnFlare', { id, body }, key),
+        conversations: {
+            list: () => client.request('flares_listConversations'),
+            get: (id) => client.request('flares_getConversation', { id }),
+            create: (body, key) => write('flares_createConversation', { body }, key),
+            send: (id, body, key) => write('flares_sendConversationMessage', { id, body }, key),
+            close: (id, key) => write('flares_closeConversation', { id }, key),
+        },
+        commitments: {
+            list: () => client.request('flares_listCommitments'),
+            get: (id) => client.request('flares_getCommitment', { id }),
+            create: (body, key) => write('flares_createCommitment', { body }, key),
+            accept: (id, key) => write('flares_acceptCommitment', { id }, key),
+            start: (id, key) => write('flares_startCommitment', { id }, key),
+            progress: (id, body, key) => write('flares_reportCommitmentProgress', { id, body }, key),
+            fulfill: (id, body, key) => write('flares_fulfillCommitment', { id, body }, key),
+            fail: (id, body, key) => write('flares_failCommitment', { id, body }, key),
+        },
+        presence: {
+            list: () => client.request('flares_listPresence'),
+            heartbeat: (body, key) => write('flares_presenceHeartbeat', { body }, key),
+            get: (did) => client.request('flares_getPresence', { did }),
+        },
+        trust: {
+            list: () => client.request('flares_listTrust'),
+            score: (did) => client.request('flares_getTrustScore', { did }),
+            check: (body, key) => write('flares_checkTrust', { body }, key),
+            endorsements: (did) => client.request('flares_listEndorsements', { did }),
+            endorse: (body, key) => write('flares_createEndorsement', { body }, key),
+            revoke: (id, key) => write('flares_revokeEndorsement', { id }, key),
+        },
+        activity: {
+            list: (q = {}) => client.request('flares_listActivity', q),
+        },
+        choreography: {
+            workflows: {
+                list: () => client.request('flares_listChoreographyWorkflows'),
+                create: (body, key) => write('flares_createChoreographyWorkflow', { body }, key),
+                start: (workflow_id, key) => write('flares_startChoreographyExecution', { workflow_id }, key),
+            },
+            executions: {
+                list: () => client.request('flares_listChoreographyExecutions'),
+                get: (execution_id) => client.request('flares_getChoreographyExecution', { execution_id }),
+                completeStep: (execution_id, step_id, body, key) => write('flares_completeChoreographyStep', { execution_id, step_id, body }, key),
+                failStep: (execution_id, step_id, body, key) => write('flares_failChoreographyStep', { execution_id, step_id, body }, key),
+                cancel: (execution_id, key) => write('flares_cancelChoreographyExecution', { execution_id }, key),
+            },
+        },
+    };
+}

package/dist/fleets.d.ts

@@ -0,0 +1,218 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput } from './types.js';
+type TaskInput = NonNullable<OperationInput<'fleets_submitTask'>['body']>;
+type AgentLaunchInput = NonNullable<OperationInput<'fleets_launchAgent'>['body']>;
+type AgentCommandInput = NonNullable<OperationInput<'fleets_commandAgent'>['body']>;
+type AgentUpdateInput = NonNullable<OperationInput<'fleets_updateAgent'>['body']>;
+type AgentLogsQuery = Omit<OperationInput<'fleets_getAgentLogs'>, 'agent_id'>;
+type TaskLogsQuery = Omit<OperationInput<'fleets_getTaskLogs'>, 'task_id'>;
+export interface FleetsInstanceOptions {
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+}
+/** Managed Henry instances and tasks scoped to the credential's verified org. */
+export declare function fleetsModule(client: GenesisClient): {
+    agents: {
+        list: () => Promise<{
+            agents: import("./index.js").components["schemas"]["Fleets.Agent"][];
+        }>;
+        launch: (body: AgentLaunchInput) => Promise<{
+            id: string;
+            name: string;
+            state: "launching" | "running" | "stopping" | "stopped" | "recovering" | "recovery_required";
+            memory: import("./index.js").components["schemas"]["Fleets.Memory"];
+            model?: string | null;
+            inference: {
+                provider: "foundry";
+                mode: "managed";
+            };
+            created_at_ms: number;
+            updated_at_ms: number;
+            last_operation_id?: string | null;
+        }>;
+        get: (agent_id: string) => Promise<{
+            id: string;
+            name: string;
+            state: "launching" | "running" | "stopping" | "stopped" | "recovering" | "recovery_required";
+            memory: import("./index.js").components["schemas"]["Fleets.Memory"];
+            model?: string | null;
+            inference: {
+                provider: "foundry";
+                mode: "managed";
+            };
+            created_at_ms: number;
+            updated_at_ms: number;
+            last_operation_id?: string | null;
+        }>;
+        command: (agent_id: string, body: AgentCommandInput) => Promise<{
+            agent: import("./index.js").components["schemas"]["Fleets.Agent"];
+            operation_id: string;
+            result?: {
+                [key: string]: unknown;
+            };
+        }>;
+        stop: (agent_id: string) => Promise<{
+            agent: import("./index.js").components["schemas"]["Fleets.Agent"];
+            operation_id: string;
+            result?: {
+                [key: string]: unknown;
+            };
+        }>;
+        recover: (agent_id: string) => Promise<{
+            agent: import("./index.js").components["schemas"]["Fleets.Agent"];
+            operation_id: string;
+            result?: {
+                [key: string]: unknown;
+            };
+        }>;
+        /** Change name, model, instructions or memory. A memory change needs a stopped agent. */
+        update: (agent_id: string, body: AgentUpdateInput) => Promise<{
+            agent: import("./index.js").components["schemas"]["Fleets.Agent"];
+            operation_id: string;
+            result?: {
+                [key: string]: unknown;
+            };
+        }>;
+        /** Delete a stopped (or recovery_required) idle agent and its log. */
+        delete: (agent_id: string) => Promise<{
+            id: string;
+            deleted: true;
+            operation_id: string;
+        }>;
+        /** Operation log, oldest first; page with after = next_after. */
+        logs: (agent_id: string, query?: AgentLogsQuery) => Promise<{
+            agent_id: string;
+            state: "launching" | "running" | "stopping" | "stopped" | "recovering" | "recovery_required";
+            entries: import("./index.js").components["schemas"]["Fleets.AgentLogEntry"][];
+            next_after: number | null;
+        }>;
+    };
+    instances: {
+        list: (query?: OperationInput<"fleets_listInstances">) => Promise<{
+            instances: import("./index.js").components["schemas"]["Fleets.Instance"][];
+            next_cursor: string | null;
+        }>;
+        get: (instance_id: string) => Promise<{
+            id: string;
+            name: string;
+            organization_id: string;
+            workspace_id: string;
+            project_id: string;
+            admission_held: boolean | null;
+            physical_state: "created" | "running" | "held" | "stopped" | "recovery_required" | "released";
+            status_evidence: "live_controller" | "confirmed_release_receipt";
+            release_acknowledged_at_ms: number | null;
+            harness_ready: boolean;
+            observed_at_ms: number | null;
+            lease_expires: {
+                wall_ms: number;
+                logical: number;
+            } | null;
+        }>;
+        stop: (instance_id: string, options?: FleetsInstanceOptions) => Promise<{
+            id: string;
+            state: "released";
+            reaped: true;
+            data_retained: true;
+            status_evidence: "confirmed_release_receipt";
+            release_acknowledged_at_ms: number;
+        }>;
+        start: (instance_id: string, options?: FleetsInstanceOptions) => Promise<{
+            id: string;
+            name: string;
+            organization_id: string;
+            workspace_id: string;
+            project_id: string;
+            admission_held: boolean | null;
+            physical_state: "created" | "running" | "held" | "stopped" | "recovery_required" | "released";
+            status_evidence: "live_controller" | "confirmed_release_receipt";
+            release_acknowledged_at_ms: number | null;
+            harness_ready: boolean;
+            observed_at_ms: number | null;
+            lease_expires: {
+                wall_ms: number;
+                logical: number;
+            } | null;
+        }>;
+    };
+    connection: {
+        get: () => Promise<{
+            connected: boolean;
+            model: string;
+            updated_at?: number;
+        }>;
+        set: (api_key: string) => Promise<{
+            connected: boolean;
+            model: string;
+            updated_at?: number;
+        }>;
+        delete: () => Promise<{
+            connected: boolean;
+            model: string;
+            updated_at?: number;
+        }>;
+    };
+    usage: {
+        /** Task lifecycle and execution-time usage events, paged by task like tasks.list. */
+        events: (query?: OperationInput<"fleets_listUsageEvents">) => Promise<{
+            events: import("./index.js").components["schemas"]["Fleets.UsageEvent"][];
+            next_before: string | null;
+        }>;
+    };
+    tasks: {
+        list: (query?: OperationInput<"fleets_listTasks">) => Promise<{
+            tasks: import("./index.js").components["schemas"]["Fleets.Summary"][];
+            next_before: string | null;
+        }>;
+        submit: (body: TaskInput) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+            submitted_at: string;
+            started_at?: string | null;
+            completed_at?: string | null;
+        }>;
+        get: (task_id: string) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+            submitted_at: string;
+            started_at?: string | null;
+            completed_at?: string | null;
+        }>;
+        cancel: (task_id: string) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+        }>;
+        receipt: (task_id: string) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+            submitted_at: string;
+            started_at?: string | null;
+            completed_at?: string | null;
+        } & {
+            tenant: string;
+            principal: string;
+            idempotency_key: string | null;
+            request_fingerprint: string;
+            timeout_seconds: number;
+            exit_code: number | null;
+            exit_signal: number | null;
+            cleanup_result: {
+                process_group_gone?: boolean;
+                workdir_removed?: boolean;
+                sigkill_sent?: boolean;
+            } | null;
+            henry_receipt?: {
+                [key: string]: unknown;
+            };
+        }>;
+        /** Lifecycle and output log; poll with after = next_after until complete. */
+        logs: (task_id: string, query?: TaskLogsQuery) => Promise<{
+            task_id: string;
+            state: "pending" | "running" | "cancelling" | "completed" | "failed" | "cancelled" | "timed_out";
+            complete: boolean;
+            entries: import("./index.js").components["schemas"]["Fleets.TaskLogEntry"][];
+            next_after: number | null;
+        }>;
+    };
+};
+export {};

package/dist/fleets.js

@@ -0,0 +1,189 @@
+import { GenesisError } from './errors.js';
+const byteLength = (value) => new TextEncoder().encode(value).byteLength;
+const invalid = (operationId, message) => new GenesisError({
+    status: 0, type: 'invalid_request', operationId, message,
+});
+function instanceOptions(operation, options) {
+    const key = options.idempotencyKey;
+    if (key !== undefined && (typeof key !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(key))) {
+        throw invalid(operation, 'Idempotency-Key must be one canonical UUID4.');
+    }
+    return { signal: options.signal, ...(key === undefined ? {} : { headers: { 'idempotency-key': key } }) };
+}
+function validateTask(body) {
+    if (typeof body?.input !== 'string' || !body.input || byteLength(body.input) > 65536 || body.input.includes('\0')) {
+        throw invalid('fleets_submitTask', 'Task input must contain 1–65536 UTF-8 bytes without NUL.');
+    }
+    if (body.timeout_seconds !== undefined && (!Number.isInteger(body.timeout_seconds) || body.timeout_seconds < 1 || body.timeout_seconds > 3600)) {
+        throw invalid('fleets_submitTask', 'Timeout must be 1–3600 seconds.');
+    }
+    if (body.idempotency_key !== undefined && (typeof body.idempotency_key !== 'string' || !/^[!-~]{1,128}$/.test(body.idempotency_key))) {
+        throw invalid('fleets_submitTask', 'Idempotency key must contain 1–128 visible ASCII characters.');
+    }
+}
+function validateKey(apiKey) {
+    if (typeof apiKey !== 'string' || !apiKey || byteLength(apiKey) > 4096 || /[\r\n\0]/.test(apiKey)) {
+        throw invalid('fleets_setConnection', 'Foundry key must contain 1–4096 UTF-8 bytes without CR, LF or NUL.');
+    }
+}
+const instanceId = (value, operation) => {
+    if (typeof value !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) {
+        throw invalid(operation, 'Invalid Fleets instance ID.');
+    }
+};
+const agentId = (value, operation) => {
+    if (typeof value !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) {
+        throw invalid(operation, 'Invalid Fleets agent ID.');
+    }
+};
+function validateAgentLaunch(body) {
+    if (!body || typeof body.name !== 'string' || !body.name.trim() || byteLength(body.name) > 128) {
+        throw invalid('fleets_launchAgent', 'Agent name must contain 1–128 UTF-8 bytes.');
+    }
+    if (body.instructions !== undefined && (byteLength(body.instructions) > 65536 || body.instructions.includes('\0'))) {
+        throw invalid('fleets_launchAgent', 'Agent instructions must contain at most 65536 UTF-8 bytes without NUL.');
+    }
+    if (body.model !== undefined && (!body.model || byteLength(body.model) > 128)) {
+        throw invalid('fleets_launchAgent', 'Agent model must contain 1–128 UTF-8 bytes.');
+    }
+    validateMemory('fleets_launchAgent', body.memory);
+    if (body.idempotency_key !== undefined && (typeof body.idempotency_key !== 'string' || !/^[!-~]{1,128}$/.test(body.idempotency_key))) {
+        throw invalid('fleets_launchAgent', 'Idempotency key must contain 1–128 visible ASCII characters.');
+    }
+}
+function validateAgentCommand(body) {
+    if (!body || typeof body.input !== 'string' || !body.input.trim() || byteLength(body.input) > 65536 || body.input.includes('\0')) {
+        throw invalid('fleets_commandAgent', 'Agent input must contain 1–65536 UTF-8 bytes without NUL.');
+    }
+}
+function validateMemory(operation, memory) {
+    if (memory === undefined)
+        return;
+    if (!memory || !['minds', 'files', 'custom'].includes(memory.provider))
+        throw invalid(operation, 'Memory provider must be minds, files, or custom.');
+    if (memory.provider === 'custom' && !memory.endpoint)
+        throw invalid(operation, 'Custom memory requires an endpoint.');
+}
+function validateAgentUpdate(body) {
+    const op = 'fleets_updateAgent';
+    if (!body || typeof body !== 'object' || Array.isArray(body))
+        throw invalid(op, 'Provide at least one of name, model, instructions or memory.');
+    const keys = Object.keys(body);
+    if (!keys.length || keys.some(key => !['name', 'model', 'instructions', 'memory'].includes(key))) {
+        throw invalid(op, 'Provide at least one of name, model, instructions or memory.');
+    }
+    if (body.name !== undefined && (typeof body.name !== 'string' || !body.name.trim() || byteLength(body.name) > 128)) {
+        throw invalid(op, 'Agent name must contain 1–128 UTF-8 bytes.');
+    }
+    if (body.model !== undefined && body.model !== null && (typeof body.model !== 'string' || !body.model || byteLength(body.model) > 128)) {
+        throw invalid(op, 'Agent model must contain 1–128 UTF-8 bytes, or be null to clear it.');
+    }
+    if (body.instructions !== undefined && body.instructions !== null
+        && (typeof body.instructions !== 'string' || byteLength(body.instructions) > 65536 || body.instructions.includes('\0'))) {
+        throw invalid(op, 'Agent instructions must contain at most 65536 UTF-8 bytes without NUL, or be null to clear them.');
+    }
+    validateMemory(op, body.memory);
+}
+const cursor = (value, operation, max) => {
+    if (value !== undefined && (!Number.isSafeInteger(value) || value < 0 || value > max)) {
+        throw invalid(operation, 'after must be a non-negative integer cursor (next_after).');
+    }
+};
+/** Managed Henry instances and tasks scoped to the credential's verified org. */
+export function fleetsModule(client) {
+    return {
+        agents: {
+            list: () => client.request('fleets_listAgents'),
+            launch: async (body) => {
+                validateAgentLaunch(body);
+                return client.request('fleets_launchAgent', { body });
+            },
+            get: async (agent_id) => {
+                agentId(agent_id, 'fleets_getAgent');
+                return client.request('fleets_getAgent', { agent_id });
+            },
+            command: async (agent_id, body) => {
+                agentId(agent_id, 'fleets_commandAgent');
+                validateAgentCommand(body);
+                return client.request('fleets_commandAgent', { agent_id, body });
+            },
+            stop: async (agent_id) => {
+                agentId(agent_id, 'fleets_stopAgent');
+                return client.request('fleets_stopAgent', { agent_id });
+            },
+            recover: async (agent_id) => {
+                agentId(agent_id, 'fleets_recoverAgent');
+                return client.request('fleets_recoverAgent', { agent_id });
+            },
+            /** Change name, model, instructions or memory. A memory change needs a stopped agent. */
+            update: async (agent_id, body) => {
+                agentId(agent_id, 'fleets_updateAgent');
+                validateAgentUpdate(body);
+                return client.request('fleets_updateAgent', { agent_id, body });
+            },
+            /** Delete a stopped (or recovery_required) idle agent and its log. */
+            delete: async (agent_id) => {
+                agentId(agent_id, 'fleets_deleteAgent');
+                return client.request('fleets_deleteAgent', { agent_id });
+            },
+            /** Operation log, oldest first; page with after = next_after. */
+            logs: async (agent_id, query = {}) => {
+                agentId(agent_id, 'fleets_getAgentLogs');
+                cursor(query.after, 'fleets_getAgentLogs', Number.MAX_SAFE_INTEGER);
+                if (query.limit !== undefined && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 200)) {
+                    throw invalid('fleets_getAgentLogs', 'Limit must be 1–200.');
+                }
+                return client.request('fleets_getAgentLogs', { agent_id, ...query });
+            },
+        },
+        instances: {
+            list: async (query = {}) => {
+                if (query.limit !== undefined && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 50)) {
+                    throw invalid('fleets_listInstances', 'Limit must be 1–50.');
+                }
+                if (query.after !== undefined)
+                    instanceId(query.after, 'fleets_listInstances');
+                return client.request('fleets_listInstances', query);
+            },
+            get: async (instance_id) => {
+                instanceId(instance_id, 'fleets_getInstance');
+                return client.request('fleets_getInstance', { instance_id });
+            },
+            stop: async (instance_id, options = {}) => {
+                instanceId(instance_id, 'fleets_stopInstance');
+                return client.request('fleets_stopInstance', { instance_id }, instanceOptions('fleets_stopInstance', options));
+            },
+            start: async (instance_id, options = {}) => {
+                instanceId(instance_id, 'fleets_startInstance');
+                return client.request('fleets_startInstance', { instance_id }, instanceOptions('fleets_startInstance', options));
+            },
+        },
+        connection: {
+            get: () => client.request('fleets_getConnection', {}),
+            set: async (api_key) => {
+                validateKey(api_key);
+                return client.request('fleets_setConnection', { body: { api_key } });
+            },
+            delete: () => client.request('fleets_deleteConnection', {}),
+        },
+        usage: {
+            /** Task lifecycle and execution-time usage events, paged by task like tasks.list. */
+            events: (query = {}) => client.request('fleets_listUsageEvents', query),
+        },
+        tasks: {
+            list: (query = {}) => client.request('fleets_listTasks', query),
+            submit: async (body) => {
+                validateTask(body);
+                return client.request('fleets_submitTask', { body });
+            },
+            get: (task_id) => client.request('fleets_getTask', { task_id }),
+            cancel: (task_id) => client.request('fleets_cancelTask', { task_id }),
+            receipt: (task_id) => client.request('fleets_getTaskReceipt', { task_id }),
+            /** Lifecycle and output log; poll with after = next_after until complete. */
+            logs: async (task_id, query = {}) => {
+                cursor(query.after, 'fleets_getTaskLogs', 4294967295);
+                return client.request('fleets_getTaskLogs', { task_id, ...query });
+            },
+        },
+    };
+}