@lifesi/genesis 0.0.0-stage → 0.1.0

package/dist/client.js

@@ -0,0 +1,94 @@
+import { operationTable, services } from './generated/operations.js';
+import { GenesisError } from './errors.js';
+export const DEFAULT_BASE_URL = 'https://console.life.one/api';
+const env = globalThis.process?.env ?? {};
+export class GenesisClient {
+    baseUrl;
+    routing;
+    opts;
+    fetchImpl;
+    constructor(opts = {}) {
+        this.opts = opts;
+        this.baseUrl = (opts.baseUrl ?? env.GENESIS_BASE_URL ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.routing = opts.routing ?? (env.GENESIS_ROUTING === 'direct' ? 'direct' : 'gateway');
+        const f = opts.fetch ?? globalThis.fetch;
+        if (!f)
+            throw new Error('No fetch available; pass options.fetch');
+        this.fetchImpl = f.bind(globalThis);
+    }
+    static operations = operationTable;
+    static services = services;
+    /** Resolve the credential: explicit apiKey > token > env GENESIS_API_KEY > GENESIS_TOKEN > provider. */
+    async credential() {
+        return this.opts.apiKey ?? this.opts.token ?? env.GENESIS_API_KEY ?? env.GENESIS_TOKEN ?? (await this.opts.credentials?.());
+    }
+    /** Build the URL for an operation (exposed for tests and `--dry-run`). */
+    url(operationId, input = {}) {
+        const op = operationTable[operationId];
+        if (!op)
+            throw new Error(`Unknown Genesis operation: ${operationId}`);
+        const fill = (tpl) => tpl.replace(/\{([^}]+)\}/g, (_, k) => {
+            const v = input[k];
+            if (v === undefined || v === null || v === '')
+                throw new GenesisError({ status: 0, type: 'invalid_request', message: `Missing required path parameter "${k}" for ${operationId}`, operationId });
+            return encodeURIComponent(String(v));
+        });
+        let base;
+        let p;
+        if (this.routing === 'direct') {
+            base = (this.opts.upstreams?.[op.service] ?? op.upstream.base).replace(/\/+$/, '');
+            p = fill(op.upstream.path);
+        }
+        else {
+            base = this.baseUrl;
+            p = fill(op.path);
+        }
+        const qs = new URLSearchParams();
+        for (const q of op.queryParams) {
+            const v = input[q];
+            if (v === undefined || v === null)
+                continue;
+            if (Array.isArray(v))
+                v.forEach((x) => qs.append(q, String(x)));
+            else
+                qs.set(q, String(v));
+        }
+        const s = qs.toString();
+        return `${base}${p}${s ? `?${s}` : ''}`;
+    }
+    /** Call any Genesis operation by id, fully typed from the merged spec. */
+    async request(operationId, input, init = {}) {
+        const res = await this.raw(operationId, (input ?? {}), init);
+        if (res.status === 204)
+            return undefined;
+        const ct = res.headers.get('content-type') ?? '';
+        return (ct.includes('json') ? await res.json() : await res.text());
+    }
+    /** Like request() but returns the raw Response (for streaming). Throws GenesisError on non-2xx. */
+    async raw(operationId, input = {}, init = {}) {
+        const op = operationTable[operationId];
+        const url = this.url(operationId, input);
+        const headers = {
+            accept: 'application/json',
+            'user-agent': this.opts.userAgent ?? '@lifesi/genesis/0.1.0',
+            ...this.opts.headers, ...init.headers,
+        };
+        if (!op.public) {
+            const cred = await this.credential();
+            // Direct mode: let the upstream decide (some, like Foundry's model list, are public).
+            if (!cred && this.routing !== 'direct')
+                throw new GenesisError({ status: 401, type: 'unauthorized', message: 'No Genesis credential. Run `genesis login`, or set GENESIS_API_KEY.', operationId });
+            if (cred)
+                headers.authorization = `Bearer ${cred}`;
+        }
+        let body;
+        if (op.hasBody && input.body !== undefined) {
+            headers['content-type'] = 'application/json';
+            body = JSON.stringify(input.body);
+        }
+        const res = await this.fetchImpl(url, { method: op.method, headers, body, signal: init.signal });
+        if (!res.ok)
+            throw await GenesisError.fromResponse(res, operationId);
+        return res;
+    }
+}

package/dist/dials.d.ts

