@helmr/sdk 0.1.1-rc.1 → 0.1.1-rc.2

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { ApprovalTimeoutError, ConcurrentWaitError, MessageTimeoutError, validateSecretName, type CacheBuilder, type CacheMount, type CacheMountBinding, type EmitContent, type EmitEvent, type ImageBuilder, type ImageRunOptions, type Placement, type SandboxBuilder, type SecretDecls, type SecretMountBinding, type SourceCapabilities, type SourceDirRef, type SourceDirectoryOptions, type SourceFileRef, type TaskContext, type TaskOutput, type TaskPayload, type WorkspaceCapabilities, type WorkspaceSpec } from "./internal.js";
 import { HelmrClient } from "./runtime/client.js";
+export type { WaitpointResponseToken, WaitpointTokenAction, WaitpointTokenCompleteOptions, WaitpointTokenCreateOptions, } from "./runtime/client.js";
 import { sandbox } from "./sandbox.js";
 import { defineConfig, type HelmrConfig, type HelmrConfigInput } from "./config.js";
 import { task, type Task, type TaskConfig } from "./task.js";

package/dist/index.js

@@ -380,7 +380,7 @@ function runId(value) {
 function runStateBooleans(status) {
   return {
     isQueued: status === "queued",
-    isRunning: status === "claimed" || status === "running",
+    isRunning: status === "running",
     isWaiting: status === "waiting",
     isTerminal: isTerminalRunStatus(status),
     isSuccess: status === "succeeded",
@@ -391,7 +391,6 @@ function runStateBooleans(status) {
 function runStatus(status) {
   switch (status) {
     case "queued":
-    case "claimed":
     case "running":
     case "waiting":
     case "succeeded":
@@ -430,9 +429,6 @@ class HelmrClient {
       throw new UnsupportedTransportError("HelmrClient requires an http(s) URL");
     }
     if (parsedUrl.protocol === "https:") {
-      if (apiKey === undefined || apiKey === "") {
-        throw new AuthError("HelmrClient https:// transport requires apiKey or HELMR_API_KEY");
-      }
       this.#baseUrl = normalizedBaseUrl(parsedUrl);
       this.#apiKey = apiKey;
     } else if (parsedUrl.protocol === "http:") {
@@ -539,6 +535,25 @@ class HelmrClient {
         body: JSON.stringify({ text: resolved.opts.text, attachments: [] }),
         headers: { "content-type": "application/json" }
       });
+    },
+    tokens: {
+      create: async (target, waitpointIdOrOpts, opts = {}) => {
+        const resolved = resolveWaitpointArgs(target, waitpointIdOrOpts, opts);
+        const response = await this.#json("/api/waitpoints/tokens", {
+          method: "POST",
+          body: JSON.stringify(waitpointTokenCreateBody(resolved.runId, resolved.waitpointId, resolved.opts)),
+          headers: { "content-type": "application/json" }
+        });
+        return waitpointResponseTokenFromResponse(response);
+      },
+      complete: async (target, tokenOrOpts, maybeOpts) => {
+        const resolved = typeof target === "string" ? resolveWaitpointTokenCompleteArgs(target, tokenOrOpts, maybeOpts) : { id: target.id, token: target.token, opts: tokenOrOpts };
+        await this.#fetch(`/api/waitpoints/tokens/${encodeURIComponent(resolved.id)}/complete`, {
+          method: "POST",
+          body: JSON.stringify(waitpointTokenCompleteBody(resolved.token, resolved.opts)),
+          headers: { "content-type": "application/json" }
+        });
+      }
     }
   };
   async#retrieveLogs(id, signal) {
