@lifesi/genesis 0.0.0-stage → 0.1.1

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/hives-functions.d.ts

@@ -0,0 +1,15 @@
+/** The service separately bounds its serialized guest stdin envelope at 10 MiB. */
+export declare const MAX_FUNCTION_BODY_BYTES: number;
+export declare const MAX_FUNCTION_JSON_BYTES: number;
+export interface HivesInvokeRequest {
+    method?: string;
+    path?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    body_base64?: string;
+}
+export declare function validateHivesInvocation(input: unknown): asserts input is HivesInvokeRequest;
+/** Safe display/transport headers; customer headers never establish identity. */
+export declare function hivesFunctionResponseHeaders(headers: Headers): Headers;
+/** Metadata contracts cannot accidentally expose an upstream env/ciphertext field. */
+export declare function hivesFunctionMetadata(input: unknown, project: unknown): Record<string, unknown>;

package/dist/hives-functions.js

@@ -0,0 +1,94 @@
+/** The service separately bounds its serialized guest stdin envelope at 10 MiB. */
+export const MAX_FUNCTION_BODY_BYTES = 10 * 1024 * 1024;
+export const MAX_FUNCTION_JSON_BYTES = 16 * 1024 * 1024;
+const reservedHeaders = new Set(['host', 'connection', 'content-length', 'transfer-encoding', 'keep-alive',
+    'proxy-authenticate', 'proxy-authorization', 'te', 'trailer', 'upgrade', 'set-cookie', 'clear-site-data',
+    'authorization', 'cookie', 'forwarded', 'origin', 'referer', 'x-org-id', 'x-workspace-id', 'x-project-id',
+    'x-admin-token', 'x-tenant-id', 'x-cold-start']);
+const platformHeader = (name) => /^x-(?:auth|genesis|life|l1fe|hives|forwarded|execution)-/.test(name);
+const bytes = (value) => new TextEncoder().encode(value).length;
+const fail = () => { throw new Error('Invalid function request. Check method, path, headers, exclusive body encoding and size limits.'); };
+export function validateHivesInvocation(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        fail();
+    const r = input;
+    if (Object.keys(r).some((k) => !['method', 'path', 'headers', 'body', 'body_base64'].includes(k)))
+        fail();
+    if (r.method !== undefined && (typeof r.method !== 'string' || bytes(r.method) > 64 || !/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(r.method)))
+        fail();
+    if (r.path !== undefined && (typeof r.path !== 'string' || !r.path.startsWith('/') || r.path.startsWith('//') || r.path.includes('#') || bytes(r.path) > 8192 || /[\s\u0000-\u001f\u007f]/.test(r.path)))
+        fail();
+    let headerBytes = 0;
+    if (r.headers !== undefined) {
+        if (!r.headers || typeof r.headers !== 'object' || Array.isArray(r.headers) || Object.keys(r.headers).length > 128)
+            fail();
+        for (const [key, value] of Object.entries(r.headers)) {
+            if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(key) || typeof value !== 'string' || /[\u0000-\u0008\u000a-\u001f\u007f]/.test(value)
+                || reservedHeaders.has(key.toLowerCase()) || platformHeader(key.toLowerCase()))
+                fail();
+            headerBytes += bytes(key) + bytes(value);
+            if (headerBytes > 64 * 1024)
+                fail();
+        }
+    }
+    let size = 0;
+    if (r.body_base64 !== undefined) {
+        const value = r.body_base64;
+        if (r.body != null || typeof value !== 'string' || value.length > Math.ceil(MAX_FUNCTION_BODY_BYTES / 3) * 4
+            || value.length % 4 || !/^[A-Za-z0-9+/]*={0,2}$/.test(value))
+            fail();
+        try {
+            const bytes = atob(value);
+            if (btoa(bytes) !== value)
+                fail();
+            size = bytes.length;
+        }
+        catch {
+            fail();
+        }
+    }
+    else if (r.body != null) {
+        let value;
+        try {
+            value = typeof r.body === 'string' ? r.body : JSON.stringify(r.body);
+        }
+        catch {
+            fail();
+        }
+        if (value === undefined)
+            fail();
+        size = new TextEncoder().encode(value).length;
+    }
+    let serialized;
+    try {
+        serialized = JSON.stringify(r);
+    }
+    catch {
+        fail();
+    }
+    if (size + headerBytes > MAX_FUNCTION_BODY_BYTES || !serialized || new TextEncoder().encode(serialized).length > MAX_FUNCTION_JSON_BYTES)
+        fail();
+}
+/** Safe display/transport headers; customer headers never establish identity. */
+export function hivesFunctionResponseHeaders(headers) {
+    const blocked = new Set(['connection', 'keep-alive', 'transfer-encoding', 'upgrade', 'proxy-authenticate', 'proxy-authorization',
+        'te', 'trailer', 'content-length', 'content-encoding', 'set-cookie', 'clear-site-data', 'authorization', 'cookie', 'forwarded', 'host', 'x-org-id', 'x-workspace-id', 'x-project-id', 'x-admin-token', 'x-tenant-id', 'x-hives-guest-status']);
+    for (const value of (headers.get('connection') ?? '').split(','))
+        blocked.add(value.trim().toLowerCase());
+    const safe = new Headers();
+    headers.forEach((value, name) => {
+        if (!blocked.has(name) && (!platformHeader(name) || ['x-execution-id', 'x-execution-duration-ms'].includes(name)))
+            safe.set(name, value);
+    });
+    safe.set('cache-control', 'no-store');
+    return safe;
+}
+/** Metadata contracts cannot accidentally expose an upstream env/ciphertext field. */
+export function hivesFunctionMetadata(input, project) {
+    if (!input || typeof input !== 'object' || input.project_id !== project) {
+        throw new Error('Hives returned invalid or wrong-project function metadata.');
+    }
+    const row = input;
+    return Object.fromEntries(['id', 'tenant_id', 'project_id', 'name', 'description', 'handler', 'route', 'memory_mb', 'timeout_ms',
+        'status', 'invocations', 'avg_duration_ms', 'created_at', 'updated_at'].map((key) => [key, row[key]]));
+}

