@onesi/genesis 0.0.1-stage → 0.2.0

package/dist/instances.d.ts

@@ -0,0 +1,200 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput } from './types.js';
+/** Instance inventory and lifecycle. Each needs a One account login with a selected organization
+ * and project, or an org API key whose binding selects them. `create` needs a stable idempotency
+ * key (8-128 printable ASCII characters): reuse it to retry and the same instance is returned.
+ * `delete` runs the instance's stop action (an optional key makes the stop one replayable
+ * operation); Omega's native stop deletes the deployment. Ids are Omega deployment UUIDs. */
+export declare function rigsModule(client: GenesisClient): {
+    list: () => Promise<{
+        product: "rigs";
+        instances: import("./index.js").components["schemas"]["Rigs.Instance"][];
+    }>;
+    get: (id: string) => Promise<{
+        product: "rigs";
+        instance: import("./index.js").components["schemas"]["Rigs.Instance"];
+    }>;
+    create: (body: NonNullable<OperationInput<"rigs_createRig">["body"]>, idempotencyKey: string) => Promise<{
+        product: "rigs";
+        instance: import("./index.js").components["schemas"]["Rigs.Instance"];
+    }>;
+    delete: (id: string, idempotencyKey?: string) => Promise<{
+        ok: true;
+        product: "rigs";
+        id: string;
+        capability: "stop";
+        result: {
+            ok?: boolean;
+            capability?: string;
+            status?: string;
+            completed?: boolean;
+            pending?: boolean;
+            bridge?: boolean;
+        };
+    }>;
+    /** `{capability, args}`; the key is required for every capability but `stop`. */
+    action: (id: string, body: NonNullable<OperationInput<"rigs_actOnRig">["body"]>, idempotencyKey?: string) => Promise<{
+        ok: boolean;
+        product: string;
+        id: string;
+        capability: string;
+        result?: {
+            [key: string]: unknown;
+        } | null;
+    } & {
+        [key: string]: unknown;
+    }>;
+    term: (id: string) => Promise<{
+        product: string;
+        id: string;
+        kind?: string;
+        credentials: {
+            url?: string;
+            token?: string;
+            expires_in?: number | string;
+        } & {
+            [key: string]: unknown;
+        };
+    } & {
+        [key: string]: unknown;
+    }>;
+};
+export declare function panesModule(client: GenesisClient): {
+    list: () => Promise<{
+        product: "panes";
+        instances: import("./index.js").components["schemas"]["Panes.Instance"][];
+    } & {
+        [key: string]: unknown;
+    }>;
+    get: (id: string) => Promise<{
+        product: "panes";
+        instance: import("./index.js").components["schemas"]["Panes.Instance"];
+    } & {
+        [key: string]: unknown;
+    }>;
+    create: (body: NonNullable<OperationInput<"panes_createPane">["body"]>, idempotencyKey: string) => Promise<{
+        product: "panes";
+        instance: import("./index.js").components["schemas"]["Panes.Instance"];
+    } & {
+        [key: string]: unknown;
+    }>;
+    delete: (id: string, idempotencyKey?: string) => Promise<{
+        ok: true;
+        product: "panes";
+        id: string;
+        capability: "stop";
+        result?: {
+            [key: string]: unknown;
+        };
+        accepted?: boolean;
+        completed?: boolean;
+        pending?: boolean;
+        status?: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    /** `{capability, args}`; the key is required for every capability but `stop`. */
+    action: (id: string, body: NonNullable<OperationInput<"panes_actOnPane">["body"]>, idempotencyKey?: string) => Promise<{
+        ok: boolean;
+        product: string;
+        id: string;
+        capability: string;
+        result?: {
+            [key: string]: unknown;
+        } | null;
+    } & {
+        [key: string]: unknown;
+    }>;
+    term: (id: string) => Promise<{
+        product: string;
+        id: string;
+        kind?: string;
+        credentials: {
+            url?: string;
+            token?: string;
+            expires_in?: number | string;
+        } & {
+            [key: string]: unknown;
+        };
+    } & {
+        [key: string]: unknown;
+    }>;
+    /** The screenshot image as a raw Response (PNG or JPEG). */
+    screenshot: (id: string, artifactId: string) => Promise<unknown>;
+};
+export declare function shellsModule(client: GenesisClient): {
+    list: () => Promise<{
+        product: "shells";
+        instances: import("./index.js").components["schemas"]["Shells.Instance"][];
+    } & {
+        [key: string]: unknown;
+    }>;
+    get: (id: string) => Promise<{
+        product: "shells";
+        instance: import("./index.js").components["schemas"]["Shells.Instance"];
+    } & {
+        [key: string]: unknown;
+    }>;
+    create: (body: NonNullable<OperationInput<"shells_createShell">["body"]>, idempotencyKey: string) => Promise<{
+        product: "shells";
+        instance: import("./index.js").components["schemas"]["Shells.Instance"];
+    } & {
+        [key: string]: unknown;
+    }>;
+    delete: (id: string, idempotencyKey?: string) => Promise<{
+        ok: true;
+        product: "shells";
+        id: string;
+        capability: "stop";
+        result?: {
+            [key: string]: unknown;
+        };
+        cambium?: unknown;
+    } & {
+        [key: string]: unknown;
+    }>;
+    /** `{capability, args}`; the key is required for every capability but `stop`. */
+    action: (id: string, body: NonNullable<OperationInput<"shells_actOnShell">["body"]>, idempotencyKey?: string) => Promise<{
+        ok: boolean;
+        product: string;
+        id: string;
+        capability: string;
+        result?: {
+            [key: string]: unknown;
+        } | null;
+    } & {
+        [key: string]: unknown;
+    }>;
+    term: (id: string) => Promise<{
+        product: string;
+        id: string;
+        kind?: string;
+        credentials: {
+            url?: string;
+            token?: string;
+            expires_in?: number | string;
+        } & {
+            [key: string]: unknown;
+        };
+    } & {
+        [key: string]: unknown;
+    }>;
+    /** One-shot exec; a repeat with the same key and body replays the stored result. */
+    exec: (id: string, body: NonNullable<OperationInput<"shells_execShell">["body"]>, idempotencyKey: string) => Promise<{
+        ok: true;
+        product: "shells";
+        id: string;
+        result: {
+            exitCode: number | null;
+            encoding: "base64";
+            stdout: string;
+            stderr: string;
+            truncated: {
+                stdout?: boolean;
+                stderr?: boolean;
+            };
+            timedOut: boolean;
+            durationMs: number;
+        };
+    }>;
+};

package/dist/instances.js

@@ -0,0 +1,43 @@
+import { idempotencyHeaders } from './idempotency.js';
+/** Instance inventory and lifecycle. Each needs a One account login with a selected organization
+ * and project, or an org API key whose binding selects them. `create` needs a stable idempotency
+ * key (8-128 printable ASCII characters): reuse it to retry and the same instance is returned.
+ * `delete` runs the instance's stop action (an optional key makes the stop one replayable
+ * operation); Omega's native stop deletes the deployment. Ids are Omega deployment UUIDs. */
+export function rigsModule(client) {
+    return {
+        list: () => client.request('rigs_listRigs'),
+        get: (id) => client.request('rigs_getRig', { id }),
+        create: (body, idempotencyKey) => client.request('rigs_createRig', { body }, { headers: idempotencyHeaders('rigs_createRig', idempotencyKey) }),
+        delete: (id, idempotencyKey) => client.request('rigs_deleteRig', { id }, { headers: idempotencyHeaders('rigs_deleteRig', idempotencyKey) }),
+        /** `{capability, args}`; the key is required for every capability but `stop`. */
+        action: (id, body, idempotencyKey) => client.request('rigs_actOnRig', { id, body }, { headers: idempotencyHeaders('rigs_actOnRig', idempotencyKey) }),
+        term: (id) => client.request('rigs_openRigTerm', { id }),
+    };
+}
+export function panesModule(client) {
+    return {
+        list: () => client.request('panes_listPanes'),
+        get: (id) => client.request('panes_getPane', { id }),
+        create: (body, idempotencyKey) => client.request('panes_createPane', { body }, { headers: idempotencyHeaders('panes_createPane', idempotencyKey) }),
+        delete: (id, idempotencyKey) => client.request('panes_deletePane', { id }, { headers: idempotencyHeaders('panes_deletePane', idempotencyKey) }),
+        /** `{capability, args}`; the key is required for every capability but `stop`. */
+        action: (id, body, idempotencyKey) => client.request('panes_actOnPane', { id, body }, { headers: idempotencyHeaders('panes_actOnPane', idempotencyKey) }),
+        term: (id) => client.request('panes_openPaneTerm', { id }),
+        /** The screenshot image as a raw Response (PNG or JPEG). */
+        screenshot: (id, artifactId) => client.request('panes_getPaneScreenshotData', { id, artifactId }),
+    };
+}
+export function shellsModule(client) {
+    return {
+        list: () => client.request('shells_listShells'),
+        get: (id) => client.request('shells_getShell', { id }),
+        create: (body, idempotencyKey) => client.request('shells_createShell', { body }, { headers: idempotencyHeaders('shells_createShell', idempotencyKey) }),
+        delete: (id, idempotencyKey) => client.request('shells_deleteShell', { id }, { headers: idempotencyHeaders('shells_deleteShell', idempotencyKey) }),
+        /** `{capability, args}`; the key is required for every capability but `stop`. */
+        action: (id, body, idempotencyKey) => client.request('shells_actOnShell', { id, body }, { headers: idempotencyHeaders('shells_actOnShell', idempotencyKey) }),
+        term: (id) => client.request('shells_openShellTerm', { id }),
+        /** One-shot exec; a repeat with the same key and body replays the stored result. */
+        exec: (id, body, idempotencyKey) => client.request('shells_execShell', { id, body }, { headers: idempotencyHeaders('shells_execShell', idempotencyKey) }),
+    };
+}

package/dist/lanes.d.ts

@@ -0,0 +1,267 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+/** Lanes agent context, Sandbox only. Every POST, including the read POSTs (retrieve, snapshots,
+ * cache lookup, tenant export), needs a stable idempotency key; a changed payload under it is 409. */
+export declare function lanesModule(client: GenesisClient): {
+    records: {
+        get: (recordId: string) => Promise<{
+            id?: string;
+            scope?: Record<string, never>;
+            subject?: string;
+            contentRef?: string;
+            summary?: string;
+            visibility?: import("./index.js").components["schemas"]["Lanes.Visibility"];
+            labels?: string[];
+        }>;
+        write: (body: {
+            subject: string;
+            contentRef: string;
+            summary: string;
+            visibility: import("./index.js").components["schemas"]["Lanes.Visibility"];
+            labels: string[];
+            proposedDataClass?: string;
+        }, idempotencyKey: string) => Promise<{
+            id?: string;
+            scope?: Record<string, never>;
+            subject?: string;
+            contentRef?: string;
+            summary?: string;
+            visibility?: import("./index.js").components["schemas"]["Lanes.Visibility"];
+            labels?: string[];
+        }>;
+        snapshot: (body: {
+            exportedBy: string;
+        }, idempotencyKey: string) => Promise<{
+            scope?: Record<string, never>;
+            exportedBy?: string;
+            evidenceRef?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        restore: (body: {
+            scope?: Record<string, never>;
+            exportedBy?: string;
+            evidenceRef?: string;
+        } & {
+            [key: string]: unknown;
+        }, idempotencyKey: string) => Promise<unknown>;
+    };
+    retrieve: (body: {
+        agentId: string;
+        taskId: string;
+        query: string;
+        allowRawContext: boolean;
+        tokenBudget: number;
+    } | {
+        subject: {
+            agentId: string;
+            runId?: string;
+            sessionId?: string;
+            userId?: string;
+        };
+        query: string;
+        allowRawContext?: boolean;
+        tokenBudget?: number;
+        maxResults?: number;
+    }, idempotencyKey: string) => Promise<{
+        frame?: import("./index.js").components["schemas"]["Lanes.Frame"];
+        route?: import("./index.js").components["schemas"]["Lanes.Route"];
+    }>;
+    frames: {
+        create: (body: {
+            agentId: string;
+            taskId: string;
+            query: string;
+            allowRawContext: boolean;
+            tokenBudget: number;
+        }, idempotencyKey: string) => Promise<{
+            frame?: import("./index.js").components["schemas"]["Lanes.Frame"];
+            route?: import("./index.js").components["schemas"]["Lanes.Route"];
+        }>;
+    };
+    answer: (body: {
+        agentId: string;
+        taskId: string;
+        query: string;
+        allowRawContext: boolean;
+        tokenBudget: number;
+    }, idempotencyKey: string) => Promise<{
+        frame?: import("./index.js").components["schemas"]["Lanes.Frame"];
+        routeDecision?: Record<string, never>;
+        route?: import("./index.js").components["schemas"]["Lanes.Route"];
+        cache?: Record<string, never>;
+        answer?: unknown;
+        policyDecisionIds?: string[];
+    }>;
+    ledger: {
+        frame: (frameId: string) => Promise<{
+            sequence?: number;
+            frameId?: string;
+            kind?: string;
+            detail?: unknown;
+        }[]>;
+        snapshot: (body: {
+            exportedBy: string;
+        }, idempotencyKey: string) => Promise<{
+            scope?: Record<string, never>;
+            exportedBy?: string;
+            evidenceRef?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        restore: (body: {
+            scope?: Record<string, never>;
+            exportedBy?: string;
+            evidenceRef?: string;
+        } & {
+            [key: string]: unknown;
+        }, idempotencyKey: string) => Promise<unknown>;
+    };
+    cache: {
+        lookup: (body: {
+            cacheKey: string;
+            cacheClass: string;
+            requestedBy: string;
+        }, idempotencyKey: string) => Promise<{
+            cacheKey?: string;
+            cacheClass?: string;
+            status?: string;
+            hit?: import("./index.js").components["schemas"]["Lanes.CacheArtifact"] | null;
+            policyDecisionIds?: string[];
+        }>;
+        write: (body: {
+            cacheKey: string;
+            cacheClass: string;
+            valueRef: string;
+            summary: string;
+            labels: string[];
+            sourceRecordIds: string[];
+            writtenBy: string;
+        }, idempotencyKey: string) => Promise<{
+            id?: string;
+            scope?: Record<string, never>;
+            cacheKey?: string;
+            cacheClass?: string;
+            valueRef?: string;
+            summary?: string;
+            labels?: string[];
+            sourceRecordIds?: string[];
+            status?: string;
+            evidenceRef?: string;
+            policyDecisionIds?: string[];
+        }>;
+        snapshot: (body: {
+            exportedBy: string;
+        }, idempotencyKey: string) => Promise<{
+            scope?: Record<string, never>;
+            exportedBy?: string;
+            evidenceRef?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        restore: (body: {
+            scope?: Record<string, never>;
+            exportedBy?: string;
+            evidenceRef?: string;
+        } & {
+            [key: string]: unknown;
+        }, idempotencyKey: string) => Promise<unknown>;
+    };
+    recovery: {
+        restore: (body: {
+            [key: string]: unknown;
+        }, idempotencyKey: string) => Promise<{
+            scope?: Record<string, never>;
+            contextRecordsRestored?: number;
+            cacheArtifactsRestored?: number;
+            framesRestored?: number;
+            ledgerEntriesRestored?: number;
+            stageOrder?: string[];
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+    tenant: {
+        export: (body: {
+            requestedBy: string;
+            includeLedger: boolean;
+            includeOperationalRecords: boolean;
+        }, idempotencyKey: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        delete: (body: {
+            requestedBy: string;
+            reason: string;
+            legalHold: boolean;
+        }, idempotencyKey: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    policy: {
+        evaluate: (body: {
+            actorId: string;
+            action: string;
+            dataClass: string;
+            allowRawContext: boolean;
+            modelClass: string;
+        }, idempotencyKey: string) => Promise<{
+            decisionId?: string;
+            allowed?: boolean;
+            decision?: "allow" | "deny";
+            reason?: string;
+            requiresRedaction?: boolean;
+            auditLevel?: string;
+            reasons?: string[];
+            denialReasons?: string[];
+            explanation?: Record<string, never>;
+        }>;
+    };
+    foundryRoutes: {
+        enforce: (body: {
+            routeAlias: string;
+            modelClass: string;
+            dataUseTerms: string[];
+            tokenBudget: number;
+            inputTokens: number;
+        }, idempotencyKey: string) => Promise<{
+            allowed?: boolean;
+            routeAlias?: string;
+            modelClass?: string;
+            inputTokens?: number;
+            maxInputTokens?: number;
+            reasons?: string[];
+        }>;
+    };
+    promotions: {
+        list: () => Promise<{
+            [key: string]: unknown;
+        }[]>;
+        propose: (body: {
+            sourceRecordId: string;
+            proposedBy: string;
+            sanitizedContentRef?: string;
+            sanitizedSummary?: string;
+            labels?: string[];
+        }, idempotencyKey: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        review: (promotionId: string, body: In<"lanes_reviewPromotion">["body"], idempotencyKey: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    operations: {
+        records: () => Promise<{
+            meterRecords?: Record<string, never>[];
+            auditRecords?: Record<string, never>[];
+            evidenceRecords?: Record<string, never>[];
+            probeEvents?: Record<string, never>[];
+        }>;
+        get: (operationId: string) => Promise<{
+            operationId?: string;
+            state?: string;
+            responseStatus?: number;
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+};

package/dist/lanes.js

@@ -0,0 +1,41 @@
+import { idempotencyHeaders } from './idempotency.js';
+/** Lanes agent context, Sandbox only. Every POST, including the read POSTs (retrieve, snapshots,
+ * cache lookup, tenant export), needs a stable idempotency key; a changed payload under it is 409. */
+export function lanesModule(client) {
+    const post = (id) => async (body, idempotencyKey) => client.request(id, { body }, { headers: idempotencyHeaders(id, idempotencyKey) });
+    return {
+        records: {
+            get: (recordId) => client.request('lanes_getRecord', { recordId }),
+            write: post('lanes_writeRecord'),
+            snapshot: post('lanes_snapshotRecords'),
+            restore: post('lanes_restoreRecords'),
+        },
+        retrieve: post('lanes_retrieve'),
+        frames: { create: post('lanes_createFrame') },
+        answer: post('lanes_answer'),
+        ledger: {
+            frame: (frameId) => client.request('lanes_getLedgerFrame', { frameId }),
+            snapshot: post('lanes_snapshotLedger'),
+            restore: post('lanes_restoreLedger'),
+        },
+        cache: {
+            lookup: post('lanes_cacheLookup'),
+            write: post('lanes_cacheWrite'),
+            snapshot: post('lanes_snapshotCache'),
+            restore: post('lanes_restoreCache'),
+        },
+        recovery: { restore: post('lanes_recoveryRestore') },
+        tenant: { export: post('lanes_exportTenant'), delete: post('lanes_deleteTenant') },
+        policy: { evaluate: post('lanes_evaluatePolicy') },
+        foundryRoutes: { enforce: post('lanes_enforceFoundryRoute') },
+        promotions: {
+            list: () => client.request('lanes_listPromotionCandidates'),
+            propose: post('lanes_proposePromotion'),
+            review: async (promotionId, body, idempotencyKey) => client.request('lanes_reviewPromotion', { promotionId, body }, { headers: idempotencyHeaders('lanes_reviewPromotion', idempotencyKey) }),
+        },
+        operations: {
+            records: () => client.request('lanes_listOperationalRecords'),
+            get: (operationId) => client.request('lanes_getOperation', { operationId }),
+        },
+    };
+}

package/dist/minds-agent.d.ts

@@ -0,0 +1,88 @@
+import type { GenesisClient } from './client.js';
+import { GenesisError } from './errors.js';
+export declare const mindsAgentOperations: readonly ["minds_agentInsertEpisodicMemory", "minds_agentGetEpisodicMemory", "minds_agentSearchMemory"];
+/** Agent Mind creation: an approved agent-create token with DPoP, default-off at the gateway (MINDS_AGENT_CREATE_ENABLED). */
+export declare const mindsAgentCreateOperations: readonly ["minds_agentCreateMind", "minds_agentGetCreateOperation"];
+export declare const isMindsAgentCreateOperation: (id: string) => boolean;
+export declare const isMindsAgentOperation: (id: string) => boolean;
+declare const EVENT_TYPES: readonly ["Conversation", "Command", "Query", "Document", "Error", "Success", "Learning", "Decision", "Action", "Context", "Knowledge"];
+type Row = Record<string, unknown>;
+export interface MindsAgentEventInput {
+    id: string;
+    content: string;
+    timestamp: string;
+    event_type?: typeof EVENT_TYPES[number];
+    summary?: string | null;
+    tags?: string[];
+}
+export interface MindsAgentCreateInput {
+    /** "Sandbox" or "Sandbox <label>", at most 80 characters. */
+    name: string;
+    approvalId: string;
+    approvalVersion: number;
+    /** Persisted UUID4 for this creation; also the idempotency key and the status lookup id. */
+    operationId: string;
+}
+export interface MindsAgentCreateOptions {
+    dpopProof: string;
+    signal?: AbortSignal;
+}
+export interface MindsAgentOptions {
+    /** Omit for the agent's private namespace; group authority is checked by the controller. */
+    group?: string;
+    /** Fresh caller-signed proof for the controller capability method and canonical URL. Never generated or retried by the SDK. */
+    dpopProof?: string;
+    signal?: AbortSignal;
+}
+/** Safe metadata from a failed agent-memory call; never contains credentials or proof bytes. */
+export declare class MindsAgentError extends GenesisError {
+    readonly dpopNonce?: string;
+    constructor(init: ConstructorParameters<typeof GenesisError>[0] & {
+        dpopNonce?: string;
+    });
+}
+/** A single agent request: no human context selection, credential exchange or automatic retry. */
+export declare function mindsAgentTransport(options: {
+    operationId: string;
+    input: Row;
+    headers?: Record<string, string>;
+    routing: string;
+    url: string;
+    credential: () => Promise<string | undefined>;
+    fetch: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<Response>;
+export declare function mindsAgentModule(client: GenesisClient): {
+    /** Free/F1 Sandbox only; the fixed spec is the only shape the gateway admits. */
+    create: (input: MindsAgentCreateInput, options: MindsAgentCreateOptions) => Promise<{
+        mind_id: string;
+        status: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    createStatus: (operation_id: string, options: MindsAgentCreateOptions) => Promise<{
+        mind_id: string;
+        status: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    memory: {
+        insert: (mind: string, event: MindsAgentEventInput, options?: MindsAgentOptions) => Promise<{
+            id: string;
+        }>;
+        get: (mind: string, storage_id: string, options?: MindsAgentOptions) => Promise<{
+            item: import("./index.js").components["schemas"]["Minds.EpisodicEvent"] | null;
+        }>;
+        search: (mind: string, text: string, limit?: number, options?: 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;
+        })[]>;
+    };
+};
+export {};