@onesi/genesis 0.1.13 → 0.2.0

package/dist/iam.d.ts

@@ -0,0 +1,391 @@
+import type { GenesisClient } from './client.js';
+import type { OperationId } from './generated/operations.js';
+import type { OperationInput } from './types.js';
+type Body<K extends OperationId> = OperationInput<K> extends {
+    body?: infer B;
+} ? NonNullable<B> : never;
+type Query<K extends OperationId> = Omit<OperationInput<K>, 'body'>;
+/**
+ * IAM v4 tenant operations at /v1/iam/... (iam.l1fe.ai). Use a One account login or an organization API key with iam:read
+ * (reads) or iam:write (changes). The gateway exchanges either at Auth for a short-lived IAM token and forwards only that;
+ * IAM decides authority (owner or manager for most changes). `org_id` must be your own organization.
+ *
+ * Inviting members, changing member roles, removing members, Mind API keys and enterprise settings are not here: they stay
+ * with a person in the Console. Projects and workspaces are `genesis.projects` and `genesis.workspaces`.
+ */
+export declare function iamModule(client: GenesisClient): {
+    orgs: {
+        list: (query?: Query<"iam_listOrgs">) => Promise<{
+            items: import("./index.js").components["schemas"]["Iam.Organization"][];
+            next_cursor?: string | null;
+        }>;
+        get: (org_id: string) => Promise<{
+            id: string;
+            name: string;
+            slug: string;
+            owner_human_principal_id?: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            created_at: number;
+            role?: string;
+        }>;
+        update: (org_id: string, body: Body<"iam_updateOrg">) => Promise<{
+            id: string;
+            name: string;
+            slug: string;
+            owner_human_principal_id?: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            created_at: number;
+            role?: string;
+        }>;
+        members: (org_id: string, query?: Omit<Query<"iam_listMembers">, "org_id">) => Promise<{
+            items: import("./index.js").components["schemas"]["Iam.Member"][];
+            total?: number;
+            nextCursor?: string | null;
+            complete?: boolean;
+            canManageMembers?: boolean;
+        }>;
+        entitlements: (org_id: string, environment_id?: "live" | "sandbox") => Promise<{
+            items: import("./index.js").components["schemas"]["Iam.Entitlement"][];
+            next_cursor?: string | null;
+            snapshotVersion?: unknown;
+            snapshotGeneratedAt?: unknown;
+            snapshotValidUntil?: unknown;
+            environmentId?: string;
+        }>;
+    };
+    fleets: {
+        list: (org_id: string) => Promise<{
+            items: import("./index.js").components["schemas"]["Iam.Fleet"][];
+            next_cursor?: string | null;
+        }>;
+        get: (org_id: string, fleet_id: string) => Promise<{
+            id: string;
+            organizationId: string;
+            projectId?: string;
+            workspaceId?: string;
+            name: string;
+            slug: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            createdAt: number;
+            updatedAt: number;
+        }>;
+        /** Reuse the same idempotencyKey to replay an uncertain create instead of making a second fleet. */
+        create: (org_id: string, body: Body<"iam_createFleet">, idempotencyKey: string) => Promise<{
+            id: string;
+            organizationId: string;
+            projectId?: string;
+            workspaceId?: string;
+            name: string;
+            slug: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            createdAt: number;
+            updatedAt: number;
+        }>;
+        update: (org_id: string, fleet_id: string, body: Body<"iam_updateFleet">) => Promise<{
+            id: string;
+            organizationId: string;
+            projectId?: string;
+            workspaceId?: string;
+            name: string;
+            slug: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            createdAt: number;
+            updatedAt: number;
+        }>;
+        /** Permanent; IAM refuses while grants reference the fleet. */
+        delete: (org_id: string, fleet_id: string) => Promise<void>;
+    };
+    agents: {
+        list: (org_id: string) => Promise<{
+            items: import("./index.js").components["schemas"]["Iam.Agent"][];
+            next_cursor?: string | null;
+            agents?: import("./index.js").components["schemas"]["Iam.Agent"][];
+        }>;
+        get: (org_id: string, agent_did: string) => Promise<{
+            agent: import("./index.js").components["schemas"]["Iam.Agent"];
+        }>;
+        /** Without `publicKey` IAM generates a key pair and returns `privateKey` once. */
+        create: (org_id: string, body: Body<"iam_createAgent">) => Promise<{
+            agent: import("./index.js").components["schemas"]["Iam.Agent"];
+            did: string;
+            publicKey?: string | null;
+            privateKey?: string | null;
+        }>;
+        /** Revokes the agent (status `revoked`); the record stays. */
+        delete: (org_id: string, agent_did: string) => Promise<{
+            agent: import("./index.js").components["schemas"]["Iam.Agent"];
+        }>;
+        suspend: (org_id: string, agent_did: string) => Promise<{
+            agent: import("./index.js").components["schemas"]["Iam.Agent"];
+        }>;
+        resume: (org_id: string, agent_did: string) => Promise<{
+            agent: import("./index.js").components["schemas"]["Iam.Agent"];
+        }>;
+        rotate: (org_id: string, agent_did: string, body?: Body<"iam_rotateAgentKey">) => Promise<{
+            did: string;
+            publicKey?: string | null;
+            privateKey?: string | null;
+        }>;
+        acts: {
+            list: (org_id: string, agent_did: string) => Promise<{
+                acts: {
+                    [key: string]: unknown;
+                }[];
+            }>;
+            issue: (org_id: string, agent_did: string, body: Body<"iam_issueAgentAct">) => Promise<{
+                id: string;
+                act: string;
+                scopes: string[];
+                issuedAt: string;
+                expiresAt: string;
+                subjectDid: string;
+            }>;
+        };
+        publication: (org_id: string, agent_id: string) => Promise<{
+            agentId: string;
+            state: "private" | "published" | "withdrawn";
+            version: number;
+        }>;
+        orbitMsgsGrant: (org_id: string, agent_id: string) => Promise<{
+            schemaVersion?: number;
+            requestId?: string;
+            agentId: string;
+            organizationId: string;
+            profile?: string;
+            ownerGeneration?: number;
+            grant?: {
+                grantId?: string;
+                grantVersion?: number;
+                actions?: string[];
+                expiresAtMs?: number;
+                status?: "active" | "expired" | "revoked";
+            } | null;
+        }>;
+        /** A published agent's public card (anonymous). */
+        publicCard: (agent_id: string) => Promise<{
+            schemaVersion?: number;
+            principalId: string;
+            kind: string;
+            publicationVersion?: number;
+            canonicalAgentDid?: string;
+            handle?: string | null;
+            handleStatus?: string;
+            contact?: {
+                [key: string]: unknown;
+            };
+            operatingCompany?: Record<string, never> | null;
+        }>;
+        /** Agents enrolled for a Mind with a currently valid credential. */
+        forMind: (org_id: string, mind_id: string) => Promise<{
+            items: {
+                agent: import("./index.js").components["schemas"]["Iam.Agent"];
+                mindId: string;
+                scopes?: string[];
+                sharedNamespaces?: string[];
+                credentialExpiresAt?: number;
+            }[];
+        }>;
+        enrollmentGrants: (org_id: string) => Promise<{
+            items: import("./index.js").components["schemas"]["Iam.AgentEnrollmentGrant"][];
+        }>;
+        /**
+         * Enroll an agent under an agent enrollment grant. Only the grant's enrollment key (`mek_...`) is sent, as the bearer;
+         * this client's own Genesis credential is not. The credential secret in the answer is returned once.
+         */
+        enroll: (enrollmentKey: string, body: Body<"iam_enrollAgent">) => Promise<{
+            agent: {
+                id: string;
+                did: string;
+                displayName?: string;
+                status?: string;
+                organizationId: string;
+                projectId?: string;
+            };
+            created: boolean;
+            credential: {
+                id: string;
+                secret: string;
+                mindId?: string;
+                scopes?: string[];
+                sharedNamespaces?: string[];
+                expiresAt?: number;
+            };
+        }>;
+    };
+    roles: {
+        list: (org_id: string) => Promise<{
+            items: import("./index.js").components["schemas"]["Iam.Role"][];
+            next_cursor?: string | null;
+        }>;
+        get: (org_id: string, role_id: string) => Promise<{
+            id: string;
+            organization_id?: string;
+            name: string;
+            description?: string;
+            permissions: string[];
+            metadata?: {
+                [key: string]: unknown;
+            };
+        }>;
+        create: (org_id: string, body: Body<"iam_createRole">) => Promise<{
+            id: string;
+            organization_id?: string;
+            name: string;
+            description?: string;
+            permissions: string[];
+            metadata?: {
+                [key: string]: unknown;
+            };
+        }>;
+        update: (org_id: string, role_id: string, body: Body<"iam_updateRole">) => Promise<{
+            id: string;
+            organization_id?: string;
+            name: string;
+            description?: string;
+            permissions: string[];
+            metadata?: {
+                [key: string]: unknown;
+            };
+        }>;
+        delete: (org_id: string, role_id: string) => Promise<void>;
+    };
+    grants: {
+        list: (query?: Query<"iam_listGrants">) => Promise<{
+            items: import("./index.js").components["schemas"]["Iam.Grant"][];
+            next_cursor?: string | null;
+        }>;
+        get: (grant_id: string) => Promise<{
+            id: string;
+            principal_id: string;
+            organization_id: string;
+            project_id?: string;
+            platform_id?: string;
+            workspace_id?: string;
+            environmentId?: "live" | "sandbox";
+            role_ids: string[];
+            permissions?: string[];
+            expires_at?: number;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            created_at: number;
+        }>;
+        /** `organization_id` must be your organization. With an idempotencyKey a retry returns the original grant. */
+        create: (body: Body<"iam_createGrant">, idempotencyKey?: string) => Promise<{
+            id: string;
+            principal_id: string;
+            organization_id: string;
+            project_id?: string;
+            platform_id?: string;
+            workspace_id?: string;
+            environmentId?: "live" | "sandbox";
+            role_ids: string[];
+            permissions?: string[];
+            expires_at?: number;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            created_at: number;
+        }>;
+        update: (grant_id: string, body: Body<"iam_updateGrant">) => Promise<{
+            id: string;
+            principal_id: string;
+            organization_id: string;
+            project_id?: string;
+            platform_id?: string;
+            workspace_id?: string;
+            environmentId?: "live" | "sandbox";
+            role_ids: string[];
+            permissions?: string[];
+            expires_at?: number;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            created_at: number;
+        }>;
+        delete: (grant_id: string) => Promise<void>;
+    };
+    capabilities: {
+        get: (capability_id: string) => Promise<{
+            id: string;
+            issuer_principal_id: string;
+            subject_principal_id: string;
+            organization_id: string;
+            permissions: string[];
+            constraints: import("./index.js").components["schemas"]["Iam.CapabilityConstraints"];
+            created_at: number;
+            revoked_at?: number;
+            revoke_reason?: string;
+        }>;
+        /** You are always the issuer; `organization_id` must be your organization. */
+        create: (body: Body<"iam_createCapability">, idempotencyKey?: string) => Promise<{
+            id: string;
+            issuer_principal_id: string;
+            subject_principal_id: string;
+            organization_id: string;
+            permissions: string[];
+            constraints: import("./index.js").components["schemas"]["Iam.CapabilityConstraints"];
+            created_at: number;
+            revoked_at?: number;
+            revoke_reason?: string;
+        }>;
+        update: (capability_id: string, body: Body<"iam_updateCapability">) => Promise<{
+            id: string;
+            issuer_principal_id: string;
+            subject_principal_id: string;
+            organization_id: string;
+            permissions: string[];
+            constraints: import("./index.js").components["schemas"]["Iam.CapabilityConstraints"];
+            created_at: number;
+            revoked_at?: number;
+            revoke_reason?: string;
+        }>;
+        /** Revoke (issuer only), with an optional recorded reason. */
+        delete: (capability_id: string, reason?: string) => Promise<void>;
+        verify: (body: Body<"iam_verifyCapability">) => Promise<{
+            valid: boolean;
+            grant?: import("./index.js").components["schemas"]["Iam.Capability"];
+            reason_invalid?: "expired" | "revoked" | "scope_mismatch" | "tenant_mismatch" | "not_found";
+        }>;
+    };
+    platforms: () => Promise<{
+        items: import("./index.js").components["schemas"]["Iam.Platform"][];
+        next_cursor?: string | null;
+    }>;
+    tenantContext: () => Promise<{
+        tenant: import("./index.js").components["schemas"]["Iam.TenantContext"];
+    }>;
+    checkPermission: (body: Body<"iam_checkPermission">) => Promise<{
+        allowed: boolean;
+        evaluated_at?: number;
+        via?: string;
+        environmentId?: string;
+    }>;
+    requirePermission: (body: Body<"iam_requirePermission">) => Promise<{
+        allowed: boolean;
+        evaluated_at?: number;
+        via?: string;
+        environmentId?: string;
+    }>;
+    checkEntitlement: (body: Body<"iam_checkEntitlement">) => Promise<{
+        key: string;
+        organization_id: string;
+        enabled: boolean;
+        quota?: number | null;
+        remaining?: number | null;
+        evaluated_at?: number;
+        source?: string;
+        environmentId?: string;
+    }>;
+};
+export {};