@@ -0,0 +1,51 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput } from './types.js';
+import type { components } from './generated/schema.js';
+export type DialsScope = components['schemas']['Dials.Scope'];
+export type DialsCallControl = components['schemas']['Dials.CallControl'];
+/** The public call contract requires customer-selected behavior for every caller. */
+export type DialsOutboundCall = components['schemas']['Dials.OutboundCall'];
+export type DialsEmergencyAddress = components['schemas']['Dials.RegisterEmergencyAddress'];
+/** Scope is selection only; the Dials backend verifies its org against signed identity. */
+export declare function dialsModule(client: GenesisClient): {
+    numbers: {
+        list: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            numbers: components["schemas"]["Dials.Number"][];
+        }>;
+        search: (scope: DialsScope, query?: {
+            areaCode?: string;
+            limit?: number;
+        }) => Promise<{
+            [key: string]: unknown;
+        }>;
+        provision: (body: OperationInput<"dials_provisionNumber">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        assign: (body: OperationInput<"dials_assignNumber">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        release: (body: OperationInput<"dials_releaseNumber">["body"]) => Promise<{
+            [key: string]: unknown;
+        }>;
+        registerEmergencyAddress: (body: DialsEmergencyAddress) => Promise<{
+            ok: boolean;
+            number: components["schemas"]["Dials.Number"];
+            address: components["schemas"]["Dials.EmergencyAddress"];
+            auditId: string;
+            next: string;
+        }>;
+    };
+    calls: {
+        list: (scope: DialsScope) => Promise<{
+            ok: boolean;
+            calls: components["schemas"]["Dials.Call"][];
+        }>;
+        validate: (body: DialsOutboundCall) => Promise<{
+            [key: string]: unknown;
+        }>;
+        create: (body: DialsOutboundCall) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+};

package/dist/dials.js

@@ -0,0 +1,18 @@
+/** Scope is selection only; the Dials backend verifies its org against signed identity. */
+export function dialsModule(client) {
+    return {
+        numbers: {
+            list: (scope) => client.request('dials_listNumbers', scope),
+            search: (scope, query = {}) => client.request('dials_searchNumbers', { ...scope, ...query }),
+            provision: (body) => client.request('dials_provisionNumber', { body }),
+            assign: (body) => client.request('dials_assignNumber', { body }),
+            release: (body) => client.request('dials_releaseNumber', { body }),
+            registerEmergencyAddress: (body) => client.request('dials_registerEmergencyAddress', { body }),
+        },
+        calls: {
+            list: (scope) => client.request('dials_listCalls', scope),
+            validate: (body) => client.request('dials_validateOutboundCall', { body }),
+            create: (body) => client.request('dials_createOutboundCall', { body }),
+        },
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,19 @@
+/** Normalized error for every Genesis service (gateway `{error:{type,message}}`, IAM `{error,error_description}`, Relays `{error}`, Foundry/OpenAI shape). */
+export declare class GenesisError extends Error {
+    readonly status: number;
+    readonly type: string;
+    readonly code?: string;
+    readonly requestId?: string;
+    readonly operationId?: string;
+    readonly body: unknown;
+    constructor(init: {
+        status: number;
+        type: string;
+        message: string;
+        code?: string;
+        requestId?: string;
+        operationId?: string;
+        body?: unknown;
+    });
+    static fromResponse(res: Response, operationId?: string): Promise<GenesisError>;
+}

package/dist/errors.js

@@ -0,0 +1,35 @@
+/** Normalized error for every Genesis service (gateway `{error:{type,message}}`, IAM `{error,error_description}`, Relays `{error}`, Foundry/OpenAI shape). */
+export class GenesisError extends Error {
+    status;
+    type;
+    code;
+    requestId;
+    operationId;
+    body;
+    constructor(init) {
+        super(init.message);
+        this.name = 'GenesisError';
+        Object.assign(this, init);
+        this.status = init.status;
+        this.type = init.type;
+        this.body = init.body;
+    }
+    static async fromResponse(res, operationId) {
+        const text = await res.text().catch(() => '');
+        let body = text;
+        try {
+            body = text ? JSON.parse(text) : undefined;
+        }
+        catch { /* keep text */ }
+        const e = body?.error;
+        const type = typeof e === 'object' && e ? (e.type ?? e.code ?? 'error') : typeof e === 'string' ? e : statusType(res.status);
+        const message = (typeof e === 'object' && e?.message) || body?.error_description || body?.message ||
+            (typeof e === 'string' && e) || (typeof body === 'string' && body) || `${res.status} ${res.statusText}`;
+        return new GenesisError({
+            status: res.status, type, message, code: typeof e === 'object' ? e?.code : undefined,
+            requestId: res.headers.get('x-request-id') ?? (typeof e === 'object' ? e?.request_id : undefined) ?? body?.request_id,
+            operationId, body,
+        });
+    }
+}
+const statusType = (s) => s === 401 ? 'unauthorized' : s === 403 ? 'forbidden' : s === 404 ? 'not_found' : s === 429 ? 'rate_limited' : s >= 500 ? 'upstream_error' : 'error';

package/dist/fleets.d.ts

@@ -0,0 +1,71 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput } from './types.js';
+type TaskInput = NonNullable<OperationInput<'fleets_submitTask'>['body']>;
+/** Managed agent tasks, always scoped to the credential's verified organization. */
+export declare function fleetsModule(client: GenesisClient): {
+    connection: {
+        get: () => Promise<{
+            connected: boolean;
+            model: string;
+            updated_at?: number;
+        }>;
+        set: (api_key: string) => Promise<{
+            connected: boolean;
+            model: string;
+            updated_at?: number;
+        }>;
+        delete: () => Promise<{
+            connected: boolean;
+            model: string;
+            updated_at?: number;
+        }>;
+    };
+    tasks: {
+        list: (query?: OperationInput<"fleets_listTasks">) => Promise<{
+            tasks: import("./index.js").components["schemas"]["Fleets.Summary"][];
+            next_before: string | null;
+        }>;
+        submit: (body: TaskInput) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+            submitted_at: string;
+            started_at?: string | null;
+            completed_at?: string | null;
+        }>;
+        get: (task_id: string) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+            submitted_at: string;
+            started_at?: string | null;
+            completed_at?: string | null;
+        }>;
+        cancel: (task_id: string) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+        }>;
+        receipt: (task_id: string) => Promise<{
+            task_id: string;
+            status: import("./index.js").components["schemas"]["Fleets.Status"];
+            submitted_at: string;
+            started_at?: string | null;
+            completed_at?: string | null;
+        } & {
+            tenant: string;
+            principal: string;
+            idempotency_key: string | null;
+            request_fingerprint: string;
+            timeout_seconds: number;
+            exit_code: number | null;
+            exit_signal: number | null;
+            cleanup_result: {
+                process_group_gone?: boolean;
+                workdir_removed?: boolean;
+                sigkill_sent?: boolean;
+            } | null;
+            henry_receipt?: {
+                [key: string]: unknown;
+            };
+        }>;
+    };
+};
+export {};

