@lifesi/genesis 0.1.0 → 0.1.2

package/dist/client.js

@@ -1,5 +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 {
@@ -59,20 +63,71 @@ export class GenesisClient {
     /** Call any Genesis operation by id, fully typed from the merged spec. */
     async request(operationId, input, init = {}) {
         const res = await this.raw(operationId, (input ?? {}), init);
+        if (operationTable[operationId].rawResponse)
+            return res;
         if (res.status === 204)
             return undefined;
         const ct = res.headers.get('content-type') ?? '';
-        return (ct.includes('json') ? await res.json() : await res.text());
+        let value;
+        try {
+            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;
+        }
+        if (operationId === 'hives_list_functions') {
+            if (!value || !Array.isArray(value.data) || !value.pagination)
+                throw new Error('Hives returned invalid function list metadata.');
+            const pagination = Object.fromEntries(['page', 'per_page', 'total', 'total_pages', 'has_next', 'has_prev'].map((key) => [key, value.pagination[key]]));
+            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);
+        }
+        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;
     }
-    /** Like request() but returns the raw Response (for streaming). Throws GenesisError on non-2xx. */
+    /** 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).
@@ -81,12 +136,91 @@ 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) {
-            headers['content-type'] = 'application/json';
-            body = JSON.stringify(input.body);
+            // 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 (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.' });
+                body = input.body;
+            }
+            else {
+                if (input.body instanceof FormData || input.body instanceof Blob || input.body instanceof ArrayBuffer || ArrayBuffer.isView(input.body)) {
+                    throw new GenesisError({ status: 0, type: 'invalid_request', operationId, message: 'This operation requires a JSON body.' });
+                }
+                headers['content-type'] = 'application/json';
+                body = JSON.stringify(input.body);
+            }
+        }
+        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' || 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.' });
+            if (!secretOperation)
+                throw error;
+            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) });
+        }
+        if (op.rawResponse && res.ok)
+            throw new GenesisError({ status: res.status, type: 'invalid_response', operationId,
+                message: 'Hives did not confirm a completed guest execution. Refresh the resource and retry.' });
+        if (functionOperation && !res.ok) {
+            const message = res.status === 401 ? 'Genesis credential rejected. Sign in again.'
+                : res.status === 403 ? 'Missing the authorized Hives scope for this function action.'
+                    : res.status === 404 ? 'Function/deployment, project or artifact not found in the authenticated organization and project.'
+                        : res.status === 409 ? 'Function mutation conflicted. Refresh its metadata before retrying.'
+                            : res.status === 400 || res.status === 422 ? 'Invalid function request. Check artifact, resource bounds and guest request syntax.'
+                                : res.status === 413 ? 'Function request exceeds a body or serialized guest envelope limit.'
+                                    : res.status >= 300 && res.status < 400 ? 'Unexpected function service redirect. No redirect was followed.'
+                                        : `Hives function operation failed (${res.status}). Refresh and retry.`;
+            throw new GenesisError({ status: res.status, type: `http_${res.status}`, operationId, message,
+                requestId: res.headers.get('x-request-id') ?? undefined });
+        }
+        if (!res.ok && secretOperation) {
+            const message = res.status === 401 ? 'Genesis credential rejected. Sign in again.'
+                : res.status === 403 ? 'Missing the authorized Hives scope for this action (hives:read or hives:write).'
+                    : res.status === 404 ? 'Secret or project not found in your authenticated organization.'
+                        : res.status === 409 ? 'A secret with this name already exists. Update it instead.'
+                            : res.status === 400 || res.status === 422 ? 'Invalid secret request. Check names and UTF-8 value size.'
+                                : res.status === 413 ? 'Secret request too large. Use a smaller batch.'
+                                    : res.status === 429 ? 'Too many requests. Wait briefly before retrying.'
+                                        : res.status === 503 ? 'Hives customer encryption is unavailable or stored secrets require protected migration.'
+                                            : `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: environmentOperation ? undefined : res.headers.get('x-request-id') ?? undefined });
+        }
+        if (!res.ok && isHivesResourceOperation(operationId)) {
+            await res.body?.cancel().catch(() => { });
+            throw resourceError(res.status, operationId);
         }
-        const res = await this.fetchImpl(url, { method: op.method, headers, body, signal: init.signal });
         if (!res.ok)
             throw await GenesisError.fromResponse(res, operationId);
         return res;

package/dist/dials.d.ts

@@ -5,19 +5,236 @@ 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;
+            scope: components["schemas"]["Dials.Scope"];
+            calls: {
+                total: number;
+                queued: number;
+                active: number;
+                completed: number;
+                failed: number;
+            };
+            dispatch: {
+                total: number;
+                pending: number;
+                claimed: number;
+                dispatched: number;
+                failed: number;
+            };
+            people: {
+                deployed: number;
+            };
+            agents: {
+                deployed: number;
+            };
+            routes: {
+                deployed: number;
+            };
+            numbers: {
+                deployed: number;
+            };
+            voice: {
+                deployed: number;
+            };
+            messages: {
+                total: number;
+                queued: number;
+                delivered: number;
+                failed: number;
+            };
+            usage: {
+                total: number;
+                quantity: number;
+                lastMetric: string | null;
+                lastResourceId: string | null;
+            };
+        }>;
+        operatingSurface: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            scope: components["schemas"]["Dials.Scope"];
+            summary: components["schemas"]["Dials.ConsoleSummary"];
+            surfaces: components["schemas"]["Dials.OperatingSurfaceCard"][];
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
     numbers: {
+        reconciliations: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            reconciliations: components["schemas"]["Dials.InventoryReconciliation"][];
+        }>;
+        drift: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            drift: components["schemas"]["Dials.InventoryDrift"][];
+        }>;
+        updateCallerName: (body: OperationInput<"dials_updateNumberCallerName">["body"]) => Promise<{
+            ok: boolean;
+            number: components["schemas"]["Dials.Number"];
+            auditId: string;
+            next: string;
+        }>;
+        reconcile: (body: OperationInput<"dials_reconcileNumberInventory">["body"]) => Promise<{
+            ok: boolean;
+            reconciliations: components["schemas"]["Dials.InventoryReconciliation"][];
+            drift: components["schemas"]["Dials.InventoryDrift"][];
+            orphanCount: number;
+            auditId: string;
+            next: string;
+        }>;
         list: (scope: DialsScope) => Promise<{
             ok: boolean;
             numbers: components["schemas"]["Dials.Number"][];
         }>;
-        search: (scope: DialsScope, query?: {
-            areaCode?: string;
-            limit?: number;
-        }) => Promise<{
-            [key: string]: unknown;
+        search: (scope: DialsScope, query?: Omit<OperationInput<"dials_searchNumbers">, keyof DialsScope>) => Promise<{
+            ok: boolean;
+            numbers: components["schemas"]["Dials.AvailableNumber"][];
         }>;
         provision: (body: OperationInput<"dials_provisionNumber">["body"]) => Promise<{
             [key: string]: unknown;
@@ -25,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;
         }>;
@@ -39,13 +263,37 @@ 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'];
+/** Read bounded, typed advisory feedback from the existing Genesis error. Never auto-apply it. */
+export declare function dialsEmergencyAddressFeedback(error: unknown): DialsEmergencyAddressFeedback | undefined;

package/dist/dials.js

@@ -1,11 +1,59 @@
+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),
+        },
         numbers: {
+            reconciliations: (scope) => client.request('dials_listNumberReconciliations', scope),
+            drift: (scope) => client.request('dials_listNumberDrift', scope),
+            updateCallerName: (body) => client.request('dials_updateNumberCallerName', { body }),
+            reconcile: (body) => client.request('dials_reconcileNumberInventory', { body }),
             list: (scope) => client.request('dials_listNumbers', scope),
-            search: (scope, query = {}) => client.request('dials_searchNumbers', { ...scope, ...query }),
+            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 }),
         },
