@lifesi/genesis 0.0.0-stage → 0.1.0

package/dist/henry.d.ts

@@ -0,0 +1,155 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput } from './types.js';
+/** Henry always derives its organization from the gateway's verified caller. */
+export declare function henryModule(client: GenesisClient): {
+    config: () => Promise<{
+        credential_configured: boolean;
+        models: {
+            id: string;
+        }[];
+    }>;
+    credential: (api_key: string) => Promise<{
+        credential_configured: boolean;
+        models: {
+            id: string;
+        }[];
+    }>;
+    runs: {
+        list: (page_token?: string) => Promise<{
+            runs: import("./index.js").components["schemas"]["Henry.Run"][];
+            next_page_token?: string | null;
+        }>;
+        create: (body: NonNullable<OperationInput<"henry_createRun">["body"]>) => Promise<{
+            id: string;
+            task: string;
+            model: string;
+            status: "ready" | "running" | "acting" | "paused" | "awaiting_approval" | "completed" | "cancelled" | "failed" | "waiting_input";
+            created_at: string;
+            updated_at: string;
+            activity: {
+                id: string;
+                at: string;
+                type: string;
+                detail: string;
+            }[];
+            approvals: {
+                id: string;
+                action: string;
+                url: string;
+                status: string;
+                requested_at: string;
+            }[];
+            phases: {
+                id?: string;
+                code?: number;
+                receipt?: Record<string, never>;
+                usage?: Record<string, never> | null;
+            }[];
+            messages: ({
+                role: string;
+                content?: string | null;
+            } & {
+                [key: string]: unknown;
+            })[];
+        }>;
+        get: (run_id: string) => Promise<{
+            id: string;
+            task: string;
+            model: string;
+            status: "ready" | "running" | "acting" | "paused" | "awaiting_approval" | "completed" | "cancelled" | "failed" | "waiting_input";
+            created_at: string;
+            updated_at: string;
+            activity: {
+                id: string;
+                at: string;
+                type: string;
+                detail: string;
+            }[];
+            approvals: {
+                id: string;
+                action: string;
+                url: string;
+                status: string;
+                requested_at: string;
+            }[];
+            phases: {
+                id?: string;
+                code?: number;
+                receipt?: Record<string, never>;
+                usage?: Record<string, never> | null;
+            }[];
+            messages: ({
+                role: string;
+                content?: string | null;
+            } & {
+                [key: string]: unknown;
+            })[];
+        }>;
+        command: (run_id: string, action: "pause" | "resume" | "cancel" | "input", text?: string) => Promise<{
+            id: string;
+            task: string;
+            model: string;
+            status: "ready" | "running" | "acting" | "paused" | "awaiting_approval" | "completed" | "cancelled" | "failed" | "waiting_input";
+            created_at: string;
+            updated_at: string;
+            activity: {
+                id: string;
+                at: string;
+                type: string;
+                detail: string;
+            }[];
+            approvals: {
+                id: string;
+                action: string;
+                url: string;
+                status: string;
+                requested_at: string;
+            }[];
+            phases: {
+                id?: string;
+                code?: number;
+                receipt?: Record<string, never>;
+                usage?: Record<string, never> | null;
+            }[];
+            messages: ({
+                role: string;
+                content?: string | null;
+            } & {
+                [key: string]: unknown;
+            })[];
+        }>;
+        approval: (run_id: string, approval_id: string, decision: "approve" | "reject") => Promise<{
+            id: string;
+            task: string;
+            model: string;
+            status: "ready" | "running" | "acting" | "paused" | "awaiting_approval" | "completed" | "cancelled" | "failed" | "waiting_input";
+            created_at: string;
+            updated_at: string;
+            activity: {
+                id: string;
+                at: string;
+                type: string;
+                detail: string;
+            }[];
+            approvals: {
+                id: string;
+                action: string;
+                url: string;
+                status: string;
+                requested_at: string;
+            }[];
+            phases: {
+                id?: string;
+                code?: number;
+                receipt?: Record<string, never>;
+                usage?: Record<string, never> | null;
+            }[];
+            messages: ({
+                role: string;
+                content?: string | null;
+            } & {
+                [key: string]: unknown;
+            })[];
+        }>;
+    };
+};

package/dist/henry.js

