@helmr/sdk 0.1.0

package/dist/internal.d.ts

@@ -0,0 +1,239 @@
+export interface CacheMount {
+    readonly id: string;
+}
+export type CacheBuilder = CacheMount;
+export interface CacheMountBinding {
+    readonly mountPath: string;
+    readonly cache: CacheMount;
+}
+export interface SecretMountBinding {
+    readonly mountPath: string;
+    readonly secret: string;
+}
+export interface SourceDirectoryOptions {
+    readonly ignore?: readonly string[];
+}
+export interface WorkspaceSpec {
+    readonly kind: "github";
+    readonly repository: string;
+    readonly ref: string;
+    readonly subpath?: string;
+}
+export interface SourceFileRef {
+    readonly path: string;
+}
+export interface SourceDirRef {
+    readonly path: string;
+    readonly ignore: readonly string[];
+}
+export interface SourceCapabilities {
+    file(path: string): SourceFileRef;
+    directory(path: string, opts?: SourceDirectoryOptions): SourceDirRef;
+}
+export interface WorkspaceCapabilities {
+    github(repo: string, opts: {
+        readonly ref: string;
+        readonly subpath?: string;
+    }): WorkspaceSpec;
+}
+export declare class ApprovalTimeoutError extends Error {
+    constructor(message: string);
+    static [Symbol.hasInstance](value: unknown): boolean;
+}
+export declare class MessageTimeoutError extends Error {
+    constructor(message: string);
+    static [Symbol.hasInstance](value: unknown): boolean;
+}
+export declare class ConcurrentWaitError extends Error {
+    constructor(message: string);
+    static [Symbol.hasInstance](value: unknown): boolean;
+}
+export type Placement = {
+    readonly env: string;
+} | {
+    readonly file: string;
+    readonly mode?: string;
+    readonly owner?: string;
+} | {
+    readonly dir: string;
+    readonly mode?: string;
+    readonly owner?: string;
+};
+export type SecretDecls = Record<string, Placement>;
+export declare function validateSecretName(name: string, label?: string): void;
+export interface TaskContext {
+    readonly wait: {
+        approval(message: string, opts?: {
+            readonly timeout?: number;
+        }): Promise<{
+            readonly approved: boolean;
+            readonly approvedBy: string;
+            readonly at: Date;
+        }>;
+        message(prompt?: string, opts?: {
+            readonly timeout?: number;
+        }): Promise<{
+            readonly text: string;
+            readonly sentBy: string;
+            readonly at: Date;
+            readonly attachments: readonly unknown[];
+        }>;
+    };
+    emit(event: EmitEvent): void;
+    readonly log: {
+        info(...args: unknown[]): void;
+        warn(...args: unknown[]): void;
+        error(...args: unknown[]): void;
+    };
+    readonly signal: AbortSignal;
+    readonly run: {
+        readonly id: string;
+    };
+}
+export type EmitContent = {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "image";
+    readonly data: string;
+    readonly mimeType?: string;
+} | {
+    readonly type: "tool_use";
+    readonly name: string;
+    readonly input?: unknown;
+} | {
+    readonly type: "tool_result";
+    readonly name?: string;
+    readonly result?: unknown;
+} | {
+    readonly type: string;
+    readonly [key: string]: unknown;
+};
+export interface EmitEvent {
+    readonly type: string;
+    readonly content: readonly EmitContent[];
+}
+export type MaybePromise<T> = T | Promise<T>;
+export interface TaskConfig<TPayload = unknown, TOutput = unknown, TSecrets extends SecretDecls = Record<never, never>> {
+    readonly id: string;
+    readonly sandbox: SandboxBuilder;
+    readonly maxDuration?: number;
+    readonly secrets?: TSecrets;
+    readonly run: (payload: TPayload, ctx: TaskContext) => MaybePromise<TOutput>;
+}
+export type Task<TPayload = unknown, TOutput = unknown, TSecrets extends SecretDecls = Record<never, never>> = TaskConfig<TPayload, TOutput, TSecrets>;
+export type AnyTask = Task<any, any, SecretDecls>;
+export type TaskPayload<TTask> = TTask extends Task<infer TPayload, any, any> ? TPayload : never;
+export type TaskOutput<TTask> = TTask extends Task<any, infer TOutput, any> ? Awaited<TOutput> : never;
+export declare const taskBrand: unique symbol;
+export declare const taskOriginBrand: unique symbol;
+export declare const configBrand: unique symbol;
+export type ImageCopyInput = SourceFileRef | SourceDirRef | ImageBuilder;
+export interface ImageRunOptions {
+    readonly cache?: readonly CacheMountBinding[];
+    readonly secrets?: readonly SecretMountBinding[];
+}
+export interface ImageBuilder {
+    from(ref: string): ImageBuilder;
+    run(argv: readonly string[], opts?: ImageRunOptions): ImageBuilder;
+    copy(dest: string, src: ImageCopyInput): ImageBuilder;
+    copyFrom(dest: string, src: ImageBuilder, srcPath: string): ImageBuilder;
+    workdir(path: string): ImageBuilder;
+    env(key: string, value: string): ImageBuilder;
+    user(name: string): ImageBuilder;
+}
+export interface SandboxBuilder {
+    image(img: ImageBuilder): SandboxBuilder;
+    workspace(mountPath?: string): SandboxBuilder;
+    resources(opts: {
+        readonly cpu?: number;
+        readonly memory?: string;
+    }): SandboxBuilder;
+}
+export type ImageBuildStep = {
+    readonly kind: "from";
+    readonly ref: string;
+} | {
+    readonly kind: "run";
+    readonly argv: readonly string[];
+    readonly cache: readonly CacheMountBinding[];
+    readonly secrets: readonly SecretMountBinding[];
+} | {
+    readonly kind: "copy";
+    readonly dest: string;
+    readonly source: ImageCopyInput;
+} | {
+    readonly kind: "copyFrom";
+    readonly dest: string;
+    readonly source: ImageBuilder;
+    readonly srcPath: string;
+} | {
+    readonly kind: "workdir";
+    readonly path: string;
+} | {
+    readonly kind: "env";
+    readonly key: string;
+    readonly value: string;
+} | {
+    readonly kind: "user";
+    readonly name: string;
+};
+export interface SandboxWorkspace {
+    readonly mountPath: string;
+}
+export interface SandboxResources {
+    readonly cpu?: number;
+    readonly memory?: string;
+}
+export declare function markTask<TPayload, TOutput, TSecrets extends SecretDecls>(config: TaskConfig<TPayload, TOutput, TSecrets>): Task<TPayload, Awaited<TOutput>, TSecrets>;
+export declare function isTaskDefinition(value: unknown): value is AnyTask & {
+    readonly [taskBrand]: true;
+};
+export declare function taskOriginFile(value: unknown): string | null;
+export interface HelmrConfig {
+    readonly project?: string;
+    readonly dirs: readonly string[];
+    readonly ignorePatterns?: readonly string[];
+}
+export declare function markConfig(config: HelmrConfig): HelmrConfig;
+export declare function isConfigDefinition(value: unknown): value is HelmrConfig & {
+    readonly [configBrand]: true;
+};
+export declare class ImageBuilderImpl implements ImageBuilder {
+    readonly id: string;
+    readonly steps: readonly ImageBuildStep[];
+    constructor(id: string, steps?: readonly ImageBuildStep[]);
+    from(ref: string): ImageBuilder;
+    run(argv: readonly string[], opts?: ImageRunOptions): ImageBuilder;
+    copy(dest: string, src: ImageCopyInput): ImageBuilder;
+    copyFrom(dest: string, src: ImageBuilder, srcPath: string): ImageBuilder;
+    workdir(path: string): ImageBuilder;
+    env(key: string, value: string): ImageBuilder;
+    user(name: string): ImageBuilder;
+}
+export declare class SandboxBuilderImpl implements SandboxBuilder {
+    readonly id: string;
+    readonly imageBuilder: ImageBuilderImpl | undefined;
+    readonly workspaceBinding: SandboxWorkspace | undefined;
+    readonly resourceSpec: SandboxResources | undefined;
+    constructor(id: string, imageBuilder?: ImageBuilderImpl, workspaceBinding?: SandboxWorkspace, resourceSpec?: SandboxResources);
+    image(img: ImageBuilder): SandboxBuilder;
+    workspace(mountPath?: string): SandboxBuilder;
+    resources(opts: {
+        readonly cpu?: number;
+        readonly memory?: string;
+    }): SandboxBuilder;
+}
+export declare class SourceFileRefImpl implements SourceFileRef {
+    readonly path: string;
+    constructor(path: string);
+}
+export declare class SourceDirRefImpl implements SourceDirRef {
+    readonly path: string;
+    readonly ignore: readonly string[];
+    constructor(path: string, ignore: readonly string[]);
+}
+export declare function isImageBuilder(value: unknown): value is ImageBuilderImpl;
+export declare function isSandboxBuilder(value: unknown): value is SandboxBuilderImpl;
+export declare function isSourceFileRef(value: unknown): value is SourceFileRefImpl;
+export declare function isSourceDirRef(value: unknown): value is SourceDirRefImpl;