@@ -649,6 +664,42 @@ function runResponseToSnapshot(response) {
 function approvalBody(opts) {
   return opts.reason === undefined ? {} : { reason: opts.reason };
 }
+function waitpointTokenCreateBody(runId2, waitpointId, opts) {
+  return {
+    run_id: runId2,
+    waitpoint_id: waitpointId,
+    ...opts.actions === undefined ? {} : { actions: opts.actions },
+    ...opts.expiresInSeconds === undefined ? {} : { expires_in_seconds: opts.expiresInSeconds },
+    ...opts.expiresAt === undefined ? {} : { expires_at: opts.expiresAt },
+    ...opts.metadata === undefined ? {} : { metadata: opts.metadata }
+  };
+}
+function waitpointTokenCompleteBody(token, opts) {
+  return {
+    token,
+    action: opts.action,
+    ..."reason" in opts && opts.reason === undefined ? {} : ("reason" in opts) ? { reason: opts.reason } : {},
+    ..."text" in opts ? { text: opts.text } : {},
+    ...opts.externalSubject === undefined ? {} : { external_subject: opts.externalSubject },
+    ...opts.metadata === undefined ? {} : { metadata: opts.metadata }
+  };
+}
+function resolveWaitpointTokenCompleteArgs(id, token, opts) {
+  if (typeof token !== "string" || opts === undefined) {
+    throw new Error("waitpoint token secret is required when completing by token id");
+  }
+  return { id, token, opts };
+}
+function waitpointResponseTokenFromResponse(response) {
+  return {
+    id: response.id,
+    runId: response.run_id,
+    waitpointId: response.waitpoint_id,
+    url: response.url,
+    token: response.token,
+    expiresAt: response.expires_at ?? null
+  };
+}
 function resolveWaitpointArgs(target, waitpointIdOrOpts, opts) {
   if (isWaitpointRef(target)) {
     const resolvedOpts = waitpointIdOrOpts !== undefined && typeof waitpointIdOrOpts !== "string" ? waitpointIdOrOpts : opts;

package/dist/internal.d.ts

@@ -65,6 +65,7 @@ export interface TaskContext {
     readonly wait: {
         approval(message: string, opts?: {
             readonly timeout?: number;
+            readonly policy?: string;
         }): Promise<{
             readonly approved: boolean;
             readonly approvedBy: string;
@@ -72,6 +73,7 @@ export interface TaskContext {
         }>;
         message(prompt?: string, opts?: {
             readonly timeout?: number;
+            readonly policy?: string;
         }): Promise<{
             readonly text: string;
             readonly sentBy: string;

package/dist/runtime/client.d.ts

@@ -1,5 +1,5 @@
 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";
+import { type LogSnapshot, type ListRunEventsOptions, type ListRunsOptions, type PendingApprovalWaitpoint, type PendingMessageWaitpoint, type PendingWaitpoint, type PendingWaitpointResponse, type RetrieveRunOptions, type RunHandle, type RunEvent, type RunSnapshot, type RunSummary, type RunWaitOptions, type SubscribeRunEventsOptions, type WaitpointApprovalOptions, type WaitpointRef, type WaitpointReplyOptions } from "./run.js";
 export interface HelmrClientOptions {
     readonly url?: string;
     readonly apiKey?: string;
@@ -34,7 +34,53 @@ export interface WaitpointsApi {
         (target: PendingMessageWaitpoint, opts: WaitpointReplyOptions): Promise<void>;
         (runId: string, waitpointId: string, opts: WaitpointReplyOptions): Promise<void>;
     };
+    readonly tokens: {
+        readonly create: {
+            (target: PendingWaitpoint | WaitpointRef, opts?: WaitpointTokenCreateOptions): Promise<WaitpointResponseToken>;
+            (runId: string, waitpointId: string, opts?: WaitpointTokenCreateOptions): Promise<WaitpointResponseToken>;
+        };
+        readonly complete: {
+            (token: WaitpointResponseToken, opts: WaitpointTokenCompleteOptions): Promise<void>;
+            (id: string, token: string, opts: WaitpointTokenCompleteOptions): Promise<void>;
+        };
+    };
+}
+export type WaitpointTokenAction = "approve" | "deny" | "message" | "reply";
+type WaitpointTokenExpirationOptions = {
+    readonly expiresInSeconds?: number;
+    readonly expiresAt?: never;
+} | {
+    readonly expiresInSeconds?: never;
+    readonly expiresAt?: string;
+};
+export type WaitpointTokenCreateOptions = WaitpointTokenExpirationOptions & {
+    readonly actions?: readonly WaitpointTokenAction[];
+    readonly metadata?: Record<string, unknown>;
+};
+export interface WaitpointResponseToken {
+    readonly id: string;
+    readonly runId: string;
+    readonly waitpointId: string;
+    readonly url: string;
+    readonly token: string;
+    readonly expiresAt: string | null;
 }
+export type WaitpointTokenCompleteOptions = {
+    readonly action: "approve";
+    readonly reason?: string;
+    readonly externalSubject?: string;
+    readonly metadata?: Record<string, unknown>;
+} | {
+    readonly action: "deny";
+    readonly reason?: string;
+    readonly externalSubject?: string;
+    readonly metadata?: Record<string, unknown>;
+} | {
+    readonly action: "message" | "reply";
+    readonly text: string;
+    readonly externalSubject?: string;
+    readonly metadata?: Record<string, unknown>;
+};
 export declare class HelmrClient {
     #private;
     constructor(options?: HelmrClientOptions);
@@ -72,3 +118,4 @@ export interface RunResponse {
 export interface ListRunsResponse {
     readonly runs: readonly RunResponse[];
 }
+export {};

package/dist/runtime/run.d.ts

@@ -1,4 +1,4 @@
-export type RunStatus = "queued" | "claimed" | "running" | "waiting" | "succeeded" | "failed" | "cancelled";
+export type RunStatus = "queued" | "running" | "waiting" | "succeeded" | "failed" | "cancelled";
 declare const runOutputBrand: unique symbol;
 export interface RunHandle<TOutput = unknown> {
     readonly id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helmr/sdk",
-  "version": "0.1.1-rc.1",
+  "version": "0.1.1-rc.2",
   "description": "TypeScript SDK for authoring and triggering Helmr tasks.",
   "type": "module",
   "license": "Apache-2.0",
@@ -43,6 +43,6 @@
   ],
   "dependencies": {
     "@bufbuild/protobuf": "^2.11.0",
-    "@helmr/proto": "0.1.1-rc.1"
+    "@helmr/proto": "0.1.1-rc.2"
   }
 }