package/dist/hives-node.d.ts

@@ -0,0 +1,9 @@
+import { Genesis } from './genesis.js';
+import type { GenesisOptions } from './client.js';
+export declare function closeHivesNodeTransport(): Promise<void>;
+export declare function hivesOperationBudget(id: string): number;
+/** Hives leaf transport. Caller fetch overrides stay authoritative; only native
+ * global fetch gets our Agent. Every operation retains an overall body deadline. */
+export declare function createHivesNodeTransport(opts?: GenesisOptions, callerSignal?: AbortSignal): typeof fetch;
+/** Node opt-in for Hives calls. Other services retain the caller transport. */
+export declare function createHivesNodeClient(opts?: GenesisOptions, callerSignal?: AbortSignal): Genesis;

package/dist/hives-node.js

@@ -0,0 +1,150 @@
+import { Agent } from 'undici';
+import { Genesis } from './genesis.js';
+import { operationTable } from './generated/operations.js';
+// Node's native fetch accepts a compatible per-request dispatcher. Never change
+// the global dispatcher or the portable SDK: other products retain their transport.
+const agentOptions = { headersTimeout: 340_000, bodyTimeout: 340_000, connect: { timeout: 5_000 }, connections: 4, pipelining: 1 };
+let agent;
+const nativeAgent = () => agent ??= new Agent(agentOptions);
+export async function closeHivesNodeTransport() {
+    const current = agent;
+    agent = undefined;
+    await current?.destroy();
+}
+export function hivesOperationBudget(id) {
+    if (id === 'hives_cancel_deployment' || id === 'hives_delete_deployment')
+        return 330_000;
+    if (['hives_create_deployment', 'hives_upload_deployment', 'hives_invoke_deployment', 'hives_invoke_function', 'hives_invoke_function_async'].includes(id))
+        return 40_000;
+    if (['hives_create_function', 'hives_update_function', 'hives_delete_function'].includes(id))
+        return 100_000;
+    return 20_000;
+}
+const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const templatePattern = (value) => new RegExp('^' + value.split(/(\{[^}]+\})/).map((part) => part.startsWith('{') ? '[^/]+' : escape(part)).join('') + '$');
+/** Hives leaf transport. Caller fetch overrides stay authoritative; only native
+ * global fetch gets our Agent. Every operation retains an overall body deadline. */
+export function createHivesNodeTransport(opts = {}, callerSignal) {
+    const supplied = opts.fetch ?? globalThis.fetch;
+    const underlying = supplied.bind(globalThis);
+    const useNative = supplied === globalThis.fetch;
+    const resolver = new Genesis(opts);
+    const routes = Object.entries(operationTable)
+        .filter(([, op]) => op.service === 'hives' && !op.internal)
+        .flatMap(([id, op]) => {
+        const direct = resolver.routing === 'direct';
+        let base;
+        try {
+            base = new URL(direct ? (opts.upstreams?.hives ?? op.upstream.base) : resolver.baseUrl);
+        }
+        catch {
+            throw new Error('Invalid Hives service address.');
+        }
+        const path = direct ? op.upstream.path : op.path;
+        const prefix = base.pathname.replace(/\/+$/, '');
+        const paths = [path];
+        if (!direct && path.startsWith('/v1/hives/'))
+            paths.push(path.replace('/v1/hives/', '/hives/v1/'));
+        return paths.map((p) => ({ id, origin: base.origin, method: direct ? op.upstream.method : op.method, pattern: templatePattern(prefix + p) }));
+    });
+    return (async (input, init = {}) => {
+        let url;
+        try {
+            url = new URL(input instanceof Request ? input.url : String(input));
+        }
+        catch {
+            throw new Error('Invalid Hives request address.');
+        }
+        const method = (init.method ?? (input instanceof Request ? input.method : 'GET')).toUpperCase();
+        const route = routes.find((entry) => entry.origin === url.origin && entry.method === method && entry.pattern.test(url.pathname));
+        if (!route)
+            return underlying(input, init);
+        const controller = new AbortController();
+        let message = 'Hives transport failed. Refresh the resource and retry.';
+        const safeError = () => new Error(message);
+        const signals = [...new Set([callerSignal, init.signal, input instanceof Request ? input.signal : undefined].filter((signal) => !!signal))];
+        const canceled = () => {
+            message = 'Hives request canceled before completion. Refresh the resource before retrying.';
+            controller.abort();
+        };
+        for (const signal of signals)
+            signal.addEventListener('abort', canceled, { once: true });
+        const timer = setTimeout(() => {
+            message = 'Hives request deadline exceeded. Refresh the resource before retrying.';
+            controller.abort();
+        }, hivesOperationBudget(route.id));
+        timer.unref();
+        let abortReject = () => { };
+        let reader;
+        let bodyController;
+        const aborted = () => {
+            abortReject(safeError());
+            bodyController?.error(safeError());
+            void reader?.cancel().catch(() => { });
+            cleanup();
+        };
+        controller.signal.addEventListener('abort', aborted, { once: true });
+        const abortPromise = new Promise((_, reject) => { abortReject = reject; });
+        void abortPromise.catch(() => { });
+        const cleanup = () => {
+            clearTimeout(timer);
+            for (const signal of signals)
+                signal.removeEventListener('abort', canceled);
+            controller.signal.removeEventListener('abort', aborted);
+        };
+        if (signals.some((signal) => signal.aborted))
+            canceled();
+        try {
+            if (controller.signal.aborted)
+                throw safeError();
+            const requestInit = {
+                ...init, signal: controller.signal, cache: 'no-store',
+                redirect: init.redirect === 'manual' ? 'manual' : 'error',
+                ...(useNative ? { dispatcher: nativeAgent() } : {}),
+            };
+            const pending = underlying(input, requestInit);
+            // A caller transport may ignore AbortSignal. Reject on our budget anyway,
+            // and discard any late response rather than presenting an acknowledgement.
+            void pending.then((response) => { if (controller.signal.aborted)
+                void response.body?.cancel().catch(() => { }); }, () => { });
+            const response = await Promise.race([pending, abortPromise]);
+            if (controller.signal.aborted)
+                throw safeError();
+            if (!response.body) {
+                cleanup();
+                return response;
+            }
+            reader = response.body.getReader();
+            const body = new ReadableStream({
+                start(value) { bodyController = value; },
+                async pull(value) {
+                    try {
+                        const next = await reader.read();
+                        if (controller.signal.aborted)
+                            return;
+                        if (next.done) {
+                            cleanup();
+                            value.close();
+                        }
+                        else
+                            value.enqueue(next.value);
+                    }
+                    catch {
+                        cleanup();
+                        value.error(safeError());
+                    }
+                },
+                async cancel() { cleanup(); await reader.cancel().catch(() => { }); },
+            });
+            return new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+        }
+        catch {
+            cleanup();
+            throw safeError();
+        }
+    });
+}
+/** Node opt-in for Hives calls. Other services retain the caller transport. */
+export function createHivesNodeClient(opts = {}, callerSignal) {
+    return new Genesis({ ...opts, fetch: createHivesNodeTransport(opts, callerSignal) });
+}