package/dist/internal.js

@@ -0,0 +1,345 @@
+// sdk/typescript/src/schema/task.ts
+var TASK_ID_PATTERN = "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$";
+var TASK_ID_MAX_LENGTH = 128;
+var DEFAULT_MAX_DURATION_SECONDS = 900;
+var MIN_MAX_DURATION_SECONDS = 5;
+var MAX_DURATION_SECONDS = 86400;
+
+class TaskIdError extends Error {
+  name = "TaskIdError";
+  value;
+  constructor(value) {
+    super(`task id must match ${TASK_ID_PATTERN}: ${JSON.stringify(value)}`);
+    this.value = value;
+  }
+}
+function validateTaskId(value) {
+  if (!isValidTaskId(value)) {
+    throw new TaskIdError(value);
+  }
+}
+function isValidTaskId(value) {
+  if (value.length === 0 || value.length > TASK_ID_MAX_LENGTH) {
+    return false;
+  }
+  const first = value.charCodeAt(0);
+  if (!isAsciiAlnum(first)) {
+    return false;
+  }
+  for (let index = 1;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (!(isAsciiAlnum(code) || code === 46 || code === 95 || code === 45)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+class TaskMaxDurationError extends Error {
+  name = "TaskMaxDurationError";
+  value;
+  label;
+  constructor(value, label = "task maxDuration") {
+    super(`${label} must be an integer number of seconds between ${MIN_MAX_DURATION_SECONDS} and ${MAX_DURATION_SECONDS}`);
+    this.value = value;
+    this.label = label;
+  }
+}
+function readOptionalMaxDurationSeconds(value, label = "task maxDuration") {
+  if (value === undefined) {
+    return DEFAULT_MAX_DURATION_SECONDS;
+  }
+  if (typeof value === "number" && Number.isInteger(value) && Number.isFinite(value) && value >= MIN_MAX_DURATION_SECONDS && value <= MAX_DURATION_SECONDS) {
+    return value;
+  }
+  throw new TaskMaxDurationError(value, label);
+}
+function validateOptionalMaxDurationSeconds(value, label = "task maxDuration") {
+  readOptionalMaxDurationSeconds(value, label);
+}
+function isAsciiAlnum(code) {
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+
+// sdk/typescript/src/internal.ts
+var approvalTimeoutErrorBrand = Symbol.for("helmr.sdk.ApprovalTimeoutError");
+var messageTimeoutErrorBrand = Symbol.for("helmr.sdk.MessageTimeoutError");
+var concurrentWaitErrorBrand = Symbol.for("helmr.sdk.ConcurrentWaitError");
+
+class ApprovalTimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ApprovalTimeoutError";
+    Object.defineProperty(this, approvalTimeoutErrorBrand, { value: true });
+  }
+  static [Symbol.hasInstance](value) {
+    return this === ApprovalTimeoutError && typeof value === "object" && value !== null && approvalTimeoutErrorBrand in value;
+  }
+}
+
+class MessageTimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MessageTimeoutError";
+    Object.defineProperty(this, messageTimeoutErrorBrand, { value: true });
+  }
+  static [Symbol.hasInstance](value) {
+    return this === MessageTimeoutError && typeof value === "object" && value !== null && messageTimeoutErrorBrand in value;
+  }
+}
+
+class ConcurrentWaitError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConcurrentWaitError";
+    Object.defineProperty(this, concurrentWaitErrorBrand, { value: true });
+  }
+  static [Symbol.hasInstance](value) {
+    return this === ConcurrentWaitError && typeof value === "object" && value !== null && concurrentWaitErrorBrand in value;
+  }
+}
+function validateSecretName(name, label = "secret name") {
+  if (name.length === 0) {
+    throw new Error(`${label} must not be empty`);
+  }
+  if (name.length > 128) {
+    throw new Error(`${label} must be at most 128 characters`);
+  }
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+    throw new Error(`${label} must match /^[A-Za-z_][A-Za-z0-9_]*$/`);
+  }
+  const upper = name.toUpperCase();
+  if (upper === "CON" || upper === "PRN" || upper === "AUX" || upper === "NUL" || /^COM[1-9]$/.test(upper) || /^LPT[1-9]$/.test(upper)) {
+    throw new Error(`${label} is reserved`);
+  }
+}
+function validateImageBuildSecretRef(name) {
+  validateSecretName(name, "image build secret ref");
+  return name;
+}
+var RESERVED_WORKSPACE_MOUNT_PATHS = [
+  "/dev",
+  "/opt/helmr",
+  "/proc",
+  "/run",
+  "/sys",
+  "/tmp",
+  "/.helmr-old-root"
+];
+function normalizeWorkspaceMountPath(raw) {
+  if (raw.length === 0) {
+    throw new Error("sandbox.workspace() mountPath is empty");
+  }
+  if (raw.includes("\x00")) {
+    throw new Error("sandbox.workspace() mountPath contains NUL");
+  }
+  if (!raw.startsWith("/")) {
+    throw new Error(`sandbox.workspace() mountPath must be absolute: ${raw}`);
+  }
+  const parts = [];
+  for (const part of raw.split("/")) {
+    if (part === "" || part === ".")
+      continue;
+    if (part === "..") {
+      throw new Error(`sandbox.workspace() mountPath contains unsafe path components: ${raw}`);
+    }
+    parts.push(part);
+  }
+  if (parts.length === 0) {
+    throw new Error("sandbox.workspace() mountPath cannot be /");
+  }
+  const normalized = `/${parts.join("/")}`;
+  if (RESERVED_WORKSPACE_MOUNT_PATHS.some((reserved) => normalized === reserved || normalized.startsWith(`${reserved}/`))) {
+    throw new Error(`sandbox.workspace() mountPath conflicts with reserved runtime mount paths: ${normalized}`);
+  }
+  return normalized;
+}
+var taskBrand = Symbol.for("helmr.sdk.Task");
+var taskOriginBrand = Symbol.for("helmr.sdk.TaskOrigin");
+var configBrand = Symbol.for("helmr.sdk.Config");
+var imageBuilderBrand = Symbol.for("helmr.sdk.ImageBuilder");
+var sandboxBuilderBrand = Symbol.for("helmr.sdk.SandboxBuilder");
+var sourceFileRefBrand = Symbol.for("helmr.sdk.SourceFileRef");
+var sourceDirRefBrand = Symbol.for("helmr.sdk.SourceDirRef");
+function markTask(config) {
+  validateTaskId(config.id);
+  validateOptionalMaxDurationSeconds(config.maxDuration);
+  Object.defineProperty(config, taskBrand, { value: true });
+  Object.defineProperty(config, taskOriginBrand, { value: captureTaskOrigin() });
+  return config;
+}
+function isTaskDefinition(value) {
+  return hasBrand(value, taskBrand);
+}
+function taskOriginFile(value) {
+  if (!isTaskDefinition(value)) {
+    return null;
+  }
+  const origin = value[taskOriginBrand];
+  return typeof origin === "string" && origin.length > 0 ? origin : null;
+}
+function markConfig(config) {
+  Object.defineProperty(config, configBrand, { value: true });
+  return config;
+}
+function isConfigDefinition(value) {
+  return hasBrand(value, configBrand);
+}
+function captureTaskOrigin() {
+  const stack = new Error().stack ?? "";
+  for (const line of stack.split(`
+`).slice(1)) {
+    const file = stackFrameFile(line);
+    if (file === null || isSdkInternalFrame(file)) {
+      continue;
+    }
+    return file;
+  }
+  return "unknown";
+}
+function stackFrameFile(line) {
+  const match = /\(?((?:file:\/\/)?\/[^():]+):\d+:\d+\)?$/.exec(line.trim());
+  if (!match?.[1]) {
+    return null;
+  }
+  return match[1].startsWith("file://") ? decodeURIComponent(new URL(match[1]).pathname) : match[1];
+}
+function isSdkInternalFrame(file) {
+  return file.includes("/sdk/typescript/src/internal.ts") || file.includes("/sdk/typescript/src/task.ts") || file.includes("/sdk/typescript/src/index.ts") || file.includes("/runtime/typescript/src/");
+}
+
+class ImageBuilderImpl {
+  id;
+  steps;
+  constructor(id, steps = []) {
+    Object.defineProperty(this, imageBuilderBrand, { value: true });
+    this.id = id;
+    this.steps = steps;
+  }
+  from(ref) {
+    return new ImageBuilderImpl(this.id, [...this.steps, { kind: "from", ref }]);
+  }
+  run(argv, opts = {}) {
+    return new ImageBuilderImpl(this.id, [
+      ...this.steps,
+      {
+        kind: "run",
+        argv: [...argv],
+        cache: (opts.cache ?? []).map((binding) => ({
+          mountPath: binding.mountPath,
+          cache: { id: binding.cache.id }
+        })),
+        secrets: (opts.secrets ?? []).map((binding) => ({
+          mountPath: binding.mountPath,
+          secret: validateImageBuildSecretRef(binding.secret)
+        }))
+      }
+    ]);
+  }
+  copy(dest, src) {
+    return new ImageBuilderImpl(this.id, [...this.steps, { kind: "copy", dest, source: src }]);
+  }
+  copyFrom(dest, src, srcPath) {
+    if (!isImageBuilder(src)) {
+      throw new Error("image.copyFrom() requires an ImageBuilder created by image()");
+    }
+    return new ImageBuilderImpl(this.id, [
+      ...this.steps,
+      { kind: "copyFrom", dest, source: src, srcPath }
+    ]);
+  }
+  workdir(path) {
+    return new ImageBuilderImpl(this.id, [...this.steps, { kind: "workdir", path }]);
+  }
+  env(key, value) {
+    return new ImageBuilderImpl(this.id, [...this.steps, { kind: "env", key, value }]);
+  }
+  user(name) {
+    return new ImageBuilderImpl(this.id, [...this.steps, { kind: "user", name }]);
+  }
+}
+
+class SandboxBuilderImpl {
+  id;
+  imageBuilder;
+  workspaceBinding;
+  resourceSpec;
+  constructor(id, imageBuilder, workspaceBinding, resourceSpec) {
+    Object.defineProperty(this, sandboxBuilderBrand, { value: true });
+    this.id = id;
+    this.imageBuilder = imageBuilder;
+    this.workspaceBinding = workspaceBinding;
+    this.resourceSpec = resourceSpec;
+  }
+  image(img) {
+    if (!isImageBuilder(img)) {
+      throw new Error("sandbox.image() requires an ImageBuilder created by image()");
+    }
+    return new SandboxBuilderImpl(this.id, img, this.workspaceBinding, this.resourceSpec);
+  }
+  workspace(mountPath = "/workspace") {
+    return new SandboxBuilderImpl(this.id, this.imageBuilder, { mountPath: normalizeWorkspaceMountPath(mountPath) }, this.resourceSpec);
+  }
+  resources(opts) {
+    const resourceSpec = {
+      ...opts.cpu === undefined ? {} : { cpu: opts.cpu },
+      ...opts.memory === undefined ? {} : { memory: opts.memory }
+    };
+    return new SandboxBuilderImpl(this.id, this.imageBuilder, this.workspaceBinding, resourceSpec);
+  }
+}
+
+class SourceFileRefImpl {
+  path;
+  constructor(path) {
+    Object.defineProperty(this, sourceFileRefBrand, { value: true });
+    this.path = path;
+  }
+}
+
+class SourceDirRefImpl {
+  path;
+  ignore;
+  constructor(path, ignore) {
+    Object.defineProperty(this, sourceDirRefBrand, { value: true });
+    this.path = path;
+    this.ignore = ignore;
+  }
+}
+function isImageBuilder(value) {
+  return hasBrand(value, imageBuilderBrand);
+}
+function isSandboxBuilder(value) {
+  return hasBrand(value, sandboxBuilderBrand);
+}
+function isSourceFileRef(value) {
+  return hasBrand(value, sourceFileRefBrand);
+}
+function isSourceDirRef(value) {
+  return hasBrand(value, sourceDirRefBrand);
+}
+function hasBrand(value, brand) {
+  return value !== null && typeof value === "object" && value[brand] === true;
+}
+export {
+  validateSecretName,
+  taskOriginFile,
+  taskOriginBrand,
+  taskBrand,
+  markTask,
+  markConfig,
+  isTaskDefinition,
+  isSourceFileRef,
+  isSourceDirRef,
+  isSandboxBuilder,
+  isImageBuilder,
+  isConfigDefinition,
+  configBrand,
+  SourceFileRefImpl,
+  SourceDirRefImpl,
+  SandboxBuilderImpl,
+  MessageTimeoutError,
+  ImageBuilderImpl,
+  ConcurrentWaitError,
+  ApprovalTimeoutError
+};

