@lifesi/genesis 0.1.1 → 0.1.3

package/dist/client.js

@@ -1,6 +1,9 @@
+import { isHivesObjectUpload, hivesObjectBody, hivesContentType, isHivesResourceOperation, resourceError } from './hives-resources-transport.js';
 import { operationTable, services } from './generated/operations.js';
 import { GenesisError } from './errors.js';
 import { validateHivesInvocation, hivesFunctionResponseHeaders, hivesFunctionMetadata } from './hives-functions.js';
+import { validateHivesEnvironment, hivesEnvironmentMetadata, hivesEnvironmentReveal } from './hives-environment.js';
+import { RUNNER_SELF_GRANT_OPERATION, snapshotRunnerSelfGrant, runnerGrantResponse, runnerGrantTransportError } from './runner-grant.js';
 export const DEFAULT_BASE_URL = 'https://console.life.one/api';
 const env = globalThis.process?.env ?? {};
 export class GenesisClient {
@@ -70,6 +73,8 @@ export class GenesisClient {
             value = ct.includes('json') ? await res.json() : await res.text();
         }
         catch (error) {
+            if (String(operationId).startsWith('hives_') && String(operationId).endsWith('_project_environment'))
+                throw new Error('Hives returned invalid environment data.');
             if (String(operationId).startsWith('hives_') && /_functions?$/.test(operationId))
                 throw new Error('Hives returned invalid function metadata.');
             throw error;
@@ -81,21 +86,48 @@ export class GenesisClient {
             return { data: value.data.map((row) => hivesFunctionMetadata(row, input?.project_id)), pagination };
         }
         if (['hives_get_function', 'hives_create_function', 'hives_update_function'].includes(operationId)) {
-            return hivesFunctionMetadata(value, input?.project_id);
+            return hivesFunctionMetadata(value, input?.project_id, operationId === 'hives_create_function' ? undefined : input?.function_id);
+        }
+        if (operationId === 'hives_list_project_environment' || operationId === 'hives_update_project_environment') {
+            return hivesEnvironmentMetadata(value, input?.project_id, operationId === 'hives_update_project_environment');
+        }
+        if (operationId === 'hives_reveal_project_environment') {
+            return hivesEnvironmentReveal(value, input?.key);
         }
         return value;
     }
     /** Raw Response. Completed Hives guest responses retain their actual status, including non-2xx. */
     async raw(operationId, input = {}, init = {}) {
+        const runnerGrant = operationId === RUNNER_SELF_GRANT_OPERATION ? snapshotRunnerSelfGrant(input, this.routing) : undefined;
+        if (runnerGrant)
+            input = { body: runnerGrant };
         const op = operationTable[operationId];
         if (op.rawResponse && op.service === 'hives')
             validateHivesInvocation(input.body);
+        const flocksNative = ['flocks_exchangeJoinToken', 'flocks_activateNode', 'flocks_rotateNodeCredential'].includes(operationId);
+        if (flocksNative && this.routing === 'direct')
+            throw new GenesisError({ status: 0, type: 'invalid_request', message: 'Native Flocks credentials are brokered only through the Genesis gateway.', operationId });
+        if (operationId === 'hives_update_project_environment')
+            input = { ...input, body: validateHivesEnvironment(input.body) };
+        const objectBody = isHivesObjectUpload(operationId) ? await hivesObjectBody(input.body) : undefined;
         const url = this.url(operationId, input);
         const headers = {
             accept: 'application/json',
             'user-agent': this.opts.userAgent ?? '@lifesi/genesis/0.1.0',
             ...this.opts.headers, ...init.headers,
         };
+        if (runnerGrant) {
+            for (const key of Object.keys(headers))
+                if (!['accept', 'user-agent'].includes(key.toLowerCase()))
+                    delete headers[key];
+            headers['x-request-id'] = runnerGrant.requestId;
+            headers['idempotency-key'] = runnerGrant.operationId;
+        }
+        if (operationId === 'flocks_exchangeJoinToken') {
+            for (const key of Object.keys(headers))
+                if (!['accept', 'user-agent'].includes(key.toLowerCase()))
+                    delete headers[key];
+        }
         if (!op.public) {
             const cred = await this.credential();
             // Direct mode: let the upstream decide (some, like Foundry's model list, are public).
@@ -104,13 +136,21 @@ export class GenesisClient {
             if (cred)
                 headers.authorization = `Bearer ${cred}`;
         }
+        // A timed-out credential provider must not dispatch a later resource mutation.
+        if (init.signal?.aborted && isHivesResourceOperation(operationId))
+            throw resourceError(0, operationId);
         let body;
         if (op.hasBody && input.body !== undefined) {
             // Fetch owns multipart boundary generation. Never serialize a File/Blob as JSON.
             for (const key of Object.keys(headers))
                 if (key.toLowerCase() === 'content-type')
                     delete headers[key];
-            if (op.requestContentType === 'multipart/form-data') {
+            if (objectBody !== undefined && op.requestContentType === 'application/octet-stream') {
+                headers['content-type'] = hivesContentType(input.content_type);
+                headers['content-length'] = String(objectBody.byteLength);
+                body = objectBody;
+            }
+            else if (op.requestContentType === 'multipart/form-data') {
                 if (!(input.body instanceof FormData))
                     throw new GenesisError({ status: 0, type: 'invalid_request', operationId,
                         message: 'This operation requires a FormData body containing a real binary file.' });
@@ -124,14 +164,17 @@ export class GenesisClient {
                 body = JSON.stringify(input.body);
             }
         }
-        const secretOperation = op.service === 'hives' && /_secrets?$/.test(operationId);
+        const environmentOperation = op.service === 'hives' && operationId.endsWith('_project_environment');
+        const secretOperation = op.service === 'hives' && (/_secrets?$/.test(operationId) || environmentOperation);
         const functionOperation = op.service === 'hives' && (op.rawResponse || /_function(?:s|_async)?$/.test(operationId));
         let res;
         try {
             res = await this.fetchImpl(url, { method: op.method, headers, body, signal: init.signal,
-                ...(op.service === 'hives' ? { cache: 'no-store', redirect: op.rawResponse ? 'manual' : 'error' } : {}) });
+                ...(op.service === 'hives' || op.service === 'flocks' || runnerGrant ? { cache: 'no-store', redirect: op.rawResponse && !runnerGrant ? 'manual' : 'error' } : {}) });
         }
         catch (error) {
+            if (runnerGrant)
+                throw runnerGrantTransportError();
             if (functionOperation)
                 throw new GenesisError({ status: 0, type: 'transport_error', operationId,
                     message: 'Hives function transport failed. No redirects are followed; check the service address and retry.' });
@@ -140,6 +183,8 @@ export class GenesisClient {
             throw new GenesisError({ status: 0, type: 'transport_error', operationId,
                 message: 'Hives secret transport failed. Redirects are refused; check the service address and retry.' });
         }
+        if (runnerGrant)
+            return runnerGrantResponse(res, runnerGrant);
         if (op.rawResponse && /^exec_[a-f0-9]{32}$/.test(res.headers.get('x-execution-id') ?? '')) {
             return new Response(res.body, { status: res.status, statusText: res.statusText, headers: hivesFunctionResponseHeaders(res.headers) });
         }
@@ -170,7 +215,11 @@ export class GenesisClient {
                                             : `Hives secret operation failed (${res.status}). Refresh metadata and retry.`;
             // Validation/provider bodies may reflect submitted plaintext. Never retain or log them.
             throw new GenesisError({ status: res.status, type: `http_${res.status}`, message, operationId,
-                requestId: res.headers.get('x-request-id') ?? undefined });
+                requestId: environmentOperation ? undefined : res.headers.get('x-request-id') ?? undefined });
+        }
+        if (!res.ok && isHivesResourceOperation(operationId)) {
+            await res.body?.cancel().catch(() => { });
+            throw resourceError(res.status, operationId);
         }
         if (!res.ok)
             throw await GenesisError.fromResponse(res, operationId);

package/dist/dials.d.ts

@@ -5,9 +5,151 @@ export type DialsScope = components['schemas']['Dials.Scope'];
 export type DialsCallControl = components['schemas']['Dials.CallControl'];
 /** The public call contract requires customer-selected behavior for every caller. */
 export type DialsOutboundCall = components['schemas']['Dials.OutboundCall'];
+export type DialsOutboundCallReceipt = components['schemas']['Dials.OutboundCallReceipt'];
+export type DialsRecoveredOutboundCallReceipt = components['schemas']['Dials.RecoveredOutboundCallReceipt'];
 export type DialsEmergencyAddress = components['schemas']['Dials.RegisterEmergencyAddress'];
+export type DialsCallListItem = components['schemas']['Dials.CallListItem'];
+export type DialsCallDispatchState = components['schemas']['Dials.CallDispatchState'];
+export type DialsMessage = components['schemas']['Dials.MessageEvent'];
+export type DialsMessageTemplate = components['schemas']['Dials.MessageTemplate'];
+export type DialsMessagingBrand = components['schemas']['Dials.MessagingBrand'];
+export type DialsMessagingCampaign = components['schemas']['Dials.MessagingCampaign'];
+export type DialsWorkflowDocument = components['schemas']['Dials.WorkflowDocument'];
+export type DialsRoutingAction = components['schemas']['Dials.RoutingAction'];
+export type DialsRoutingRule = components['schemas']['Dials.RoutingRule'];
+export type DialsRoutingRuleReceipt = components['schemas']['Dials.RoutingRuleReceipt'];
 /** Scope is selection only; the Dials backend verifies its org against signed identity. */
 export declare function dialsModule(client: GenesisClient): {
+    routing: {
+        list: (scope: DialsScope) => Promise<{
+            ok: true;
+            scope: components["schemas"]["Dials.Scope"];
+            rules: components["schemas"]["Dials.RoutingRule"][];
+        }>;
+        create: (body: OperationInput<"dials_createRoutingRule">["body"]) => Promise<{
+            ok: true;
+            rule: components["schemas"]["Dials.RoutingRule"];
+            auditId: string;
+            idempotentReplay: boolean;
+        }>;
+        disable: (ruleId: string, body: OperationInput<"dials_disableRoutingRule">["body"]) => Promise<{
+            ok: true;
+            rule: components["schemas"]["Dials.RoutingRule"];
+            auditId: string | null;
+            idempotentReplay: boolean;
+        }>;
+    };
+    people: {
+        list: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            humans: components["schemas"]["Dials.HumanProfile"][];
+        }>;
+        create: (body: OperationInput<"dials_createHumanProfile">["body"]) => Promise<{
+            ok: boolean;
+            human: components["schemas"]["Dials.HumanProfile"];
+            auditId: string;
+            usageEventId: string;
+            next: string;
+        }>;
+    };
+    agents: {
+        list: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            agents: components["schemas"]["Dials.AgentProfile"][];
+        }>;
+        create: (body: OperationInput<"dials_createAgent">["body"]) => Promise<{
+            ok: boolean;
+            agent: components["schemas"]["Dials.AgentProfile"];
+            auditId: string;
+            usageEventId: string;
+            next: string;
+        }>;
+    };
+    voice: {
+        list: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            voiceProfiles: components["schemas"]["Dials.VoiceProfile"][];
+        }>;
+        create: (body: OperationInput<"dials_createVoiceProfile">["body"]) => Promise<{
+            ok: boolean;
+            voiceProfile: components["schemas"]["Dials.VoiceProfile"];
+            auditId: string;
+            usageEventId: string;
+            next: string;
+        }>;
+    };
+    messages: {
+        list: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            messages: components["schemas"]["Dials.MessageEvent"][];
+        }>;
+        send: (body: OperationInput<"dials_createOutboundMessage">["body"]) => Promise<{
+            ok: boolean;
+            message: components["schemas"]["Dials.MessageEvent"];
+            auditId: string;
+            usageEventId: string;
+            next: string;
+            idempotentReplay: boolean;
+        }>;
+        templates: {
+            list: (scope: DialsScope) => Promise<{
+                ok: boolean;
+                templates: components["schemas"]["Dials.MessageTemplate"][];
+            }>;
+            create: (body: OperationInput<"dials_createMessageTemplate">["body"]) => Promise<{
+                ok: boolean;
+                template: components["schemas"]["Dials.MessageTemplate"];
+                auditId: string;
+                usageEventId: string;
+                next: string;
+            }>;
+        };
+        brands: {
+            list: (scope: DialsScope) => Promise<{
+                ok: boolean;
+                brands: components["schemas"]["Dials.MessagingBrand"][];
+            }>;
+            create: (body: OperationInput<"dials_createMessagingBrand">["body"]) => Promise<{
+                ok: boolean;
+                brand: components["schemas"]["Dials.MessagingBrand"];
+                auditId: string;
+                next: string;
+            }>;
+        };
+        campaigns: {
+            list: (scope: DialsScope) => Promise<{
+                ok: boolean;
+                campaigns: components["schemas"]["Dials.MessagingCampaign"][];
+            }>;
+            create: (body: OperationInput<"dials_createMessagingCampaign">["body"]) => Promise<{
+                ok: boolean;
+                campaign: components["schemas"]["Dials.MessagingCampaign"];
+                auditId: string;
+                next: string;
+            }>;
+            assignNumber: (campaignId: string, body: OperationInput<"dials_assignCampaignNumber">["body"]) => Promise<{
+                ok: boolean;
+                campaignId: string;
+                phoneNumberId: string;
+                auditId: string;
+                next: string;
+            }>;
+        };
+    };
+    workflows: {
+        list: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            workflows: components["schemas"]["Dials.WorkflowDocument"][];
+        }>;
+        deploy: (body: OperationInput<"dials_deployWorkflow">["body"]) => Promise<{
+            ok: boolean;
+            workflow: components["schemas"]["Dials.WorkflowDocument"];
+            auditId: string;
+            usageEventId: string;
+            next: string;
+            route: components["schemas"]["Dials.RoutingRule"];
+        }>;
+    };
     overview: {
         summary: (scope: DialsScope) => Promise<{
             ok: boolean;
@@ -100,6 +242,13 @@ export declare function dialsModule(client: GenesisClient): {
         assign: (body: OperationInput<"dials_assignNumber">["body"]) => Promise<{
             [key: string]: unknown;
         }>;
+        delete: (input: OperationInput<"dials_deleteNumber">) => Promise<{
+            ok: boolean;
+            number: components["schemas"]["Dials.Number"];
+            auditId: string;
+            usageEventId: string;
+            next: string;
+        }>;
         release: (body: OperationInput<"dials_releaseNumber">["body"]) => Promise<{
             [key: string]: unknown;
         }>;
@@ -114,14 +263,35 @@ export declare function dialsModule(client: GenesisClient): {
     calls: {
         list: (scope: DialsScope) => Promise<{
             ok: boolean;
-            calls: components["schemas"]["Dials.Call"][];
+            calls: components["schemas"]["Dials.CallListItem"][];
         }>;
         validate: (body: DialsOutboundCall) => Promise<{
             [key: string]: unknown;
         }>;
         create: (body: DialsOutboundCall) => Promise<{
+            ok: boolean;
+            call: components["schemas"]["Dials.CallSession"];
+            auditId: string;
+            dispatchJobId: string;
+            usageEventId: string;
+            next: string;
+            idempotentReplay: boolean;
+        } & {
             [key: string]: unknown;
         }>;
+        recover: (body: DialsOutboundCall) => Promise<{
+            ok: boolean;
+            call: components["schemas"]["Dials.CallSession"];
+            auditId: string;
+            dispatchJobId: string;
+            usageEventId: string;
+            next: string;
+            idempotentReplay: boolean;
+        } & {
+            [key: string]: unknown;
+        } & {
+            idempotentReplay: true;
+        }>;
     };
 };
 export type DialsEmergencyAddressFeedback = components['schemas']['Dials.EmergencyAddressFeedback'];

package/dist/dials.js

@@ -2,6 +2,44 @@ import { GenesisError } from './errors.js';
 /** Scope is selection only; the Dials backend verifies its org against signed identity. */
 export function dialsModule(client) {
     return {
+        routing: {
+            list: (scope) => client.request('dials_listRoutingRules', scope),
+            create: (body) => client.request('dials_createRoutingRule', { body }),
+            disable: (ruleId, body) => client.request('dials_disableRoutingRule', { rule_id: ruleId, body }),
+        },
+        people: {
+            list: (scope) => client.request('dials_listHumanProfiles', scope),
+            create: (body) => client.request('dials_createHumanProfile', { body }),
+        },
+        agents: {
+            list: (scope) => client.request('dials_listAgents', scope),
+            create: (body) => client.request('dials_createAgent', { body }),
+        },
+        voice: {
+            list: (scope) => client.request('dials_listVoiceProfiles', scope),
+            create: (body) => client.request('dials_createVoiceProfile', { body }),
+        },
+        messages: {
+            list: (scope) => client.request('dials_listMessages', scope),
+            send: (body) => client.request('dials_createOutboundMessage', { body }),
+            templates: {
+                list: (scope) => client.request('dials_listMessageTemplates', scope),
+                create: (body) => client.request('dials_createMessageTemplate', { body }),
+            },
+            brands: {
+                list: (scope) => client.request('dials_listMessagingBrands', scope),
+                create: (body) => client.request('dials_createMessagingBrand', { body }),
+            },
+            campaigns: {
+                list: (scope) => client.request('dials_listMessagingCampaigns', scope),
+                create: (body) => client.request('dials_createMessagingCampaign', { body }),
+                assignNumber: (campaignId, body) => client.request('dials_assignCampaignNumber', { campaign_id: campaignId, body }),
+            },
+        },
+        workflows: {
+            list: (scope) => client.request('dials_listWorkflows', scope),
+            deploy: (body) => client.request('dials_deployWorkflow', { body }),
+        },
         overview: {
             summary: (scope) => client.request('dials_getConsoleSummary', scope),
             operatingSurface: (scope) => client.request('dials_getOperatingSurface', scope),
@@ -15,6 +53,7 @@ export function dialsModule(client) {
             search: (scope, query = {}) => client.request('dials_searchNumbers', { ...query, ...scope }),
             provision: (body) => client.request('dials_provisionNumber', { body }),
             assign: (body) => client.request('dials_assignNumber', { body }),
+            delete: (input) => client.request('dials_deleteNumber', input),
             release: (body) => client.request('dials_releaseNumber', { body }),
             registerEmergencyAddress: (body) => client.request('dials_registerEmergencyAddress', { body }),
         },
@@ -22,6 +61,7 @@ export function dialsModule(client) {
             list: (scope) => client.request('dials_listCalls', scope),
             validate: (body) => client.request('dials_validateOutboundCall', { body }),
             create: (body) => client.request('dials_createOutboundCall', { body }),
+            recover: (body) => client.request('dials_recoverOutboundCall', { body }),
         },
     };
 }

package/dist/fleets.d.ts

@@ -1,8 +1,116 @@
 import type { GenesisClient } from './client.js';
 import type { OperationInput } from './types.js';
 type TaskInput = NonNullable<OperationInput<'fleets_submitTask'>['body']>;
-/** Managed agent tasks, always scoped to the credential's verified organization. */
+type AgentLaunchInput = NonNullable<OperationInput<'fleets_launchAgent'>['body']>;
+type AgentCommandInput = NonNullable<OperationInput<'fleets_commandAgent'>['body']>;
+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;
+            };
+        }>;
+    };
+    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;

package/dist/fleets.js

@@ -3,6 +3,13 @@ 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.');
@@ -19,9 +26,90 @@ function validateKey(apiKey) {
         throw invalid('fleets_setConnection', 'Foundry key must contain 1–4096 UTF-8 bytes without CR, LF or NUL.');
     }
 }
-/** Managed agent tasks, always scoped to the credential's verified organization. */
+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.');
+    }
+    if (body.memory !== undefined) {
+        if (!['minds', 'files', 'custom'].includes(body.memory.provider))
+            throw invalid('fleets_launchAgent', 'Memory provider must be minds, files, or custom.');
+        if (body.memory.provider === 'custom' && !body.memory.endpoint)
+            throw invalid('fleets_launchAgent', 'Custom memory requires an endpoint.');
+    }
+    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.');
+    }
+}
+/** 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 });
+            },
+        },
+        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) => {