package/dist/hives-response.d.ts

@@ -0,0 +1,2 @@
+/** Bound completed response bytes without losing binary data or treating HTTP errors as JSON wrappers. */
+export declare function hivesResponseBytes(response: Response): Promise<Uint8Array>;

package/dist/hives-response.js

@@ -0,0 +1,32 @@
+import { MAX_FUNCTION_BODY_BYTES } from './hives-functions.js';
+/** Bound completed response bytes without losing binary data or treating HTTP errors as JSON wrappers. */
+export async function hivesResponseBytes(response) {
+    if (!response.body)
+        return new Uint8Array();
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > MAX_FUNCTION_BODY_BYTES) {
+                await reader.cancel();
+                throw new Error('Hives guest response exceeds 10 MiB.');
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return bytes;
+}

package/dist/hives-upload.d.ts

@@ -0,0 +1,9 @@
+export declare const MAX_WASM_BYTES: number;
+export interface HivesUploadOptions {
+    filename?: string;
+    git_sha?: string;
+    git_branch?: string;
+    git_message?: string;
+}
+/** Real multipart binary; the org and digest are resolved by the authenticated backend. */
+export declare function hivesUploadBody(file: Blob, options?: HivesUploadOptions): Promise<FormData>;

package/dist/hives-upload.js