package/dist/iam.js

@@ -0,0 +1,92 @@
+import { GenesisError } from './errors.js';
+import { idempotencyHeaders } from './idempotency.js';
+const key = (operationId, idempotencyKey) => ({ headers: idempotencyHeaders(operationId, idempotencyKey) });
+const ENROLLMENT_KEY = /^mek_[A-Za-z0-9_-]{16,512}$/;
+/**
+ * IAM v4 tenant operations at /v1/iam/... (iam.l1fe.ai). Use a One account login or an organization API key with iam:read
+ * (reads) or iam:write (changes). The gateway exchanges either at Auth for a short-lived IAM token and forwards only that;
+ * IAM decides authority (owner or manager for most changes). `org_id` must be your own organization.
+ *
+ * Inviting members, changing member roles, removing members, Mind API keys and enterprise settings are not here: they stay
+ * with a person in the Console. Projects and workspaces are `genesis.projects` and `genesis.workspaces`.
+ */
+export function iamModule(client) {
+    return {
+        orgs: {
+            list: (query = {}) => client.request('iam_listOrgs', query),
+            get: (org_id) => client.request('iam_getOrg', { org_id }),
+            update: (org_id, body) => client.request('iam_updateOrg', { org_id, body }),
+            members: (org_id, query = {}) => client.request('iam_listMembers', { org_id, ...query }),
+            entitlements: (org_id, environment_id) => client.request('iam_listEntitlements', { org_id, ...(environment_id ? { environment_id } : {}) }),
+        },
+        fleets: {
+            list: (org_id) => client.request('iam_listFleets', { org_id }),
+            get: (org_id, fleet_id) => client.request('iam_getFleet', { org_id, fleet_id }),
+            /** Reuse the same idempotencyKey to replay an uncertain create instead of making a second fleet. */
+            create: (org_id, body, idempotencyKey) => client.request('iam_createFleet', { org_id, body }, key('iam_createFleet', idempotencyKey)),
+            update: (org_id, fleet_id, body) => client.request('iam_updateFleet', { org_id, fleet_id, body }),
+            /** Permanent; IAM refuses while grants reference the fleet. */
+            delete: (org_id, fleet_id) => client.request('iam_deleteFleet', { org_id, fleet_id }),
+        },
+        agents: {
+            list: (org_id) => client.request('iam_listAgents', { org_id }),
+            get: (org_id, agent_did) => client.request('iam_getAgent', { org_id, agent_did }),
+            /** Without `publicKey` IAM generates a key pair and returns `privateKey` once. */
+            create: (org_id, body) => client.request('iam_createAgent', { org_id, body }),
+            /** Revokes the agent (status `revoked`); the record stays. */
+            delete: (org_id, agent_did) => client.request('iam_deleteAgent', { org_id, agent_did }),
+            suspend: (org_id, agent_did) => client.request('iam_suspendAgent', { org_id, agent_did }),
+            resume: (org_id, agent_did) => client.request('iam_resumeAgent', { org_id, agent_did }),
+            rotate: (org_id, agent_did, body = {}) => client.request('iam_rotateAgentKey', { org_id, agent_did, body }),
+            acts: {
+                list: (org_id, agent_did) => client.request('iam_listAgentActs', { org_id, agent_did }),
+                issue: (org_id, agent_did, body) => client.request('iam_issueAgentAct', { org_id, agent_did, body }),
+            },
+            publication: (org_id, agent_id) => client.request('iam_getAgentPublication', { org_id, agent_id }),
+            orbitMsgsGrant: (org_id, agent_id) => client.request('iam_getOrbitMsgsProductGrant', { org_id, agent_id }),
+            /** A published agent's public card (anonymous). */
+            publicCard: (agent_id) => client.request('iam_getPublicAgent', { agent_id }),
+            /** Agents enrolled for a Mind with a currently valid credential. */
+            forMind: (org_id, mind_id) => client.request('iam_listMindAgents', { org_id, mind_id }),
+            enrollmentGrants: (org_id) => client.request('iam_listAgentEnrollmentGrants', { org_id }),
+            /**
+             * Enroll an agent under an agent enrollment grant. Only the grant's enrollment key (`mek_...`) is sent, as the bearer;
+             * this client's own Genesis credential is not. The credential secret in the answer is returned once.
+             */
+            enroll: (enrollmentKey, body) => {
+                if (typeof enrollmentKey !== 'string' || !ENROLLMENT_KEY.test(enrollmentKey))
+                    throw new GenesisError({ status: 0, type: 'invalid_request', operationId: 'iam_enrollAgent', message: 'Agent enrollment needs the grant\'s enrollment key (mek_...).' });
+                return client.request('iam_enrollAgent', { body }, { headers: { authorization: `Bearer ${enrollmentKey}` } });
+            },
+        },
+        roles: {
+            list: (org_id) => client.request('iam_listRoles', { org_id }),
+            get: (org_id, role_id) => client.request('iam_getRole', { org_id, role_id }),
+            create: (org_id, body) => client.request('iam_createRole', { org_id, body }),
+            update: (org_id, role_id, body) => client.request('iam_updateRole', { org_id, role_id, body }),
+            delete: (org_id, role_id) => client.request('iam_deleteRole', { org_id, role_id }),
+        },
+        grants: {
+            list: (query = {}) => client.request('iam_listGrants', query),
+            get: (grant_id) => client.request('iam_getGrant', { grant_id }),
+            /** `organization_id` must be your organization. With an idempotencyKey a retry returns the original grant. */
+            create: (body, idempotencyKey) => client.request('iam_createGrant', { body }, key('iam_createGrant', idempotencyKey)),
+            update: (grant_id, body) => client.request('iam_updateGrant', { grant_id, body }),
+            delete: (grant_id) => client.request('iam_deleteGrant', { grant_id }),
+        },
+        capabilities: {
+            get: (capability_id) => client.request('iam_getCapability', { capability_id }),
+            /** You are always the issuer; `organization_id` must be your organization. */
+            create: (body, idempotencyKey) => client.request('iam_createCapability', { body }, key('iam_createCapability', idempotencyKey)),
+            update: (capability_id, body) => client.request('iam_updateCapability', { capability_id, body }),
+            /** Revoke (issuer only), with an optional recorded reason. */
+            delete: (capability_id, reason) => client.request('iam_deleteCapability', { capability_id, body: reason === undefined ? {} : { reason } }),
+            verify: (body) => client.request('iam_verifyCapability', { body }),
+        },
+        platforms: () => client.request('iam_listPlatforms'),
+        tenantContext: () => client.request('iam_getTenantContext'),
+        checkPermission: (body) => client.request('iam_checkPermission', { body }),
+        requirePermission: (body) => client.request('iam_requirePermission', { body }),
+        checkEntitlement: (body) => client.request('iam_checkEntitlement', { body }),
+    };
+}