@@ -13,6 +61,39 @@ 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 }),
         },
     };
 }
+const fields = { streetNumber: 'Review the street number.', streetName: 'Review the street name.', addressLine2: 'Review the suite or unit type and number.', city: 'Review the city.', region: 'Review the state.', postalCode: 'Review the postal code.', country: 'Review the country.', address: 'The carrier could not validate this address. Review the address and any suggestions.' };
+const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const addressText = (value, max) => typeof value === 'string' && value.length > 0 && value.length <= max && /^[\p{L}\p{N} .,'#/-]+$/u.test(value) && !/(bearer|basic |sk_|api_key|authorization|secret|token=)/i.test(value);
+/** Read bounded, typed advisory feedback from the existing Genesis error. Never auto-apply it. */
+export function dialsEmergencyAddressFeedback(error) {
+    if (!(error instanceof GenesisError) || error.status !== 422 || error.operationId !== 'dials_registerEmergencyAddress')
+        return;
+    const body = error.body;
+    if (!object(body) || body.error !== 'carrier_rejected' || body.automaticCorrection !== false || !Array.isArray(body.fieldErrors) || !body.fieldErrors.length || body.fieldErrors.length > 8 || !Array.isArray(body.candidates) || body.candidates.length > 5)
+        return;
+    const fieldErrors = [];
+    for (const value of body.fieldErrors) {
+        if (!object(value) || typeof value.field !== 'string' || !Object.hasOwn(fields, value.field) || !['required', 'invalid', 'not_found', 'ambiguous', 'not_validated'].includes(String(value.code)))
+            return;
+        const field = value.field;
+        fieldErrors.push({ field, code: value.code, message: fields[field] });
+    }
+    const candidates = [];
+    for (const value of body.candidates) {
+        if (!object(value) || !addressText(value.streetNumber, 32) || !addressText(value.streetName, 128) || !addressText(value.city, 80) || typeof value.region !== 'string' || !/^[A-Za-z]{2}$/.test(value.region) || typeof value.postalCode !== 'string' || !/^\d{5}(?:-\d{4})?$/.test(value.postalCode))
+            return;
+        const extra = {};
+        if (value.addressType !== undefined || value.addressNumber !== undefined) {
+            if (!['Apartment', 'Basement', 'Building', 'Department', 'Floor', 'Office', 'Penthouse', 'Suite', 'Trailer', 'Unit'].includes(String(value.addressType)) || !addressText(value.addressNumber, 32))
+                return;
+            extra.addressType = value.addressType;
+            extra.addressNumber = value.addressNumber;
+        }
+        candidates.push({ streetNumber: value.streetNumber, streetName: value.streetName, city: value.city, region: value.region, postalCode: value.postalCode, ...extra });
+    }
+    return { automaticCorrection: false, fieldErrors, candidates };
+}

package/dist/fleets.d.ts

@@ -1,8 +1,60 @@
 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. */
+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): {
+    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;