package/dist/fleets.js

@@ -0,0 +1,44 @@
+import { GenesisError } from './errors.js';
+const byteLength = (value) => new TextEncoder().encode(value).byteLength;
+const invalid = (operationId, message) => new GenesisError({
+    status: 0, type: 'invalid_request', operationId, message,
+});
+function validateTask(body) {
+    if (typeof body?.input !== 'string' || !body.input || byteLength(body.input) > 65536 || body.input.includes('\0')) {
+        throw invalid('fleets_submitTask', 'Task input must contain 1–65536 UTF-8 bytes without NUL.');
+    }
+    if (body.timeout_seconds !== undefined && (!Number.isInteger(body.timeout_seconds) || body.timeout_seconds < 1 || body.timeout_seconds > 3600)) {
+        throw invalid('fleets_submitTask', 'Timeout must be 1–3600 seconds.');
+    }
+    if (body.idempotency_key !== undefined && (typeof body.idempotency_key !== 'string' || !/^[!-~]{1,128}$/.test(body.idempotency_key))) {
+        throw invalid('fleets_submitTask', 'Idempotency key must contain 1–128 visible ASCII characters.');
+    }
+}
+function validateKey(apiKey) {
+    if (typeof apiKey !== 'string' || !apiKey || byteLength(apiKey) > 4096 || /[\r\n\0]/.test(apiKey)) {
+        throw invalid('fleets_setConnection', 'Foundry key must contain 1–4096 UTF-8 bytes without CR, LF or NUL.');
+    }
+}
+/** Managed agent tasks, always scoped to the credential's verified organization. */
+export function fleetsModule(client) {
+    return {
+        connection: {
+            get: () => client.request('fleets_getConnection', {}),
+            set: async (api_key) => {
+                validateKey(api_key);
+                return client.request('fleets_setConnection', { body: { api_key } });
+            },
+            delete: () => client.request('fleets_deleteConnection', {}),
+        },
+        tasks: {
+            list: (query = {}) => client.request('fleets_listTasks', query),
+            submit: async (body) => {
+                validateTask(body);
+                return client.request('fleets_submitTask', { body });
+            },
+            get: (task_id) => client.request('fleets_getTask', { task_id }),
+            cancel: (task_id) => client.request('fleets_cancelTask', { task_id }),
+            receipt: (task_id) => client.request('fleets_getTaskReceipt', { task_id }),
+        },
+    };
+}