package/dist/idempotency.d.ts

@@ -2,3 +2,6 @@ import { type OperationId } from './generated/operations.js';
 /** The Idempotency-Key header an operation's spec declares. A required key is refused locally when missing
  * or malformed, before any request is sent; reuse the same key to replay instead of acting twice. */
 export declare function idempotencyHeaders(operationId: OperationId, key: string | undefined): Record<string, string>;
+/** The If-Match header an operation's spec requires (Auto's optimistic concurrency): the resource `version`
+ * you read, or its ETag. A missing or malformed version is refused locally, before anything is sent. */
+export declare function ifMatchHeaders(operationId: OperationId, version: string | number | undefined): Record<string, string>;

package/dist/idempotency.js

@@ -2,6 +2,8 @@ import { GenesisError } from './errors.js';
 import { operationTable } from './generated/operations.js';
 const REQUIRED = /^[\x21-\x7e]{8,128}$/;
 const OPTIONAL = /^[\x21-\x7e]{1,256}$/;
+/** Auto's Idempotency-Key grammar (l1felabs/auto src/operating.ts IDEMPOTENCY_KEY). */
+const AUTO_KEY = /^[A-Za-z0-9_.:-]{8,128}$/;
 /** The Idempotency-Key header an operation's spec declares. A required key is refused locally when missing
  * or malformed, before any request is sent; reuse the same key to replay instead of acting twice. */
 export function idempotencyHeaders(operationId, key) {
@@ -13,5 +15,25 @@ export function idempotencyHeaders(operationId, key) {
             message: need === 'required' ? `${operationId} needs a stable idempotency key (8-128 printable ASCII characters)`
                 : need ? `${operationId} idempotency key must be 1-256 printable ASCII characters` : `${operationId} does not take an idempotency key` });
     }