@@ -0,0 +1,14 @@
+/** Henry always derives its organization from the gateway's verified caller. */
+export function henryModule(client) {
+    return {
+        config: () => client.request('henry_getConfig'),
+        credential: (api_key) => client.request('henry_putCredential', { body: { api_key } }),
+        runs: {
+            list: (page_token) => client.request('henry_listRuns', page_token ? { page_token } : {}),
+            create: (body) => client.request('henry_createRun', { body: { ...body, run_id: body.run_id ?? globalThis.crypto.randomUUID() } }),
+            get: (run_id) => client.request('henry_getRun', { run_id }),
+            command: (run_id, action, text) => client.request('henry_commandRun', { run_id, body: { action, ...(text === undefined ? {} : { text }) } }),
+            approval: (run_id, approval_id, decision) => client.request('henry_decideApproval', { run_id, approval_id, body: { decision } }),
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { Genesis, type ChatMessage } from './genesis.js';
+export { GenesisClient, DEFAULT_BASE_URL, type GenesisOptions, type CredentialProvider } from './client.js';
+export { GenesisError } from './errors.js';
+export { operationTable, services, type OperationId } from './generated/operations.js';
+export type { OperationInput, OperationOutput, OperationMeta, ServiceMeta } from './types.js';
+export type { paths, operations, components } from './generated/schema.js';
+export { runnerModule, type RunnerStartInput, type RunnerSnapshot, type RunnerCatalog, type RunnerEvent, type RunnerProviderResult, type RunnerRequestOptions } from './runner.js';
+export { beaconsModule } from './beacons.js';
+export { dialsModule, type DialsScope, type DialsOutboundCall, type DialsCallControl, type DialsEmergencyAddress } from './dials.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { Genesis } from './genesis.js';
+export { GenesisClient, DEFAULT_BASE_URL } from './client.js';
+export { GenesisError } from './errors.js';
+export { operationTable, services } from './generated/operations.js';
+export { runnerModule } from './runner.js';
+export { beaconsModule } from './beacons.js';
+export { dialsModule } from './dials.js';

package/dist/runner.d.ts

@@ -0,0 +1,52 @@
+import type { GenesisClient } from './client.js';
+import type { components } from './generated/schema.js';
+type Schemas = components['schemas'];
+export type RunnerStartInput = Schemas['Runner.StartInput'];
+export type RunnerSnapshot = Schemas['Runner.Snapshot'];
+export type RunnerCatalog = Schemas['Runner.Catalog'];
+export type RunnerEvent = Schemas['Runner.Event'];
+export type RunnerProviderResult = Schemas['Runner.ProviderResult'];
+export type RunnerRequestOptions = {
+    signal?: AbortSignal;
+};
+/** Runner routes use the Genesis client's credential; the backend owns org/subject scoping. */
+export declare function runnerModule(client: GenesisClient): Readonly<{
+    catalog: (opts?: RunnerRequestOptions) => Promise<{
+        workspaces: {
+            key: components["schemas"]["Runner.SafeOpaqueRef"];
+            label: string;
+        }[];
+        routes: {
+            routeId: components["schemas"]["Runner.SafeOpaqueRef"];
+            kind: "external-harness" | "internal-model";
+            name: string;
+            via: string;
+            state: "synthetic" | "bound" | "unbound";
+            default: boolean;
+        }[];
+    }>;
+    jobs: Readonly<{
+        list: (opts?: RunnerRequestOptions) => Promise<{
+            jobs: components["schemas"]["Runner.Snapshot"][];
+        }>;
+        start: (input: RunnerStartInput, opts?: RunnerRequestOptions) => Promise<{
+            jobId: components["schemas"]["Runner.SafeOpaqueRef"];
+            snapshot: components["schemas"]["Runner.Snapshot"];
+        }>;
+        get: (jobId: string, opts?: RunnerRequestOptions) => Promise<{
+            snapshot: components["schemas"]["Runner.Snapshot"];
+        }>;
+        events: (jobId: string, afterSeq?: number, opts?: RunnerRequestOptions) => Promise<{
+            events: components["schemas"]["Runner.Event"][];
+            nextAfterSeq: number;
+            hasMore: boolean;
+        }>;
+        result: (jobId: string, opts?: RunnerRequestOptions) => Promise<{
+            result: components["schemas"]["Runner.ProviderResult"];
+        }>;
+        cancel: (jobId: string, opts?: RunnerRequestOptions) => Promise<{
+            snapshot: components["schemas"]["Runner.Snapshot"];
+        }>;
+    }>;
+}>;
+export {};

package/dist/runner.js

@@ -0,0 +1,112 @@
+const requestOptions = (options) => ({ signal: options.signal });
+const opaqueId = (v) => typeof v === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(v);
+const pathLike = (v) => /^[A-Za-z]:/.test(v) || v.includes('..');
+const invalid = () => new TypeError('Runner input must match the bounded runner/task-client/v0 contract');
+function checkedJobId(value) {
+    if (!opaqueId(value) || pathLike(value)
+        || /^(?:https?|ftp|file|data|javascript|bearer|basic):|^(?:sk[-_]|pk[-_]|gh[pousr]_|github_pat_|xox[baprs]-|eyJ)/i.test(value)) {
+        throw invalid();
+    }
+    return value;
+}
+function closed(value, required, optional = []) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        && required.every((key) => Object.hasOwn(value, key))
+        && Object.keys(value).every((key) => required.includes(key) || optional.includes(key));
+}
+// Match the core's input bounds and copy once so a caller cannot mutate a validated request
+// while the asynchronous credential provider runs. Identity is never an input property.
+function copyBoundedInput(value) {
+    let nodes = 0;
+    let chars = 0;
+    const ancestors = new Set();
+    const countText = (text) => {
+        chars += text.length;
+        if (text.length > 32768 || chars > 65536)
+            throw invalid();
+        return text;
+    };
+    const walk = (v, depth) => {
+        if (++nodes > 256)
+            throw invalid();
+        if (v === null || typeof v === 'boolean')
+            return v;
+        if (typeof v === 'string')
+            return countText(v);
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v !== 'object' || depth >= 6 || ancestors.has(v))
+            throw invalid();
+        ancestors.add(v);
+        try {
+            if (Array.isArray(v)) {
+                if (Object.getPrototypeOf(v) !== Array.prototype || v.length > 64 || Reflect.ownKeys(v).length !== v.length + 1)
+                    throw invalid();
+                return Array.from({ length: v.length }, (_, index) => {
+                    const d = Object.getOwnPropertyDescriptor(v, String(index));
+                    if (!d || !('value' in d) || !d.enumerable)
+                        throw invalid();
+                    return walk(d.value, depth + 1);
+                });
+            }
+            const prototype = Object.getPrototypeOf(v);
+            if (prototype !== null && prototype !== Object.prototype)
+                throw invalid();
+            const keys = Reflect.ownKeys(v);
+            if (keys.length > 32)
+                throw invalid();
+            const out = Object.create(null);
+            for (const key of keys) {
+                if (typeof key !== 'string')
+                    throw invalid();
+                countText(key);
+                const d = Object.getOwnPropertyDescriptor(v, key);
+                if (!('value' in d) || !d.enumerable)
+                    throw invalid();
+                out[key] = walk(d.value, depth + 1);
+            }
+            return out;
+        }
+        finally {
+            ancestors.delete(v);
+        }
+    };
+    return walk(value, 0);
+}
+function checkedStartInput(input) {
+    const v = copyBoundedInput(input);
+    if (!closed(v, ['task', 'workspaceRef', 'executionRef', 'limits', 'idempotencyKey'])
+        || !closed(v.task, ['id', 'text'], ['meta']) || !opaqueId(v.task.id)
+        || typeof v.task.text !== 'string' || !v.task.text.trim()
+        || (Object.hasOwn(v.task, 'meta') && (v.task.meta === null || typeof v.task.meta !== 'object' || Array.isArray(v.task.meta)))
+        || !opaqueId(v.workspaceRef) || pathLike(v.workspaceRef)
+        || !closed(v.executionRef, ['kind', 'routeId'])
+        || !['external-harness', 'internal-model'].includes(v.executionRef.kind) || !opaqueId(v.executionRef.routeId)
+        || !closed(v.limits, ['maxDurationMs', 'maxOutputBytes'], ['maxEvents']) || !opaqueId(v.idempotencyKey))
+        throw invalid();
+    const limit = (n, maximum) => Number.isInteger(n) && n > 0 && n <= maximum;
+    if (!limit(v.limits.maxDurationMs, 86400000) || !limit(v.limits.maxOutputBytes, 67108864)
+        || (Object.hasOwn(v.limits, 'maxEvents') && !limit(v.limits.maxEvents, 1000)))
+        throw invalid();
+    if (new TextEncoder().encode(JSON.stringify(v)).byteLength > 65536)
+        throw invalid();
+    return v;
+}
+/** Runner routes use the Genesis client's credential; the backend owns org/subject scoping. */
+export function runnerModule(client) {
+    return Object.freeze({
+        catalog: (opts = {}) => client.request('runner_getCatalog', undefined, requestOptions(opts)),
+        jobs: Object.freeze({
+            list: (opts = {}) => client.request('runner_listJobs', undefined, requestOptions(opts)),
+            start: (input, opts = {}) => client.request('runner_startJob', { body: checkedStartInput(input) }, requestOptions(opts)),
+            get: (jobId, opts = {}) => client.request('runner_getJob', { jobId: checkedJobId(jobId) }, requestOptions(opts)),
+            events: (jobId, afterSeq = 0, opts = {}) => {
+                if (!Number.isSafeInteger(afterSeq) || afterSeq < 0)
+                    throw invalid();
+                return client.request('runner_getJobEvents', { jobId: checkedJobId(jobId), afterSeq }, requestOptions(opts));
+            },
+            result: (jobId, opts = {}) => client.request('runner_getJobResult', { jobId: checkedJobId(jobId) }, requestOptions(opts)),
+            cancel: (jobId, opts = {}) => client.request('runner_cancelJob', { jobId: checkedJobId(jobId) }, requestOptions(opts)),
+        }),
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,70 @@
+import type { operations } from './generated/schema.js';
+export interface ServiceMeta {
+    name: string;
+    title: string;
+    upstream: string;
+    status: string;
+    statusNote?: string;
+    operations: number;
+}
+export interface OperationMeta {
+    method: string;
+    path: string;
+    service: string;
+    summary: string;
+    upstream: {
+        base: string;
+        method: string;
+        path: string;
+        status: string;
+    };
+    mcp: boolean;
+    internal: boolean;
+    public: boolean;
+    pathParams: readonly string[];
+    queryParams: readonly string[];
+    hasBody: boolean;
+    inputSchema: Record<string, unknown>;
+}
+type Ops = operations;
+type Clean<T> = [T] extends [never] ? {} : [NonNullable<T>] extends [never] ? {} : NonNullable<T>;
+type Part<K extends keyof Ops, L extends 'path' | 'query'> = Ops[K] extends {
+    parameters: infer P;
+} ? (P extends {
+    [X in L]?: infer T;
+} ? Clean<T> : {}) : {};
+type Body<K extends keyof Ops> = Ops[K] extends {
+    requestBody?: infer B;
+} ? [NonNullable<B>] extends [never] ? {} : NonNullable<B> extends {
+    content: {
+        'application/json': infer J;
+    };
+} ? (undefined extends B ? {
+    body?: J;
+} : {
+    body: J;
+}) : {} : {};
+/** Flat input for an operation: path params + query params + `body`. */
+export type OperationInput<K extends keyof Ops> = Part<K, 'path'> & Part<K, 'query'> & Body<K>;
+type Ok<R> = R extends {
+    200: infer X;
+} ? X : R extends {
+    201: infer X;
+} ? X : R extends {
+    202: infer X;
+} ? X : R extends {
+    204: unknown;
+} ? {
+    content: {
+        'application/json': void;
+    };
+} : unknown;
+/** Parsed JSON success body for an operation. */
+export type OperationOutput<K extends keyof Ops> = Ops[K] extends {
+    responses: infer R;
+} ? (Ok<R> extends {
+    content: {
+        'application/json': infer J;
+    };
+} ? J : unknown) : unknown;
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,22 @@
 {
   "name": "@lifesi/genesis",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "One typed SDK for every Genesis service (Foundry, Hives, Relays, IAM...) via the Genesis API gateway",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./spec.json": "./dist/genesis.openapi.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "gen": "node scripts/gen.mjs",
+    "build": "tsc -p tsconfig.json && cp ../../openapi/genesis.openapi.json dist/"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.