@helmr/sdk 0.1.0-preview.g52eb0eef.b35190749915

package/LICENSE

@@ -0,0 +1,190 @@
+Apache License
+Version 2.0, January 2004
+https://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction,
+and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by
+the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all
+other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition,
+"control" means (i) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity
+exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation
+source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but
+not limited to compiled object code, generated documentation,
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or
+Object form, made available under the License, as indicated by a
+copyright notice that is included in or attached to the work
+(an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object
+form, that is based on (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including
+the original version of the Work and any modifications or additions
+to that Work or Derivative Works thereof, that is intentionally
+submitted to Licensor for inclusion in the Work by the copyright owner
+or by an individual or Legal Entity authorized to submit on behalf of
+the copyright owner. For the purposes of this definition, "submitted"
+means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems,
+and issue tracking systems that are managed by, or on behalf of, the
+Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity
+on behalf of whom a Contribution has been received by Licensor and
+subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the
+Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except as stated in this section) patent license to make, have made,
+use, offer to sell, sell, import, and otherwise transfer the Work,
+where such license applies only to those patent claims licensable
+by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s)
+with the Work to which such Contribution(s) was submitted. If You
+institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work
+or a Contribution incorporated within the Work constitutes direct
+or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate
+as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You
+meet the following conditions:
+
+(a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+You may add Your own copyright statement to Your modifications and
+may provide additional or different license terms and conditions
+for use, reproduction, or distribution of Your modifications, or
+for any such Derivative Works as a whole, provided Your use,
+reproduction, and distribution of the Work otherwise complies with
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+any Contribution intentionally submitted for inclusion in the Work
+by You to the Licensor shall be under the terms and conditions of
+this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify
+the terms of any separate license agreement you may have executed
+with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor,
+except as required for reasonable and customary use in describing the
+origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+agreed to in writing, Licensor provides the Work (and each
+Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied, including, without limitation, any warranties or conditions
+of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any
+risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+whether in tort (including negligence), contract, or otherwise,
+unless required by applicable law (such as deliberate and grossly
+negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special,
+incidental, or consequential damages of any character arising as a
+result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses), even if such Contributor
+has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+the Work or Derivative Works thereof, You may choose to offer,
+and charge a fee for, acceptance of support, warranty, indemnity,
+or other liability obligations and/or rights consistent with this
+License. However, in accepting such obligations, You may act only
+on Your own behalf and on Your sole responsibility, not on behalf
+of any other Contributor, and only if You agree to indemnify,
+defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason
+of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+Copyright 2026 Helmr
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,65 @@
+# SDK
+
+User-facing SDK packages live here. `typescript/` contains `@helmr/sdk` for
+declaration authoring, managed runtime operations, and the external
+`HelmrClient`.
+
+Runtime adapter internals, VM details, and host-specific code stay outside the
+SDK surface.
+
+## External client
+
+Declaration-backed resources use a runtime declared ID and a type-only
+definition generic:
+
+```ts
+import { HelmrClient } from "@helmr/sdk"
+import type { issueTask } from "./definitions"
+
+const client = new HelmrClient({
+  url: process.env.HELMR_API_URL!,
+  apiKey: process.env.HELMR_API_KEY!,
+})
+
+const workspace = await client.sandboxes.createWorkspace(
+  "issue-workspace",
+  {
+    key: "issue:123",
+    idempotencyKey: "issue:123:workspace",
+  },
+)
+
+const run = await client.tasks.start<typeof issueTask>(
+  "issue-task",
+  {
+    payload: { issue: 123 },
+    workspace,
+    idempotencyKey: "issue:123:run",
+  },
+)
+
+const result = await client.runs.wait(run)
+const logs = await client.runs.logs(run.id)
+const events = await client.runs.events(run.id)
+```
+
+Task start requires an existing Workspace. The Task Run payload is plaintext
+audit data. Place Secret values when creating the Workspace; never put them in
+payload.
+
+## Tokens
+
+Tokens are independent durable external-completion resources. Task code can
+create and wait on one; a trusted backend can also create or complete one
+through `client.tokens`. Multiple Runs in the same Environment may wait on the
+same Token.
+
+```ts
+const token = await tokens.create({ timeout: "1h" })
+const decision = await token.wait({ schema: approvalSchema })
+
+await client.tokens.complete(tokenId, {
+  result: { approved: true },
+  idempotencyKey: "approval:123",
+})
+```

package/dist/actor.d.ts

@@ -0,0 +1,3 @@
+export { actor } from "./definitions.js";
+export { sessions } from "./session.js";
+export type { SessionClosedError, ActorConfig, Actor, ActorSession, ActorSessionInput, ActorSessionOutput, ActorSessionOutputAppendOptions, ActorSessionOutputSequenceOptions, ActorSessionReceiveOptions, SessionInputMetadata, SessionInputRecord, SessionInputSendRequest, ActorSessionInputResult, SessionInputSource, SessionFailure, SessionStatus, SessionCloseRequest, SessionCloseReceipt, SessionOutputRecord, SessionOutputQuery, ActorSessionReceive, SessionRef, ActorStartOptions, ActorStartResult, Session, WaitTimeoutError, } from "./contract.js";

package/dist/client-actor.d.ts

@@ -0,0 +1,32 @@
+import type { ActorStartResult, ActorStartOptions, CursorPage } from "./contract.js";
+import type { RequestOptions } from "./request.js";
+export type ActorStartRequest = Omit<ActorStartOptions, "signal">;
+export interface ActorRetrieveQuery {
+    readonly deploymentId?: string;
+}
+export interface ActorListQuery extends ActorRetrieveQuery {
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+export interface ActorListItem {
+    readonly id: string;
+}
+export interface ActorInfo extends ActorListItem {
+    readonly deploymentId: string;
+}
+export interface ActorPage extends CursorPage<ActorListItem> {
+    readonly deploymentId: string;
+}
+export interface ClientActorsApi {
+    retrieve(id: string, query?: ActorRetrieveQuery, options?: RequestOptions): Promise<ActorInfo>;
+    list(query?: ActorListQuery, options?: RequestOptions): Promise<ActorPage>;
+    start(id: string, request: ActorStartRequest, options?: RequestOptions): Promise<ActorStartResult>;
+}
+interface ActorTransport {
+    request(method: "GET" | "POST", path: string, options?: Readonly<{
+        body?: unknown;
+        signal?: AbortSignal;
+    }>): Promise<unknown>;
+}
+export declare function createClientActors(transport: ActorTransport): ClientActorsApi;
+export {};

package/dist/client-deployment.d.ts

@@ -0,0 +1,30 @@
+import type { CursorPage } from "./contract.js";
+import type { RequestOptions } from "./request.js";
+export interface Deployment {
+    readonly id: string;
+    readonly version: string;
+    readonly bundleDigest: string;
+    readonly createdAt: string;
+}
+export interface DeploymentListItem {
+    readonly id: string;
+    readonly version: string;
+    readonly bundleDigest: string;
+    readonly createdAt: string;
+}
+export interface DeploymentListQuery {
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+export interface ClientDeploymentsApi {
+    list(query?: DeploymentListQuery, options?: RequestOptions): Promise<CursorPage<DeploymentListItem>>;
+    current(options?: RequestOptions): Promise<Deployment | null>;
+    retrieve(deploymentId: string, options?: RequestOptions): Promise<Deployment>;
+}
+interface DeploymentTransport {
+    request(method: "GET", path: string, options?: Readonly<{
+        signal?: AbortSignal;
+    }>): Promise<unknown>;
+}
+export declare function createClientDeployments(transport: DeploymentTransport): ClientDeploymentsApi;
+export {};

package/dist/client-sandbox.d.ts

@@ -0,0 +1,26 @@
+import { type WorkspaceTransport } from "./client-workspace.js";
+import type { CursorPage } from "./contract.js";
+import type { RequestOptions } from "./request.js";
+import { type WorkspaceCreateRequest, type WorkspaceRef } from "./workspace.js";
+export interface SandboxRetrieveQuery {
+    readonly deploymentId?: string;
+}
+export interface SandboxListQuery extends SandboxRetrieveQuery {
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+export interface SandboxListItem {
+    readonly id: string;
+}
+export interface SandboxInfo extends SandboxListItem {
+    readonly deploymentId: string;
+}
+export interface SandboxPage extends CursorPage<SandboxListItem> {
+    readonly deploymentId: string;
+}
+export interface ClientSandboxesApi {
+    retrieve(id: string, query?: SandboxRetrieveQuery, options?: RequestOptions): Promise<SandboxInfo>;
+    list(query?: SandboxListQuery, options?: RequestOptions): Promise<SandboxPage>;
+    createWorkspace(id: string, request?: WorkspaceCreateRequest, options?: RequestOptions): Promise<WorkspaceRef>;
+}
+export declare function createClientSandboxes(transport: WorkspaceTransport): ClientSandboxesApi;

package/dist/client-schedule.d.ts

@@ -0,0 +1,44 @@
+import type { CursorPage, JsonValue } from "./contract.js";
+import type { RequestOptions } from "./request.js";
+export interface ScheduleFailure {
+    readonly code: string;
+    readonly message: string;
+    readonly details: Readonly<Record<string, JsonValue>>;
+}
+export type ScheduleStatus = "active" | "errored" | "archived";
+export interface Schedule {
+    readonly id: string;
+    readonly taskId: string;
+    readonly generation: number;
+    readonly effectiveFrom: string;
+    readonly cron: Readonly<{
+        pattern: string;
+        timezone: string;
+    }>;
+    readonly status: ScheduleStatus;
+    readonly lastFailure?: ScheduleFailure;
+    readonly nextFireAt?: string;
+    readonly lastFireAt?: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export type ScheduleListQuery = Readonly<{
+    taskId?: never;
+    cursor?: string;
+    limit?: number;
+}> | Readonly<{
+    taskId: string;
+    cursor?: never;
+    limit?: never;
+}>;
+export interface ClientSchedulesApi {
+    retrieve(scheduleId: string, options?: RequestOptions): Promise<Schedule>;
+    list(query?: ScheduleListQuery, options?: RequestOptions): Promise<CursorPage<Schedule>>;
+}
+interface ScheduleTransport {
+    request(method: "GET", path: string, options?: Readonly<{
+        signal?: AbortSignal;
+    }>): Promise<unknown>;
+}
+export declare function createClientSchedules(transport: ScheduleTransport): ClientSchedulesApi;
+export {};

package/dist/client-secret.d.ts

@@ -0,0 +1,51 @@
+import type { CursorPage } from "./contract.js";
+import type { RequestOptions } from "./request.js";
+export type SecretStatus = "active" | "revoked";
+export interface SecretCreateRequest {
+    readonly name: string;
+    readonly value: string;
+    readonly idempotencyKey?: string;
+}
+export interface SecretRotateRequest {
+    readonly value: string;
+    readonly idempotencyKey: string;
+}
+export interface SecretRevokeRequest {
+    readonly idempotencyKey: string;
+}
+export interface Secret {
+    readonly id: string;
+    readonly name: string;
+    readonly status: SecretStatus;
+    readonly createdAt: string;
+    readonly rotatedAt?: string;
+    readonly revokedAt?: string;
+}
+export interface SecretRef {
+    readonly id: string;
+    rotate(request: SecretRotateRequest, options?: RequestOptions): Promise<Secret>;
+    revoke(request: SecretRevokeRequest, options?: RequestOptions): Promise<Secret>;
+}
+export interface ClientSecretsApi {
+    create(request: SecretCreateRequest, options?: RequestOptions): Promise<Secret>;
+    retrieve(id: string, options?: RequestOptions): Promise<Secret>;
+    ref(id: string): SecretRef;
+    list(query?: SecretListQuery, options?: RequestOptions): Promise<CursorPage<Secret>>;
+}
+export type SecretListQuery = Readonly<{
+    name?: never;
+    cursor?: string;
+    limit?: number;
+}> | Readonly<{
+    name: string;
+    cursor?: never;
+    limit?: never;
+}>;
+interface SecretTransport {
+    request(method: "GET" | "POST", path: string, options?: Readonly<{
+        body?: unknown;
+        signal?: AbortSignal;
+    }>): Promise<unknown>;
+}
+export declare function createClientSecrets(transport: SecretTransport): ClientSecretsApi;
+export {};

package/dist/client-session.d.ts

@@ -0,0 +1,38 @@
+import type { CursorPage, SessionInputPage, SessionInputQuery, SessionRef, SessionStatus, Session } from "./contract.js";
+import type { RequestOptions } from "./request.js";
+export type SessionListQuery = Readonly<{
+    actorId?: never;
+    key?: never;
+    status?: SessionStatus | readonly SessionStatus[];
+    cursor?: string;
+    limit?: number;
+}> | Readonly<{
+    actorId: string;
+    key: string;
+    status?: never;
+    cursor?: never;
+    limit?: never;
+}>;
+/**
+ * A Session ref addressed through the REST client. It extends the shared
+ * SessionRef with the durable input log, which only the REST surface reads.
+ */
+export interface ClientSessionRef extends SessionRef {
+    readonly input: SessionRef["input"] & Readonly<{
+        list(query?: SessionInputQuery, options?: RequestOptions): Promise<SessionInputPage>;
+    }>;
+}
+export interface ClientSessionsApi {
+    retrieve(id: string, options?: RequestOptions): Promise<Session>;
+    list(query?: SessionListQuery, options?: RequestOptions): Promise<CursorPage<Session>>;
+    ref(id: string): ClientSessionRef;
+}
+interface SessionTransport {
+    request(method: "GET" | "POST", path: string, options?: Readonly<{
+        body?: unknown;
+        signal?: AbortSignal;
+    }>): Promise<unknown>;
+}
+export declare function createClientSessions(transport: SessionTransport): ClientSessionsApi;
+export declare function createSessionRef(id: string, transport: SessionTransport): ClientSessionRef;
+export {};

package/dist/client-workspace.d.ts

@@ -0,0 +1,36 @@
+import type { CursorPage } from "./contract.js";
+import type { RequestOptions } from "./request.js";
+import { type WorkspaceOwner, type WorkspaceRef, type Workspace, type WorkspaceStatus } from "./workspace.js";
+export interface WorkspaceListItem {
+    readonly id: string;
+    readonly key?: string;
+    readonly sandboxId: string;
+    readonly deploymentId: string;
+    readonly status: WorkspaceStatus;
+    readonly owner?: WorkspaceOwner;
+    readonly lastActivityAt: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export type WorkspaceListQuery = Readonly<{
+    key?: never;
+    cursor?: string;
+    limit?: number;
+}> | Readonly<{
+    key: string;
+    cursor?: never;
+    limit?: never;
+}>;
+export interface ClientWorkspacesApi {
+    retrieve(id: string, options?: RequestOptions): Promise<Workspace>;
+    list(query?: WorkspaceListQuery, options?: RequestOptions): Promise<CursorPage<WorkspaceListItem>>;
+    ref(id: string): WorkspaceRef;
+}
+export interface WorkspaceTransport {
+    request(method: "GET" | "POST" | "DELETE", path: string, options?: Readonly<{
+        body?: unknown;
+        signal?: AbortSignal;
+    }>): Promise<unknown>;
+}
+export declare function createClientWorkspaces(transport: WorkspaceTransport): ClientWorkspacesApi;
+export declare function createClientWorkspaceRef(id: string, transport: WorkspaceTransport): WorkspaceRef;

package/dist/client.d.ts

@@ -0,0 +1,153 @@
+import type { CursorPage, JsonValue, RunHandle, Run, RunStatus, Task, TaskInput, TaskOutput, RunOptions, TaskWait } from "./contract.js";
+import type { TokenCreateRequest, TokenCreateResult, TokenListItem, TokenListQuery, Token } from "./tokens.js";
+import type { WorkspaceRef } from "./workspace.js";
+import { type ClientWorkspacesApi } from "./client-workspace.js";
+import { type ClientSandboxesApi } from "./client-sandbox.js";
+import { type ClientActorsApi } from "./client-actor.js";
+import { type ClientSessionsApi } from "./client-session.js";
+import { type ClientDeploymentsApi } from "./client-deployment.js";
+import { type ClientSchedulesApi } from "./client-schedule.js";
+import { type ClientSecretsApi } from "./client-secret.js";
+import type { RequestOptions } from "./request.js";
+import type { LogAttributes, RunLogLevel } from "./logger.js";
+export interface HelmrClientOptions {
+    readonly url?: string;
+    readonly apiKey: string;
+    readonly fetch?: typeof fetch;
+}
+export interface TokenCompleteRequest {
+    readonly result: JsonValue;
+    readonly idempotencyKey?: string;
+}
+export interface TokenCancelRequest {
+    readonly idempotencyKey?: string;
+}
+export interface ClientTokensApi {
+    create(request?: TokenCreateRequest, options?: RequestOptions): Promise<TokenCreateResult>;
+    retrieve(id: string, options?: RequestOptions): Promise<Token>;
+    list(query?: TokenListQuery, options?: RequestOptions): Promise<CursorPage<TokenListItem>>;
+    complete(id: string, request: TokenCompleteRequest, options?: RequestOptions): Promise<Token>;
+    cancel(id: string, request?: TokenCancelRequest, options?: RequestOptions): Promise<Token>;
+}
+type ClientTaskRunRequest = RunOptions & Readonly<{
+    idempotencyKey?: string;
+    workspace: WorkspaceRef;
+}>;
+export type TaskStartRequest<TTask extends Task> = [
+    TaskInput<TTask>
+] extends [never] ? ClientTaskRunRequest & Readonly<{
+    payload?: never;
+}> : ClientTaskRunRequest & Readonly<{
+    payload: TaskInput<TTask>;
+}>;
+export interface ClientTasksApi {
+    retrieve(id: string, query?: TaskRetrieveQuery, options?: RequestOptions): Promise<TaskInfo>;
+    list(query?: TaskListQuery, options?: RequestOptions): Promise<TaskPage>;
+    start<TTask extends Task>(taskId: TTask["id"], request: TaskStartRequest<TTask>, options?: RequestOptions): Promise<RunHandle<TaskOutput<TTask>>>;
+}
+export interface TaskRetrieveQuery {
+    readonly deploymentId?: string;
+}
+export interface TaskListQuery extends TaskRetrieveQuery {
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+export interface TaskListItem {
+    readonly id: string;
+}
+export interface TaskInfo extends TaskListItem {
+    readonly deploymentId: string;
+}
+export interface TaskPage extends CursorPage<TaskListItem> {
+    readonly deploymentId: string;
+}
+export interface RunListQuery {
+    readonly status?: RunStatus | readonly RunStatus[];
+    readonly kind?: RunEntrypointKind | readonly RunEntrypointKind[];
+    readonly sessionId?: string;
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+export type RunEntrypointKind = "task" | "actor";
+export interface RunListItem {
+    readonly id: string;
+    readonly status: RunStatus;
+    readonly entrypoint: Readonly<{
+        kind: RunEntrypointKind;
+        id: string;
+    }>;
+    readonly workspaceId: string;
+    readonly sessionId?: string;
+    readonly currentAttemptNumber: number;
+    readonly createdAt: string;
+    readonly startedAt?: string;
+    readonly terminalAt?: string;
+}
+export interface RunLogQuery {
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly level?: RunLogLevel | readonly RunLogLevel[];
+}
+export interface RunEventQuery {
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly severity?: RunLogLevel | readonly RunLogLevel[];
+}
+export interface StructuredRunLogRecord {
+    readonly id: string;
+    readonly kind: "structured";
+    readonly runId: string;
+    readonly attemptNumber: number;
+    readonly level: RunLogLevel;
+    readonly message: string;
+    readonly attributes: LogAttributes;
+    readonly at: string;
+}
+export interface StreamRunLogRecord {
+    readonly id: string;
+    readonly kind: "stdout" | "stderr";
+    readonly runId: string;
+    readonly attemptNumber: number;
+    readonly observedSequence: number;
+    readonly contentBase64: string;
+    readonly bytes: number;
+    readonly at: string;
+}
+export type RunLogRecord = StructuredRunLogRecord | StreamRunLogRecord;
+export interface RunEventRecord {
+    readonly id: string;
+    readonly runId: string;
+    readonly attemptNumber?: number;
+    readonly category: string;
+    readonly severity: RunLogLevel;
+    readonly source: string;
+    readonly kind: string;
+    readonly message: string;
+    readonly attributes: JsonValue;
+    readonly occurredAt: string;
+    readonly at: string;
+}
+export interface ClientRunsApi {
+    retrieve<TOutput extends JsonValue>(run: RunHandle<TOutput>, options?: RequestOptions): Promise<Run<TOutput>>;
+    retrieve(runId: string, options?: RequestOptions): Promise<Run<JsonValue>>;
+    list(query?: RunListQuery, options?: RequestOptions): Promise<CursorPage<RunListItem>>;
+    cancel(runId: string, options?: RequestOptions): Promise<Run<JsonValue>>;
+    wait<TOutput extends JsonValue>(run: RunHandle<TOutput>, options?: RequestOptions): TaskWait<TOutput>;
+    wait(runId: string, options?: RequestOptions): TaskWait<JsonValue>;
+    logs(runId: string, query?: RunLogQuery, options?: RequestOptions): Promise<CursorPage<RunLogRecord>>;
+    events(runId: string, query?: RunEventQuery, options?: RequestOptions): Promise<CursorPage<RunEventRecord>>;
+}
+export declare class HelmrClient {
+    readonly tasks: ClientTasksApi;
+    readonly actors: ClientActorsApi;
+    readonly sessions: ClientSessionsApi;
+    readonly sandboxes: ClientSandboxesApi;
+    readonly deployments: ClientDeploymentsApi;
+    readonly schedules: ClientSchedulesApi;
+    readonly secrets: ClientSecretsApi;
+    readonly runs: ClientRunsApi;
+    readonly tokens: ClientTokensApi;
+    readonly workspaces: ClientWorkspacesApi;
+    constructor(options: HelmrClientOptions);
+}
+export {};