+    // Auto takes 8-128 characters of [A-Za-z0-9_.:-] (its authority check); refuse anything it would 422 before sending.
+    if (operationTable[operationId].service === 'auto' && !AUTO_KEY.test(key)) {
+        throw new GenesisError({ status: 0, type: 'invalid_request', operationId,
+            message: `${operationId} idempotency key must be 8-128 characters of A-Z a-z 0-9 _ . : -` });
+    }
     return { 'idempotency-key': key };
 }
+/** The If-Match header an operation's spec requires (Auto's optimistic concurrency): the resource `version`
+ * you read, or its ETag. A missing or malformed version is refused locally, before anything is sent. */
+export function ifMatchHeaders(operationId, version) {
+    const need = operationTable[operationId].ifMatch;
+    if (!need) {
+        if (version === undefined)
+            return {};
+        throw new GenesisError({ status: 0, type: 'invalid_request', operationId, message: `${operationId} does not take If-Match` });
+    }
+    const v = typeof version === 'number' ? String(version) : version;
+    if (typeof v !== 'string' || !/^(?:W\/)?"?[1-9][0-9]{0,8}"?$/.test(v)) {
+        throw new GenesisError({ status: 0, type: 'invalid_request', operationId, message: `${operationId} needs the version you read (If-Match, e.g. 3)` });
+    }
+    return { 'if-match': `"${v.replace(/^W\//, '').replace(/"/g, '')}"` };
+}

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export { Genesis, type ChatMessage } from './genesis.js';
 export { GenesisClient, DEFAULT_BASE_URL, type GenesisOptions, type CredentialProvider } from './client.js';