@@ -0,0 +1,23 @@
+export const MAX_WASM_BYTES = 10 * 1024 * 1024;
+/** Real multipart binary; the org and digest are resolved by the authenticated backend. */
+export async function hivesUploadBody(file, options = {}) {
+    if (!(file instanceof Blob) || file.size < 4 || file.size > MAX_WASM_BYTES)
+        throw new Error('Choose a WebAssembly binary of 4 bytes to 10 MiB.');
+    const magic = new Uint8Array(await file.slice(0, 4).arrayBuffer());
+    if (magic[0] !== 0 || magic[1] !== 97 || magic[2] !== 115 || magic[3] !== 109)
+        throw new Error('The file must be a WebAssembly binary.');
+    const limits = { git_sha: 40, git_branch: 255, git_message: 1000 };
+    if (options.filename !== undefined && (typeof options.filename !== 'string' || !options.filename.length || options.filename.length > 255 || /[\r\n]/.test(options.filename)))
+        throw new Error('WASM filename must contain 1–255 characters without newlines.');
+    const form = new FormData();
+    form.append('file', file, options.filename ?? 'module.wasm');
+    for (const key of Object.keys(limits)) {
+        const value = options[key];
+        if (value === undefined)
+            continue;
+        if (typeof value !== 'string' || value.length > limits[key] || (key === 'git_sha' && value.length < 7))
+            throw new Error('Invalid deployment Git metadata.');
+        form.append(key, value);
+    }
+    return form;
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+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 { hivesUploadBody, MAX_WASM_BYTES, type HivesUploadOptions } from './hives-upload.js';
+export { validateHivesInvocation, hivesFunctionResponseHeaders, MAX_FUNCTION_BODY_BYTES, MAX_FUNCTION_JSON_BYTES, type HivesInvokeRequest } from './hives-functions.js';
+export { hivesResponseBytes } from './hives-response.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, dialsEmergencyAddressFeedback, type DialsEmergencyAddressFeedback, type DialsScope, type DialsOutboundCall, type DialsCallControl, type DialsEmergencyAddress } from './dials.js';

package/dist/index.js

@@ -0,0 +1,10 @@
+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 { hivesUploadBody, MAX_WASM_BYTES } from './hives-upload.js';
+export { validateHivesInvocation, hivesFunctionResponseHeaders, MAX_FUNCTION_BODY_BYTES, MAX_FUNCTION_JSON_BYTES } from './hives-functions.js';
+export { hivesResponseBytes } from './hives-response.js';
+export { runnerModule } from './runner.js';
+export { beaconsModule } from './beacons.js';
+export { dialsModule, dialsEmergencyAddressFeedback } 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 {};