package/dist/runtime/client.d.ts

@@ -0,0 +1,74 @@
+import { type SecretDecls, type Task, type WorkspaceSpec } from "../internal.js";
+import { type LogSnapshot, type ListRunEventsOptions, type ListRunsOptions, type PendingApprovalWaitpoint, type PendingMessageWaitpoint, type PendingWaitpointResponse, type RetrieveRunOptions, type RunHandle, type RunEvent, type RunSnapshot, type RunSummary, type RunWaitOptions, type SubscribeRunEventsOptions, type WaitpointApprovalOptions, type WaitpointReplyOptions } from "./run.js";
+export interface HelmrClientOptions {
+    readonly url?: string;
+    readonly apiKey?: string;
+}
+export type TaskTriggerOptions<TPayload, TSecrets extends SecretDecls> = {
+    /**
+     * Payload is audit data: Helmr persists it in plaintext in the `run.created`
+     * event, DB, and events stream. Do not put secret values (tokens, API keys,
+     * credentials, or PII) in payload; use `secrets:` instead. Use payload for
+     * business context such as PR numbers, repo names, ticket ids, and other
+     * identifiers.
+     */
+    readonly payload: TPayload;
+    readonly workspace: WorkspaceSpec;
+} & ([keyof TSecrets] extends [never] ? {
+    readonly secrets?: Record<never, never>;
+} : {
+    readonly secrets: {
+        readonly [K in keyof TSecrets]: string;
+    };
+});
+export interface WaitpointsApi {
+    readonly approve: {
+        (target: PendingApprovalWaitpoint, opts?: WaitpointApprovalOptions): Promise<void>;
+        (runId: string, waitpointId: string, opts?: WaitpointApprovalOptions): Promise<void>;
+    };
+    readonly deny: {
+        (target: PendingApprovalWaitpoint, opts?: WaitpointApprovalOptions): Promise<void>;
+        (runId: string, waitpointId: string, opts?: WaitpointApprovalOptions): Promise<void>;
+    };
+    readonly reply: {
+        (target: PendingMessageWaitpoint, opts: WaitpointReplyOptions): Promise<void>;
+        (runId: string, waitpointId: string, opts: WaitpointReplyOptions): Promise<void>;
+    };
+}
+export declare class HelmrClient {
+    #private;
+    constructor(options?: HelmrClientOptions);
+    readonly tasks: {
+        trigger: <TPayload, TOutput, TSecrets extends SecretDecls>(task: Task<TPayload, TOutput, TSecrets>, opts: TaskTriggerOptions<TPayload, TSecrets>) => Promise<RunHandle<TOutput>>;
+    };
+    readonly runs: {
+        retrieve: <TOutput = unknown>(idOrHandle: string | RunHandle<TOutput>, opts?: RetrieveRunOptions) => Promise<RunSnapshot<TOutput>>;
+        wait: <TOutput = unknown>(idOrHandle: string | RunHandle<TOutput>, opts?: RunWaitOptions) => Promise<RunSnapshot<TOutput>>;
+        list: (opts?: ListRunsOptions) => Promise<RunSummary[]>;
+        logs: {
+            retrieve: <TOutput = unknown>(idOrHandle: string | RunHandle<TOutput>, opts?: {
+                readonly signal?: AbortSignal;
+            }) => Promise<LogSnapshot>;
+        };
+        events: {
+            list: <TOutput = unknown>(idOrHandle: string | RunHandle<TOutput>, opts?: ListRunEventsOptions) => Promise<RunEvent[]>;
+            subscribe: <TOutput = unknown>(idOrHandle: string | RunHandle<TOutput>, opts?: SubscribeRunEventsOptions) => Promise<AsyncIterable<RunEvent>>;
+        };
+    };
+    readonly waitpoints: WaitpointsApi;
+}
+export interface RunResponse {
+    readonly id: string;
+    readonly project_id?: string;
+    readonly environment_id?: string;
+    readonly task_id: string;
+    readonly status: string;
+    readonly exit_code?: number | null;
+    readonly created_at?: string;
+    readonly updated_at?: string;
+    readonly pending_wait?: PendingWaitpointResponse | null;
+    readonly output?: unknown;
+}
+export interface ListRunsResponse {
+    readonly runs: readonly RunResponse[];
+}

package/dist/runtime/errors.d.ts

@@ -0,0 +1,13 @@
+export declare class RunNotFoundError extends Error {
+    readonly runId: string;
+    constructor(runId: string);
+}
+export declare class AuthError extends Error {
+    constructor(message: string);
+}
+export declare class TimeoutError extends Error {
+    constructor(message: string);
+}
+export declare class UnsupportedTransportError extends Error {
+    constructor(message: string);
+}