+export { iamDirectoryOperations, isIamDirectoryOperation, iamDirectoryFailure } from './iam-directory.js';
+export { iamModule } from './iam.js';
 export { GenesisError, errorCatalog, errorToken, errorOutcome } from './errors.js';
 export { requireSecureUrl } from './urls.js';
 export { operationTable, services, type OperationId } from './generated/operations.js';
@@ -10,14 +12,23 @@ export { validateHivesInvocation, hivesFunctionResponseHeaders, HivesOperationEr
 export { hivesResponseBytes } from './hives-response.js';
 export { runnerModule, type RunnerStartInput, type RunnerSnapshot, type RunnerCatalog, type RunnerEvent, type RunnerProviderResult, type RunnerRequestOptions } from './runner.js';
 export type { RunnerSelfExecutionGrantInput, RunnerSelfExecutionGrant } from './runner-grant.js';
-export { beaconsModule } from './beacons.js';
+export { beaconsModule, BEACONS_RESOURCE_FAMILIES, BEACONS_CLIENT_PLATFORMS, type BeaconsResourceFamily } from './beacons.js';
+export type { BeaconsClientPlatform } from './beacons.js';
 export { rigsModule, panesModule, shellsModule } from './instances.js';
 export { gearsModule } from './gears.js';
+export { tapsModule } from './taps.js';
 export { lanesModule } from './lanes.js';
 export { flaresModule } from './flares.js';
-export { idempotencyHeaders } from './idempotency.js';
+export { idempotencyHeaders, ifMatchHeaders } from './idempotency.js';
+export type { FlocksWriteOptions, WaitForJobOptions, FlocksJob } from './flocks.js';
+export { autoModule } from './auto.js';
+export { gardenModule } from './garden.js';
+export { orgsEntitiesModule, type OrgsDocumentContent } from './orgs.js';
+export { scopesModule } from './scopes.js';
+export { billingModule, gatewayModule, orgsModule } from './gateway.js';
 export { dialsModule, dialsEmergencyAddressFeedback, type DialsEmergencyAddressFeedback, type DialsScope, type DialsOutboundCall, type DialsCallControl, type DialsEmergencyAddress, type DialsCallListItem, type DialsCallDispatchState, type DialsMessage, type DialsMessageTemplate, type DialsMessagingBrand, type DialsMessagingCampaign, type DialsWorkflowDocument, type DialsRoutingAction, type DialsRoutingRule, type DialsRoutingRuleReceipt, type DialsOutboundCallReceipt, type DialsRecoveredOutboundCallReceipt } from './dials.js';
 export { hivesObjectKey, type HivesBucket, type HivesObject, type HivesObjectAcknowledgement, type HivesObjectList, type HivesCorsRule, type HivesCreateBucket, type HivesPresign, type HivesPresignedUrl } from './hives-cells.js';
+export { hivesSseEvents, hivesSseReader, type HivesLogStreamEvent, type HivesLogStreamQuery, type HivesLogWindow, type HivesLogWindowOptions } from './hives-platform.js';
 export { hivesQueueBody, type HivesQueue, type HivesQueueConfig, type HivesQueueCreate, type HivesQueueSend, type HivesQueueDelivery, type HivesDeadLetter, type HivesDeadLetterStats } from './hives-queues.js';
 export type { HivesRuntime, HivesRuntimeSelection } from './hives-runtimes.js';
 export type { HivesVolume, HivesVolumeCreate, HivesVolumeMount, HivesVolumePage } from './hives-volumes.js';
@@ -26,8 +37,11 @@ export type { HivesMarketplacePackage, HivesMarketplaceVersion, HivesMarketplace
 export type { HivesQueueConsumerConfig, HivesQueueConsumerBinding, HivesQueueConsumerAttempt, HivesQueueConsumerStatus } from './hives-queue-consumer.js';
 export { foundryBillingOperations, isFoundryBillingOperation } from './foundry-billing.js';
 export type { HivesTopic, HivesTopicSubscription, HivesTopicPublish, HivesTopicPublication } from './hives-topics.js';
-export { mindsModule, mindsOperations, isMindsOperation, type MindsCreateOptions, type MindsResumeOptions, type MindsStopOptions, type MindsWakeReason, type MindsRequestOptions, type MindsUsage, type MindsEventInput } from './minds.js';
-export { MindsAgentError, mindsAgentOperations, isMindsAgentOperation, type MindsAgentOptions, type MindsAgentEventInput } from './minds-agent.js';
+export { mindsModule, mindsOperations, isMindsOperation, mindsServices, type MindsService, type MindsDeleteOptions, type MindsResizeOptions, type MindsCreateOptions, type MindsResumeOptions, type MindsStopOptions, type MindsWakeReason, type MindsRequestOptions, type MindsUsage, type MindsEventInput, type MindsWebhookDelivery, type MindsWebhookDeliveryReceipt } from './minds.js';
+export { MindsAgentError, mindsAgentOperations, isMindsAgentOperation, mindsAgentCreateOperations, isMindsAgentCreateOperation, type MindsAgentOptions, type MindsAgentEventInput, type MindsAgentCreateInput, type MindsAgentCreateOptions } from './minds-agent.js';
+export { mindsEngineModule, mindsEngineOperations, isMindsEngineOperation, mindsEngineCommands, type MindsEngineOperation, type MindsEngineOptions } from './minds-engine.js';
 export { MindsOwnerError, mindsOwnerOperations, isMindsOwnerOperation, type MindsOwnerOptions, type MindsOwnerVersion, type MindsAttachmentSubject, type MindsAttachInput } from './minds-owner.js';
 export { selectGenesisContext, checkedGenesisContextSession, type GenesisContextSelection, type GenesisContextSession } from './context.js';
 export { HivesQueueOperationError, hivesQueueOperationId, type HivesQueueOperation, type HivesQueueSendOptions } from './hives-queue-funding.js';
+export { foldHenryTurns, type HenryRun, type HenryRunEvent, type HenryRunEventMessage, type HenryRunStreamStatus, type HenryMessageDelivery, type HenryStreamEvent, type HenryStreamOptions, type HenryTurn, type HenryReplay } from './henry.js';
+export { hivesSseWindow, type HivesSseEvent, type HivesSseWindow, type HivesSseWindowOptions } from './hives-sse.js';

package/dist/index.js

@@ -1,5 +1,7 @@
 export { Genesis } from './genesis.js';
 export { GenesisClient, DEFAULT_BASE_URL } from './client.js';
+export { iamDirectoryOperations, isIamDirectoryOperation, iamDirectoryFailure } from './iam-directory.js';
+export { iamModule } from './iam.js';
 export { GenesisError, errorCatalog, errorToken, errorOutcome } from './errors.js';
 export { requireSecureUrl } from './urls.js';
 export { operationTable, services } from './generated/operations.js';
@@ -7,19 +9,29 @@ export { hivesUploadBody, MAX_WASM_BYTES } from './hives-upload.js';
 export { validateHivesInvocation, hivesFunctionResponseHeaders, HivesOperationError, MAX_FUNCTION_BODY_BYTES, MAX_FUNCTION_JSON_BYTES } from './hives-functions.js';
 export { hivesResponseBytes } from './hives-response.js';
 export { runnerModule } from './runner.js';
-export { beaconsModule } from './beacons.js';
+export { beaconsModule, BEACONS_RESOURCE_FAMILIES, BEACONS_CLIENT_PLATFORMS } from './beacons.js';
 export { rigsModule, panesModule, shellsModule } from './instances.js';
 export { gearsModule } from './gears.js';
+export { tapsModule } from './taps.js';
 export { lanesModule } from './lanes.js';
 export { flaresModule } from './flares.js';
-export { idempotencyHeaders } from './idempotency.js';
+export { idempotencyHeaders, ifMatchHeaders } from './idempotency.js';
+export { autoModule } from './auto.js';
+export { gardenModule } from './garden.js';
+export { orgsEntitiesModule } from './orgs.js';
+export { scopesModule } from './scopes.js';
+export { billingModule, gatewayModule, orgsModule } from './gateway.js';
 export { dialsModule, dialsEmergencyAddressFeedback } from './dials.js';
 export { hivesObjectKey } from './hives-cells.js';
+export { hivesSseEvents, hivesSseReader } from './hives-platform.js';
 export { hivesQueueBody } from './hives-queues.js';
 export { HIVES_OBJECT_BYTES, HIVES_QUEUE_BYTES } from './hives-resources-transport.js';
 export { foundryBillingOperations, isFoundryBillingOperation } from './foundry-billing.js';
-export { mindsModule, mindsOperations, isMindsOperation } from './minds.js';
-export { MindsAgentError, mindsAgentOperations, isMindsAgentOperation } from './minds-agent.js';
+export { mindsModule, mindsOperations, isMindsOperation, mindsServices } from './minds.js';
+export { MindsAgentError, mindsAgentOperations, isMindsAgentOperation, mindsAgentCreateOperations, isMindsAgentCreateOperation } from './minds-agent.js';
+export { mindsEngineModule, mindsEngineOperations, isMindsEngineOperation, mindsEngineCommands } from './minds-engine.js';
 export { MindsOwnerError, mindsOwnerOperations, isMindsOwnerOperation } from './minds-owner.js';
 export { selectGenesisContext, checkedGenesisContextSession } from './context.js';
 export { HivesQueueOperationError, hivesQueueOperationId } from './hives-queue-funding.js';
+export { foldHenryTurns } from './henry.js';
+export { hivesSseWindow } from './hives-sse.js';