@onesi/genesis 0.0.1-stage → 0.1.13

package/dist/minds-owner.js

@@ -0,0 +1,226 @@
+import { envelopeExtrasValid, ENVELOPE_EXTRA_FIELDS, GenesisError } from './errors.js';
+export const mindsOwnerOperations = ['minds_listAgentGroups', 'minds_createAgentGroup', 'minds_listAgentGroupMembers', 'minds_addAgentGroupMember',
+    'minds_removeAgentGroupMember', 'minds_listMindAttachments', 'minds_attachMind', 'minds_detachMind'];
+export const isMindsOwnerOperation = (id) => mindsOwnerOperations.includes(id);
+export class MindsOwnerError extends GenesisError {
+}
+const row = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const exact = (value, keys) => row(value)
+    && Object.keys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key));
+const canonical = (value, prefix) => typeof value === 'string' && new RegExp(`^${prefix}[0-7][0-9A-HJKMNP-TV-Z]{25}$`).test(value);
+const uuid = (value) => typeof value === 'string' && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(value) && value !== '00000000-0000-0000-0000-000000000000';
+const utf8 = (value) => new TextEncoder().encode(value).length;
+const version = (value) => Number.isSafeInteger(value) && Number(value) >= 0 && Number(value) < Number.MAX_SAFE_INTEGER;
+const positive = (value) => Number.isSafeInteger(value) && Number(value) > 0;
+const tombstone = (value) => value === null || positive(value);
+const name = (value) => typeof value === 'string' && !!value.trim() && utf8(value) <= 128;
+const text = (value) => typeof value === 'string' && value.length > 0;
+const permissions = (value) => JSON.stringify(value) === '["minds.agent_data.read"]'
+    || JSON.stringify(value) === '["minds.agent_data.read","minds.agent_data.write"]';
+const subject = (value) => exact(value, ['kind', 'agentId']) && value.kind === 'agent' && canonical(value.agentId, 'a_')
+    || exact(value, ['kind', 'groupId']) && value.kind === 'group' && canonical(value.groupId, 'agp_');
+const reads = new Set(['minds_listAgentGroups', 'minds_listAgentGroupMembers', 'minds_listMindAttachments']);
+const removes = new Set(['minds_removeAgentGroupMember', 'minds_detachMind']);
+function validBody(id, value) {
+    if (reads.has(id))
+        return value === undefined;
+    if (id === 'minds_createAgentGroup')
+        return exact(value, ['operationId', 'name']) && uuid(value.operationId) && name(value.name);
+    if (id === 'minds_addAgentGroupMember')
+        return exact(value, ['operationId', 'expectedVersion', 'agentId'])
+            && uuid(value.operationId) && version(value.expectedVersion) && canonical(value.agentId, 'a_');
+    if (removes.has(id))
+        return exact(value, ['operationId', 'expectedVersion']) && uuid(value.operationId) && version(value.expectedVersion);
+    return exact(value, ['operationId', 'expectedVersion', 'subject', 'permissions', 'expiresAt']) && uuid(value.operationId)
+        && version(value.expectedVersion) && subject(value.subject) && permissions(value.permissions) && Number.isSafeInteger(value.expiresAt)
+        && Number(value.expiresAt) > Date.now() && Number(value.expiresAt) <= Date.now() + 30 * 86400000;
+}
+function validResponse(id, input, value) {
+    const requested = row(input.body) ? input.body : undefined;
+    const group = (v) => exact(v, ['id', 'organizationId', 'ownerId', 'organizationGeneration', 'name', 'version', 'revokedAt'])
+        && canonical(v.id, 'agp_') && text(v.organizationId) && text(v.ownerId) && positive(v.organizationGeneration)
+        && name(v.name) && positive(v.version) && tombstone(v.revokedAt)
+        && (id !== 'minds_createAgentGroup' || v.name === requested?.name && v.version === 1 && v.revokedAt === null);
+    const member = (v) => exact(v, ['groupId', 'agentId', 'agentDid', 'agentCreatedAt', 'version', 'revokedAt'])
+        && v.groupId === input.group_id && canonical(v.agentId, 'a_') && (input.agent_id === undefined || v.agentId === input.agent_id)
+        && typeof v.agentDid === 'string' && /^did:[A-Za-z0-9:._%-]{1,512}$/.test(v.agentDid)
+        && positive(v.agentCreatedAt) && positive(v.version) && tombstone(v.revokedAt)
+        && (id !== 'minds_addAgentGroupMember' || v.agentId === requested?.agentId && v.version === Number(requested?.expectedVersion) + 1 && v.revokedAt === null)
+        && (id !== 'minds_removeAgentGroupMember' || v.version === Number(requested?.expectedVersion) + 1 && positive(v.revokedAt));
+    const attachment = (v) => {
+        if (!exact(v, ['id', 'version', 'organizationId', 'projectId', 'mindId', 'subject', 'permissions', 'sharedNamespace', 'expiresAt', 'revokedAt'])
+            || !canonical(v.id, 'mat_') || (input.attachment_id !== undefined && v.id !== input.attachment_id)
+            || !positive(v.version) || !text(v.organizationId) || !text(v.projectId) || v.mindId !== input.mind_id
+            || !subject(v.subject) || !permissions(v.permissions) || !positive(v.expiresAt) || !tombstone(v.revokedAt))
+            return false;
+        const s = v.subject;
+        if (v.sharedNamespace !== (s.kind === 'group' ? `group:${s.groupId}` : null))
+            return false;
+        if (id === 'minds_attachMind') {
+            const selected = requested?.subject;
+            return s.kind === selected.kind && (s.kind === 'agent' ? s.agentId === selected.agentId : s.groupId === selected.groupId)
+                && JSON.stringify(v.permissions) === JSON.stringify(requested?.permissions) && v.expiresAt === requested?.expiresAt
+                && v.version === Number(requested?.expectedVersion) + 1 && v.revokedAt === null;
+        }
+        return id !== 'minds_detachMind' || v.version === Number(requested?.expectedVersion) + 1 && positive(v.revokedAt);
+    };
+    const list = (key, valid) => exact(value, [key]) && Array.isArray(value[key]) && value[key].every(valid);
+    if (id === 'minds_listAgentGroups')
+        return list('groups', group);
+    if (id === 'minds_listAgentGroupMembers')
+        return list('members', member);
+    if (id === 'minds_listMindAttachments')
+        return list('attachments', attachment);
+    return id === 'minds_createAgentGroup' ? group(value) : id === 'minds_addAgentGroupMember' || id === 'minds_removeAgentGroupMember' ? member(value) : attachment(value);
+}
+/** Original-human owner operations. No context selection, token substitution or automatic retry. */
+export async function mindsOwnerTransport(options) {
+    const id = options.operationId;
+    let dispatched = false;
+    const fail = (status, type, info = {}) => new MindsOwnerError({
+        status, type, operationId: id, code: info.code, requestId: info.requestId,
+        message: 'Minds owner operation was not confirmed. Preserve its operation ID and version when reconciling.',
+        ...(info.unknown || dispatched && (status === 0 || status >= 500 || type === 'invalid_response' && status >= 200 && status < 300) ? { body: { outcome: 'unknown' } } : {}),
+    });
+    if (!isMindsOwnerOperation(id) || options.routing !== 'gateway' || Object.keys(options.headers ?? {}).length)
+        throw fail(0, 'invalid_request');
+    const input = options.input, fields = id === 'minds_listAgentGroups' ? [] : id === 'minds_createAgentGroup' ? ['body']
+        : id === 'minds_removeAgentGroupMember' ? ['group_id', 'agent_id', 'body']
+            : id === 'minds_listAgentGroupMembers' ? ['group_id'] : id === 'minds_addAgentGroupMember' ? ['group_id', 'body']
+                : id === 'minds_listMindAttachments' ? ['mind_id'] : id === 'minds_detachMind' ? ['mind_id', 'attachment_id', 'body'] : ['mind_id', 'body'];
+    if (!exact(input, fields) || input.group_id !== undefined && !canonical(input.group_id, 'agp_')
+        || input.agent_id !== undefined && !canonical(input.agent_id, 'a_') || input.mind_id !== undefined && !uuid(input.mind_id)
+        || input.attachment_id !== undefined && !canonical(input.attachment_id, 'mat_') || !validBody(id, input.body))
+        throw fail(0, 'invalid_request');
+    const body = input.body === undefined ? undefined : JSON.stringify(input.body);
+    if (body !== undefined && utf8(body) > 8192)
+        throw fail(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 = () => { };
+        const cancelled = new Promise((_, reject) => { abort = () => reject(fail(0, 'transport_error')); controller.signal.addEventListener('abort', abort, { once: true }); });
+        try {
+            controller.signal.throwIfAborted();
+            let pending;
+            try {
+                pending = work();
+            }
+            catch (error) {
+                pending = Promise.reject(error);
+            }
+            return await Promise.race([cancelled, pending]);
+        }
+        finally {
+            controller.signal.removeEventListener('abort', abort);
+        }
+    }
+    try {
+        const credential = await bounded(options.credential);
+        controller.signal.throwIfAborted();
+        if (!text(credential) || utf8(credential) > 16384 || /[^\x21-\x7e]|,/.test(credential))
+            throw fail(401, 'unauthenticated');
+        const response = await bounded(() => {
+            dispatched = !reads.has(id);
+            return options.fetch(options.url, { method: reads.has(id) ? 'GET' : removes.has(id) ? 'DELETE' : 'POST',
+                headers: { authorization: `Bearer ${credential}`, accept: 'application/json', ...(body === undefined ? {} : { 'content-type': 'application/json' }) },
+                ...(body === undefined ? {} : { body }), signal: controller.signal, redirect: 'error', cache: 'no-store' }).then(response => {
+                if (controller.signal.aborted) {
+                    void response.body?.cancel().catch(() => { });
+                    throw fail(0, 'transport_error');
+                }
+                return response;
+            });
+        });
+        if (response.headers.get('content-type')?.split(';')[0].trim().toLowerCase() !== 'application/json')
+            throw fail(response.status, 'invalid_response');
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw fail(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 fail(response.status, 'invalid_response');
+                chunks.push(next.value);
+            }
+        }
+        finally {
+            controller.signal.removeEventListener('abort', stop);
+            stop();
+            try {
+                reader.releaseLock();
+            }
+            catch { /* pending cancellation owns the reader */ }
+        }
+        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 fail(response.status, 'invalid_response');
+        }
+        if (!response.ok) {
+            if (!exact(value, ['error']) || !row(value.error) || !['code', 'request_id'].every(k => Object.hasOwn(value.error, k))
+                || Object.keys(value.error).some(k => !['code', 'request_id', 'outcome', ...ENVELOPE_EXTRA_FIELDS].includes(k)) || !envelopeExtrasValid(value.error) || typeof value.error.code !== 'string'
+                || !/^[A-Z][A-Z0-9_]{0,127}$/.test(value.error.code) || typeof value.error.request_id !== 'string'
+                || !/^[\x21-\x7e]{1,256}$/.test(value.error.request_id) || value.error.outcome !== undefined && value.error.outcome !== 'unknown')
+                throw fail(response.status, 'invalid_response');
+            throw fail(response.status, 'minds_owner_error', { code: value.error.code, requestId: value.error.request_id, unknown: !reads.has(id) && value.error.outcome === 'unknown' });
+        }
+        if (response.status !== 200 || !validResponse(id, input, value))
+            throw fail(response.status, 'invalid_response');
+        return Response.json(value, { status: 200, headers: { 'cache-control': 'private, no-store' } });
+    }
+    catch (error) {
+        if (error instanceof MindsOwnerError)
+            throw error;
+        throw fail(0, 'transport_error');
+    }
+    finally {
+        clearTimeout(timer);
+        controller.abort();
+        options.signal?.removeEventListener('abort', cancel);
+    }
+}
+export function mindsOwnerModule(client) {
+    const validOptions = (value) => exact(value, []) || exact(value, ['signal']);
+    const init = (options) => {
+        if (!validOptions(options))
+            throw new MindsOwnerError({ status: 0, type: 'invalid_request', message: 'Unknown Minds owner option.' });
+        return { signal: options.signal };
+    };
+    return {
+        groups: {
+            list: (options = {}) => client.request('minds_listAgentGroups', {}, init(options)),
+            create: (body, options = {}) => client.request('minds_createAgentGroup', { body }, init(options)),
+            members: {
+                list: (group_id, options = {}) => client.request('minds_listAgentGroupMembers', { group_id }, init(options)),
+                add: (group_id, body, options = {}) => client.request('minds_addAgentGroupMember', { group_id, body }, init(options)),
+                remove: (group_id, agent_id, body, options = {}) => client.request('minds_removeAgentGroupMember', { group_id, agent_id, body }, init(options)),
+            },
+        },
+        attachments: {
+            list: (mind_id, options = {}) => client.request('minds_listMindAttachments', { mind_id }, init(options)),
+            attach: (mind_id, body, options = {}) => client.request('minds_attachMind', { mind_id, body }, init(options)),
+            detach: (mind_id, attachment_id, body, options = {}) => client.request('minds_detachMind', { mind_id, attachment_id, body }, init(options)),
+        },
+    };
+}

package/dist/minds.d.ts

@@ -0,0 +1,269 @@
+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_insertEpisodicMemory", "minds_getEpisodicMemory", "minds_updateEpisodicMemory", "minds_searchMemory"];
+export declare const isMindsOperation: (id: string) => boolean;
+export type MindsEventInput = OperationInput<'minds_insertEpisodicMemory'>['body']['event'];
+export type MindsUsage = OperationOutput<'minds_getUsage'>;
+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 interface MindsCreateOptions extends MindsRequestOptions {
+    idempotencyKey: string;
+    contextSha256: string;
+    plan?: 'free' | 'pro';
+    profileId?: 'F1' | 'D1' | 'D2';
+}
+/** 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: {
+        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;
+    }>;
+    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;
+        }>;
+    };
+};