@onesi/genesis 0.0.1-stage → 0.2.0

package/dist/minds.d.ts

@@ -0,0 +1,377 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput, OperationOutput } from './types.js';
+export declare const mindsOperations: readonly ["minds_listMinds", "minds_getMind", "minds_getUsage", "minds_createMind", "minds_resumeMind", "minds_stopMind", "minds_deleteMind", "minds_resizeMind", "minds_insertEpisodicMemory", "minds_getEpisodicMemory", "minds_updateEpisodicMemory", "minds_searchMemory", "minds_createWebhookDelivery", "minds_getWebhookDelivery"];
+/** Engine service groups a create may choose (the controller's CREATE_SERVICES); kv and memory always run. */
+export declare const mindsServices: readonly ["kv", "memory", "graph", "analytics", "ml", "inference", "vector", "snn", "continual", "associative-memory", "cognitive", "cognitive-cycle", "mcp"];
+export type MindsService = typeof mindsServices[number];
+export declare const isMindsOperation: (id: string) => boolean;
+export type MindsEventInput = OperationInput<'minds_insertEpisodicMemory'>['body']['event'];
+export type MindsUsage = OperationOutput<'minds_getUsage'>;
+export type MindsWebhookDelivery = OperationInput<'minds_createWebhookDelivery'>['body'];
+export type MindsWebhookDeliveryReceipt = OperationOutput<'minds_getWebhookDelivery'>;
+export interface MindsRequestOptions {
+    signal?: AbortSignal;
+}
+export type MindsWakeReason = 'manual' | 'scheduled_job' | 'webhook' | 'memory_consolidation' | 'activity';
+export interface MindsResumeOptions extends MindsRequestOptions {
+    idempotencyKey: string;
+    wakeReason?: MindsWakeReason;
+}
+export interface MindsStopOptions extends MindsRequestOptions {
+    idempotencyKey: string;
+}
+export type MindsDeleteOptions = MindsStopOptions;
+export type MindsResizeOptions = MindsStopOptions;
+export interface MindsCreateOptions extends MindsRequestOptions {
+    idempotencyKey: string;
+    contextSha256: string;
+    plan?: 'free' | 'pro';
+    profileId?: 'F1' | 'D1' | 'D2';
+    services?: MindsService[];
+}
+/** One dispatch only. Creation retains its operation key; episodic insertion returns a storage UUID distinct from event.id. */
+export declare function mindsTransport(options: {
+    operationId: string;
+    input: Record<string, unknown>;
+    headers?: Record<string, string>;
+    routing: string;
+    url: string;
+    credential: () => Promise<string | undefined>;
+    fetch: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<Response>;
+export declare function mindsModule(client: GenesisClient): {
+    agent: {
+        create: (input: import("./minds-agent.js").MindsAgentCreateInput, options: import("./minds-agent.js").MindsAgentCreateOptions) => Promise<{
+            mind_id: string;
+            status: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        createStatus: (operation_id: string, options: import("./minds-agent.js").MindsAgentCreateOptions) => Promise<{
+            mind_id: string;
+            status: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        memory: {
+            insert: (mind: string, event: import("./minds-agent.js").MindsAgentEventInput, options?: import("./minds-agent.js").MindsAgentOptions) => Promise<{
+                id: string;
+            }>;
+            get: (mind: string, storage_id: string, options?: import("./minds-agent.js").MindsAgentOptions) => Promise<{
+                item: import("./index.js").components["schemas"]["Minds.EpisodicEvent"] | null;
+            }>;
+            search: (mind: string, text: string, limit?: number, options?: import("./minds-agent.js").MindsAgentOptions) => Promise<({
+                id: string;
+                content: string;
+                timestamp: string;
+                event_type: "Conversation" | "Command" | "Query" | "Document" | "Error" | "Success" | "Learning" | "Decision" | "Action" | "Context" | "Knowledge";
+                summary?: string | null;
+                tags: string[];
+            } & {
+                [key: string]: unknown;
+            })[]>;
+        };
+    };
+    list: (query?: OperationInput<"minds_listMinds">, options?: MindsRequestOptions) => Promise<{
+        schema_version: "minds.controller.v1";
+        items: import("./index.js").components["schemas"]["Minds.Mind"][];
+        next_cursor: string | null;
+        context_sha256: string;
+    }>;
+    get: (mind_id: string, options?: MindsRequestOptions) => Promise<{
+        schema_version: "minds.controller.v1";
+        mind_id: string;
+        organization_id: string;
+        project_id: string;
+        name: string;
+        region: string;
+        plan: "free" | "pro";
+        capacity: import("./index.js").components["schemas"]["Minds.Capacity"];
+        observed_capacity: import("./index.js").components["schemas"]["Minds.Capacity"] | null;
+        services: string[];
+        volume_id: string;
+        base_url: string;
+        desired_state: "running" | "stopped" | "deleted";
+        observed_state: "pending" | "running" | "stopped" | "deleted" | "failed" | "uncertain";
+        desired_generation: number;
+        observed_generation: number;
+        status: "ready" | "provisioning" | "stopped" | "deleted" | "failed" | "uncertain";
+        capacity_applied: boolean;
+        operation_id: string | null;
+        error_code: string | null;
+        created_at: string;
+        updated_at: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    usage: (window: OperationInput<"minds_getUsage">, options?: MindsRequestOptions) => Promise<{
+        schema_version: "minds.controller.v1";
+        organization_id: string;
+        project_id: string;
+        from: string;
+        to: string;
+        measured_at: string;
+        basis: "host_confirmed_intervals";
+        minds: import("./index.js").components["schemas"]["Minds.UsageMind"][];
+    }>;
+    create: (name: string, options: MindsCreateOptions) => Promise<{
+        schema_version: "minds.controller.v1";
+        mind_id: string;
+        organization_id: string;
+        project_id: string;
+        name: string;
+        region: string;
+        plan: "free" | "pro";
+        capacity: import("./index.js").components["schemas"]["Minds.Capacity"];
+        observed_capacity: import("./index.js").components["schemas"]["Minds.Capacity"] | null;
+        services: string[];
+        volume_id: string;
+        base_url: string;
+        desired_state: "running" | "stopped" | "deleted";
+        observed_state: "pending" | "running" | "stopped" | "deleted" | "failed" | "uncertain";
+        desired_generation: number;
+        observed_generation: number;
+        status: "ready" | "provisioning" | "stopped" | "deleted" | "failed" | "uncertain";
+        capacity_applied: boolean;
+        operation_id: string | null;
+        error_code: string | null;
+        created_at: string;
+        updated_at: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    resume: (mind_id: string, expected_generation: number, options: MindsResumeOptions) => Promise<{
+        schema_version: "minds.controller.v1";
+        mind_id: string;
+        organization_id: string;
+        project_id: string;
+        name: string;
+        region: string;
+        plan: "free" | "pro";
+        capacity: import("./index.js").components["schemas"]["Minds.Capacity"];
+        observed_capacity: import("./index.js").components["schemas"]["Minds.Capacity"] | null;
+        services: string[];
+        volume_id: string;
+        base_url: string;
+        desired_state: "running" | "stopped" | "deleted";
+        observed_state: "pending" | "running" | "stopped" | "deleted" | "failed" | "uncertain";
+        desired_generation: number;
+        observed_generation: number;
+        status: "ready" | "provisioning" | "stopped" | "deleted" | "failed" | "uncertain";
+        capacity_applied: boolean;
+        operation_id: string | null;
+        error_code: string | null;
+        created_at: string;
+        updated_at: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    stop: (mind_id: string, expected_generation: number, options: MindsStopOptions) => Promise<{
+        schema_version: "minds.controller.v1";
+        mind_id: string;
+        organization_id: string;
+        project_id: string;
+        name: string;
+        region: string;
+        plan: "free" | "pro";
+        capacity: import("./index.js").components["schemas"]["Minds.Capacity"];
+        observed_capacity: import("./index.js").components["schemas"]["Minds.Capacity"] | null;
+        services: string[];
+        volume_id: string;
+        base_url: string;
+        desired_state: "running" | "stopped" | "deleted";
+        observed_state: "pending" | "running" | "stopped" | "deleted" | "failed" | "uncertain";
+        desired_generation: number;
+        observed_generation: number;
+        status: "ready" | "provisioning" | "stopped" | "deleted" | "failed" | "uncertain";
+        capacity_applied: boolean;
+        operation_id: string | null;
+        error_code: string | null;
+        created_at: string;
+        updated_at: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    /** Deletes the Mind (controller lifecycle delete): human delete permission, or an org API key with minds:write. */
+    delete: (mind_id: string, expected_generation: number, options: MindsDeleteOptions) => Promise<{
+        schema_version: "minds.controller.v1";
+        mind_id: string;
+        organization_id: string;
+        project_id: string;
+        name: string;
+        region: string;
+        plan: "free" | "pro";
+        capacity: import("./index.js").components["schemas"]["Minds.Capacity"];
+        observed_capacity: import("./index.js").components["schemas"]["Minds.Capacity"] | null;
+        services: string[];
+        volume_id: string;
+        base_url: string;
+        desired_state: "running" | "stopped" | "deleted";
+        observed_state: "pending" | "running" | "stopped" | "deleted" | "failed" | "uncertain";
+        desired_generation: number;
+        observed_generation: number;
+        status: "ready" | "provisioning" | "stopped" | "deleted" | "failed" | "uncertain";
+        capacity_applied: boolean;
+        operation_id: string | null;
+        error_code: string | null;
+        created_at: string;
+        updated_at: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    /** Resizes to an existing Pro profile (F1/D1/D2): human manage permission, or an org API key with minds:manage. */
+    resize: (mind_id: string, expected_generation: number, profile_id: "F1" | "D1" | "D2", options: MindsResizeOptions) => Promise<{
+        schema_version: "minds.controller.v1";
+        mind_id: string;
+        organization_id: string;
+        project_id: string;
+        name: string;
+        region: string;
+        plan: "free" | "pro";
+        capacity: import("./index.js").components["schemas"]["Minds.Capacity"];
+        observed_capacity: import("./index.js").components["schemas"]["Minds.Capacity"] | null;
+        services: string[];
+        volume_id: string;
+        base_url: string;
+        desired_state: "running" | "stopped" | "deleted";
+        observed_state: "pending" | "running" | "stopped" | "deleted" | "failed" | "uncertain";
+        desired_generation: number;
+        observed_generation: number;
+        status: "ready" | "provisioning" | "stopped" | "deleted" | "failed" | "uncertain";
+        capacity_applied: boolean;
+        operation_id: string | null;
+        error_code: string | null;
+        created_at: string;
+        updated_at: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    webhookDeliveries: {
+        create: (mind_id: string, delivery: MindsWebhookDelivery, options?: MindsRequestOptions) => Promise<{
+            schema_version: "minds.webhook-delivery.v1";
+            delivery_id: string;
+            mind_id: string;
+            organization_id: string;
+            project_id: string;
+            issuer_principal_id: string;
+            event_reference: string;
+            event_sha256: string;
+            received_at: string;
+            outcome: "wake_queued" | "activity_recorded" | "ignored";
+            reason: "deleted" | "user_stopped" | "operation_in_flight" | "not_ready" | null;
+            operation_id: string | null;
+            generation: number;
+            wake_reason: "webhook";
+        }>;
+        get: (mind_id: string, delivery_id: string, options?: MindsRequestOptions) => Promise<{
+            schema_version: "minds.webhook-delivery.v1";
+            delivery_id: string;
+            mind_id: string;
+            organization_id: string;
+            project_id: string;
+            issuer_principal_id: string;
+            event_reference: string;
+            event_sha256: string;
+            received_at: string;
+            outcome: "wake_queued" | "activity_recorded" | "ignored";
+            reason: "deleted" | "user_stopped" | "operation_in_flight" | "not_ready" | null;
+            operation_id: string | null;
+            generation: number;
+            wake_reason: "webhook";
+        }>;
+    };
+    memory: {
+        insert: (mind: string, event: MindsEventInput, options?: MindsRequestOptions) => Promise<{
+            id: string;
+        }>;
+        get: (mind: string, storage_id: string, options?: MindsRequestOptions) => Promise<{
+            item: import("./index.js").components["schemas"]["Minds.EpisodicEvent"] | null;
+        }>;
+        update: (mind: string, storage_id: string, body: {
+            event_id: string;
+            content: string;
+        }, options?: MindsRequestOptions) => Promise<{
+            ok: true;
+        }>;
+        search: (mind: string, text: string, limit?: number, options?: MindsRequestOptions) => Promise<({
+            id: string;
+            content: string;
+            timestamp: string;
+            event_type: "Conversation" | "Command" | "Query" | "Document" | "Error" | "Success" | "Learning" | "Decision" | "Action" | "Context" | "Knowledge";
+            summary?: string | null;
+            tags: string[];
+        } & {
+            [key: string]: unknown;
+        })[]>;
+    };
+    groups: {
+        list: (options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+            groups: import("./index.js").components["schemas"]["Minds.OwnerAgentGroup"][];
+        }>;
+        create: (body: {
+            operationId: string;
+            name: string;
+        }, options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+            id: string;
+            organizationId: string;
+            ownerId: string;
+            organizationGeneration: number;
+            name: string;
+            version: number;
+            revokedAt: number | null;
+        }>;
+        members: {
+            list: (group_id: string, options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+                members: import("./index.js").components["schemas"]["Minds.OwnerAgentGroupMember"][];
+            }>;
+            add: (group_id: string, body: import("./minds-owner.js").MindsOwnerVersion & {
+                agentId: string;
+            }, options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+                groupId: string;
+                agentId: string;
+                agentDid: string;
+                agentCreatedAt: number;
+                version: number;
+                revokedAt: number | null;
+            }>;
+            remove: (group_id: string, agent_id: string, body: import("./minds-owner.js").MindsOwnerVersion, options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+                groupId: string;
+                agentId: string;
+                agentDid: string;
+                agentCreatedAt: number;
+                version: number;
+                revokedAt: number | null;
+            }>;
+        };
+    };
+    attachments: {
+        list: (mind_id: string, options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+            attachments: import("./index.js").components["schemas"]["Minds.MindAttachment"][];
+        }>;
+        attach: (mind_id: string, body: import("./minds-owner.js").MindsAttachInput, options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+            id: string;
+            version: number;
+            organizationId: string;
+            projectId: string;
+            mindId: string;
+            subject: import("./index.js").components["schemas"]["Minds.MindAttachmentSubject"];
+            permissions: ["minds.agent_data.read"] | ["minds.agent_data.read", "minds.agent_data.write"];
+            sharedNamespace: string | null;
+            expiresAt: number;
+            revokedAt: number | null;
+        }>;
+        detach: (mind_id: string, attachment_id: string, body: import("./minds-owner.js").MindsOwnerVersion, options?: import("./minds-owner.js").MindsOwnerOptions) => Promise<{
+            id: string;
+            version: number;
+            organizationId: string;
+            projectId: string;
+            mindId: string;
+            subject: import("./index.js").components["schemas"]["Minds.MindAttachmentSubject"];
+            permissions: ["minds.agent_data.read"] | ["minds.agent_data.read", "minds.agent_data.write"];
+            sharedNamespace: string | null;
+            expiresAt: number;
+            revokedAt: number | null;
+        }>;
+    };
+};

package/dist/minds.js

@@ -0,0 +1,228 @@
+import { GenesisError } from './errors.js';
+import { mindsAgentModule } from './minds-agent.js';
+import { mindsOwnerModule } from './minds-owner.js';
+export const mindsOperations = ['minds_listMinds', 'minds_getMind', 'minds_getUsage', 'minds_createMind', 'minds_resumeMind', 'minds_stopMind', 'minds_deleteMind', 'minds_resizeMind', 'minds_insertEpisodicMemory', 'minds_getEpisodicMemory', 'minds_updateEpisodicMemory', 'minds_searchMemory', 'minds_createWebhookDelivery', 'minds_getWebhookDelivery'];
+/** Engine service groups a create may choose (the controller's CREATE_SERVICES); kv and memory always run. */
+export const mindsServices = ['kv', 'memory', 'graph', 'analytics', 'ml', 'inference', 'vector', 'snn', 'continual', 'associative-memory', 'cognitive', 'cognitive-cycle', 'mcp'];
+export const isMindsOperation = (id) => mindsOperations.includes(id);
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const uuid4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const lifecycle = ['minds_resumeMind', 'minds_stopMind', 'minds_deleteMind', 'minds_resizeMind'];
+const writes = new Set(['minds_createMind', 'minds_resumeMind', 'minds_stopMind', 'minds_deleteMind', 'minds_resizeMind', 'minds_insertEpisodicMemory', 'minds_updateEpisodicMemory', 'minds_createWebhookDelivery']);
+const nilUuid = '00000000-0000-0000-0000-000000000000';
+// Match the native gateway's RFC3339/calendar and nanosecond window bounds.
+function usageInstant(value) {
+    if (typeof value !== 'string' || value.length > 40)
+        return undefined;
+    const match = /^(\d{4})-(\d\d)-(\d\d)[Tt](\d\d):(\d\d):(\d\d)(?:\.(\d{1,9}))?([Zz]|([+-])(\d\d):(\d\d))$/.exec(value);
+    if (!match)
+        return undefined;
+    const [, year, month, day, hour, minute, second, fraction, zone, sign, offsetHour, offsetMinute] = match;
+    const [y, mo, d, h, mi, s] = [year, month, day, hour, minute, second].map(Number);
+    if (mo < 1 || mo > 12 || d < 1 || d > 31 || h > 23 || mi > 59 || s > 59
+        || (zone.toUpperCase() !== 'Z' && (Number(offsetHour) > 23 || Number(offsetMinute) > 59)))
+        return undefined;
+    const parsed = new Date(0);
+    parsed.setUTCFullYear(y, mo - 1, d);
+    parsed.setUTCHours(h, mi, s, 0);
+    if (parsed.getUTCFullYear() !== y || parsed.getUTCMonth() !== mo - 1 || parsed.getUTCDate() !== d)
+        return undefined;
+    const offset = zone.toUpperCase() === 'Z' ? 0 : (Number(offsetHour) * 60 + Number(offsetMinute)) * (sign === '+' ? 1 : -1);
+    return BigInt(parsed.getTime() - offset * 60_000) * 1000000n + BigInt((fraction ?? '').padEnd(9, '0'));
+}
+/** One dispatch only. Creation retains its operation key; episodic insertion returns a storage UUID distinct from event.id. */
+export async function mindsTransport(options) {
+    const id = options.operationId, input = options.input, write = writes.has(id);
+    let dispatchAttempted = false;
+    const error = (status, type, code, unknownOutcome = false) => new GenesisError({ status, type, code, operationId: id,
+        message: status === 403 ? code === 'HUMAN_SANDBOX_SELECTION_REQUIRED'
+            ? 'HUMAN_SANDBOX_SELECTION_REQUIRED: Minds accepts an original human One account session with a Console Sandbox selection, or organization API keys with a selected (bound) context; M2M tokens are refused.'
+            : code === 'SCOPE_MISSING' ? 'SCOPE_MISSING: this organization API key lacks the Minds scope the operation needs (minds:read, minds:write or minds:manage; minds:manage does not imply read).'
+                : 'Minds requires an admitted original human One account session with a Console Sandbox selection, or an organization API key with the operation\'s Minds scope.'
+            : write ? 'Minds write was not confirmed. Preserve the lifecycle/create key or delivery_id, or reconcile memory, before an explicit retry.' : 'Minds request was not confirmed.',
+        ...(write && (unknownOutcome || dispatchAttempted && (status === 0 || status >= 500 || type === 'invalid_response')) ? { body: { outcome: 'unknown' } } : {}) });
+    const fields = id === 'minds_getUsage' ? ['from', 'to'] : id === 'minds_listMinds' ? ['after', 'limit'] : id === 'minds_getMind' ? ['mind_id'] : id === 'minds_updateEpisodicMemory' ? ['mind', 'storage_id', 'body'] : ['minds_resumeMind', 'minds_stopMind', 'minds_resizeMind'].includes(id) ? ['mind_id', 'body']
+        : id === 'minds_deleteMind' ? ['mind_id', 'expected_generation']
+            : id === 'minds_createMind' ? ['body'] : id === 'minds_getEpisodicMemory' ? ['mind', 'storage_id'] : id === 'minds_createWebhookDelivery' ? ['mind_id', 'body']
+                : id === 'minds_getWebhookDelivery' ? ['mind_id', 'delivery_id'] : ['mind', 'body'];
+    if (options.routing !== 'gateway' || !isMindsOperation(id) || Object.keys(input).some(key => !fields.includes(key)))
+        throw error(0, 'invalid_request');
+    if (id === 'minds_getUsage') {
+        const from = usageInstant(input.from), to = usageInstant(input.to);
+        if (from === undefined || to === undefined || to <= from || to - from > 93n * 86400n * 1000000000n)
+            throw error(0, 'invalid_request');
+    }
+    for (const key of ['mind', 'mind_id', 'storage_id', 'after', 'delivery_id'])
+        if (input[key] !== undefined && (typeof input[key] !== 'string' || !uuid.test(input[key])))
+            throw error(0, 'invalid_request');
+    if (id === 'minds_updateEpisodicMemory') {
+        const body = input.body;
+        if (typeof input.mind !== 'string' || input.mind.length !== 36 || typeof input.storage_id !== 'string' || input.storage_id.length !== 36
+            || !body || typeof body !== 'object' || Array.isArray(body) || Object.keys(body).sort().join() !== 'content,event_id'
+            || typeof body.event_id !== 'string' || body.event_id.length !== 36 || !uuid.test(body.event_id)
+            || typeof body.content !== 'string' || !body.content.trim() || body.content.length > 16_000)
+            throw error(0, 'invalid_request');
+    }
+    if (id === 'minds_createWebhookDelivery' || id === 'minds_getWebhookDelivery') {
+        const body = input.body;
+        if (input.mind_id === nilUuid || input.delivery_id === nilUuid || (id === 'minds_getWebhookDelivery' ? typeof input.delivery_id !== 'string'
+            : !body || typeof body !== 'object' || Array.isArray(body) || Object.keys(body).sort().join() !== 'delivery_id,event_reference,event_sha256'
+                || typeof body.delivery_id !== 'string' || !uuid.test(body.delivery_id) || body.delivery_id === nilUuid
+                || typeof body.event_reference !== 'string' || body.event_reference.length > 200 || !/^[A-Za-z0-9_.:/-]+$/.test(body.event_reference)
+                || typeof body.event_sha256 !== 'string' || !/^[0-9a-f]{64}$/.test(body.event_sha256)))
+            throw error(0, 'invalid_request');
+    }
+    if (id === 'minds_createMind') {
+        const body = input.body;
+        if (!uuid4.test(options.headers?.['idempotency-key'] ?? '') || !/^[a-f0-9]{64}$/.test(options.headers?.['x-genesis-minds-creation-context'] ?? '')
+            || !body || typeof body !== 'object' || Array.isArray(body) || typeof body.name !== 'string'
+            || Object.keys(body).some(key => !['name', 'plan', 'profile_id', 'services'].includes(key))
+            || (body.services !== undefined && (!Array.isArray(body.services) || new Set(body.services).size !== body.services.length
+                || body.services.some(service => !mindsServices.includes(service))))
+            || (body.plan !== undefined && body.plan !== 'free' && body.plan !== 'pro')
+            || (body.profile_id !== undefined && (typeof body.profile_id !== 'string' || !['F1', 'D1', 'D2'].includes(body.profile_id) || (body.plan !== 'pro' && body.profile_id !== 'F1'))))
+            throw error(0, 'invalid_request');
+    }
+    if (id === 'minds_resumeMind' || id === 'minds_stopMind') {
+        const body = input.body;
+        if (!uuid4.test(options.headers?.['idempotency-key'] ?? '') || !body || typeof body !== 'object' || Array.isArray(body)
+            || Object.keys(body).some(key => !(id === 'minds_resumeMind' ? ['expected_generation', 'wake_reason'] : ['expected_generation']).includes(key))
+            || (body.wake_reason !== undefined && (typeof body.wake_reason !== 'string' || !['manual', 'scheduled_job', 'webhook', 'memory_consolidation', 'activity'].includes(body.wake_reason)))
+            || !Number.isSafeInteger(body.expected_generation) || body.expected_generation < 1
+            || body.expected_generation >= Number.MAX_SAFE_INTEGER)
+            throw error(0, 'invalid_request');
+    }
+    if (id === 'minds_deleteMind' || id === 'minds_resizeMind') {
+        const body = input.body, generation = id === 'minds_deleteMind' ? input.expected_generation : body?.expected_generation;
+        if (!uuid4.test(options.headers?.['idempotency-key'] ?? '') || !Number.isSafeInteger(generation) || generation < 1 || generation >= Number.MAX_SAFE_INTEGER
+            || (id === 'minds_resizeMind' && (!body || typeof body !== 'object' || Array.isArray(body) || Object.keys(body).sort().join() !== 'expected_generation,profile_id'
+                || !['F1', 'D1', 'D2'].includes(body.profile_id))))
+            throw error(0, 'invalid_request');
+    }
+    const controller = new AbortController(), cancel = () => controller.abort(options.signal?.reason);
+    options.signal?.addEventListener('abort', cancel, { once: true });
+    if (options.signal?.aborted)
+        cancel();
+    const timer = setTimeout(() => controller.abort(), 35_000);
+    async function bounded(work) {
+        controller.signal.throwIfAborted();
+        let abort = () => { };
+        try {
+            return await Promise.race([work(), new Promise((_, reject) => { abort = () => reject(error(0, 'transport_error')); controller.signal.addEventListener('abort', abort, { once: true }); })]);
+        }
+        finally {
+            controller.signal.removeEventListener('abort', abort);
+        }
+    }
+    try {
+        const credential = await bounded(options.credential);
+        controller.signal.throwIfAborted();
+        if (!credential)
+            throw error(401, 'unauthenticated');
+        const body = Object.hasOwn(input, 'body') ? JSON.stringify(input.body) : undefined;
+        if (body !== undefined && new TextEncoder().encode(body).length > 65_536)
+            throw error(0, 'invalid_request');
+        const response = await bounded(() => {
+            dispatchAttempted = true;
+            return options.fetch(options.url, { method: id === 'minds_updateEpisodicMemory' ? 'PUT' : id === 'minds_deleteMind' ? 'DELETE' : ['minds_listMinds', 'minds_getMind', 'minds_getUsage', 'minds_getEpisodicMemory', 'minds_getWebhookDelivery'].includes(id) ? 'GET' : 'POST',
+                headers: { authorization: `Bearer ${credential}`, accept: 'application/json', ...(body === undefined ? {} : { 'content-type': 'application/json' }),
+                    ...(lifecycle.includes(id) ? { 'idempotency-key': options.headers['idempotency-key'] } : {}),
+                    ...(id === 'minds_createMind' ? { 'idempotency-key': options.headers['idempotency-key'], 'x-genesis-minds-creation-context': options.headers['x-genesis-minds-creation-context'] } : {}) },
+                ...(body === undefined ? {} : { body }), signal: controller.signal, redirect: 'error', cache: 'no-store' }).then(result => {
+                if (controller.signal.aborted) {
+                    void result.body?.cancel().catch(() => { });
+                    throw error(0, 'transport_error');
+                }
+                return result;
+            });
+        });
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw error(response.status, 'invalid_response');
+        const chunks = [];
+        let size = 0;
+        const stop = () => { void reader.cancel().catch(() => { }); };
+        controller.signal.addEventListener('abort', stop, { once: true });
+        try {
+            for (;;) {
+                const next = await bounded(() => reader.read());
+                if (next.done)
+                    break;
+                size += next.value.length;
+                if (size > 2 * 1024 * 1024)
+                    throw error(response.status, 'invalid_response');
+                chunks.push(next.value);
+            }
+        }
+        finally {
+            controller.signal.removeEventListener('abort', stop);
+            stop();
+            try {
+                reader.releaseLock();
+            }
+            catch { /* cancellation owns a pending read */ }
+        }
+        const bytes = new Uint8Array(size);
+        let offset = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.length;
+        }
+        let value;
+        try {
+            value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+        }
+        catch {
+            throw error(response.status, 'invalid_response');
+        }
+        if (!response.ok) {
+            const row = value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+            const detail = row && Object.hasOwn(row, 'error') && row.error && typeof row.error === 'object' && !Array.isArray(row.error)
+                ? row.error : undefined;
+            const code = detail && Object.hasOwn(detail, 'code') && typeof detail.code === 'string' ? detail.code : undefined;
+            const unknownOutcome = lifecycle.includes(id) && response.status === 401 && code === 'SELECTION_EXPIRED'
+                && detail !== undefined && Object.hasOwn(detail, 'outcome') && detail.outcome === 'unknown';
+            throw error(response.status, 'minds_error', code, unknownOutcome || id === 'minds_createWebhookDelivery' && detail?.outcome === 'unknown');
+        }
+        if (['minds_createMind', ...lifecycle, 'minds_createWebhookDelivery'].includes(id) && response.status !== 202)
+            throw error(response.status, 'invalid_response');
+        return Response.json(value, { status: response.status, headers: { 'cache-control': 'no-store' } });
+    }
+    catch (cause) {
+        if (cause instanceof GenesisError)
+            throw cause;
+        throw error(0, 'transport_error');
+    }
+    finally {
+        clearTimeout(timer);
+        controller.abort();
+        options.signal?.removeEventListener('abort', cancel);
+    }
+}
+export function mindsModule(client) {
+    return {
+        ...mindsOwnerModule(client),
+        agent: mindsAgentModule(client),
+        list: (query = {}, options = {}) => client.request('minds_listMinds', query, options),
+        get: (mind_id, options = {}) => client.request('minds_getMind', { mind_id }, options),
+        usage: (window, options = {}) => client.request('minds_getUsage', window, options),
+        create: (name, options) => client.request('minds_createMind', { body: { name, ...(options.plan === undefined ? {} : { plan: options.plan }), ...(options.profileId === undefined ? {} : { profile_id: options.profileId }), ...(options.services === undefined ? {} : { services: options.services }) } }, { signal: options.signal,
+            headers: { 'idempotency-key': options.idempotencyKey, 'x-genesis-minds-creation-context': options.contextSha256 } }),
+        resume: (mind_id, expected_generation, options) => client.request('minds_resumeMind', { mind_id, body: { expected_generation, ...(options.wakeReason === undefined ? {} : { wake_reason: options.wakeReason }) } }, { signal: options.signal, headers: { 'idempotency-key': options.idempotencyKey } }),
+        stop: (mind_id, expected_generation, options) => client.request('minds_stopMind', { mind_id, body: { expected_generation } }, { signal: options.signal, headers: { 'idempotency-key': options.idempotencyKey } }),
+        /** Deletes the Mind (controller lifecycle delete): human delete permission, or an org API key with minds:write. */
+        delete: (mind_id, expected_generation, options) => client.request('minds_deleteMind', { mind_id, expected_generation }, { signal: options.signal, headers: { 'idempotency-key': options.idempotencyKey } }),
+        /** Resizes to an existing Pro profile (F1/D1/D2): human manage permission, or an org API key with minds:manage. */
+        resize: (mind_id, expected_generation, profile_id, options) => client.request('minds_resizeMind', { mind_id, body: { expected_generation, profile_id } }, { signal: options.signal, headers: { 'idempotency-key': options.idempotencyKey } }),
+        webhookDeliveries: {
+            create: (mind_id, delivery, options = {}) => client.request('minds_createWebhookDelivery', { mind_id, body: delivery }, options),
+            get: (mind_id, delivery_id, options = {}) => client.request('minds_getWebhookDelivery', { mind_id, delivery_id }, options),
+        },
+        memory: {
+            insert: (mind, event, options = {}) => client.request('minds_insertEpisodicMemory', { mind, body: { event } }, options),
+            get: (mind, storage_id, options = {}) => client.request('minds_getEpisodicMemory', { mind, storage_id }, options),
+            update: (mind, storage_id, body, options = {}) => client.request('minds_updateEpisodicMemory', { mind, storage_id, body }, options),
+            search: (mind, text, limit = 20, options = {}) => client.request('minds_searchMemory', { mind, body: { text, limit } }, options),
+        },
+    };
+}