@helmr/sdk 0.1.1-rc.4 → 0.1.1-rc.6

package/dist/runtime/client.d.ts

@@ -1,51 +1,95 @@
-import { type SecretDecls, type Task, type WorkspaceSpec } from "../internal.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";
+import { type AnyTask, type NoPayload, type SecretDecls, type TaskOutput, type TaskRunOptions, type TaskSecrets, type TaskTriggerPayload } from "../internal.js";
+import { type LogSnapshot, type ListRunEventsOptions, type ListRunsOptions, type PendingManualWaitpoint, type PendingWaitpointResponse, type RetrieveRunOptions, type RunHandle, type RunEvent, type RunSnapshot, type RunSummary, type RunWaitOptions, type SubscribeRunEventsOptions, type WaitpointRespondOptions, type WaitpointRef } 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 type TaskTriggerOptions<TSecrets extends SecretDecls> = TaskRunOptions<TSecrets>;
+export type TasksTriggerArgs<TTask extends AnyTask> = [
+    TaskTriggerPayload<TTask>
+] extends [NoPayload] ? [id: string, opts: TaskTriggerOptions<TaskSecrets<TTask>>] : [id: string, payload: TaskTriggerPayload<TTask>, opts: TaskTriggerOptions<TaskSecrets<TTask>>];
+export type DirectTaskTriggerArgs<TTask extends AnyTask> = [
+    TaskTriggerPayload<TTask>
+] extends [NoPayload] ? [opts: TaskTriggerOptions<TaskSecrets<TTask>>] : [payload: TaskTriggerPayload<TTask>, opts: TaskTriggerOptions<TaskSecrets<TTask>>];
+export declare const triggerTaskClientMethod: unique symbol;
 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>;
+    readonly create: (opts: WaitpointCreateOptions) => Promise<Waitpoint>;
+    readonly respond: {
+        (target: PendingManualWaitpoint | WaitpointRef, opts?: WaitpointRespondOptions): Promise<void>;
+        (waitpointId: string, opts?: WaitpointRespondOptions): Promise<void>;
     };
     readonly tokens: {
         readonly create: {
-            (target: PendingWaitpoint | WaitpointRef, opts?: WaitpointTokenCreateOptions): Promise<WaitpointResponseToken>;
-            (runId: string, waitpointId: string, opts?: WaitpointTokenCreateOptions): Promise<WaitpointResponseToken>;
+            (target: PendingManualWaitpoint | WaitpointRef, opts?: WaitpointTokenCreateOptions): Promise<WaitpointResponseToken>;
+            (waitpointId: string, opts?: WaitpointTokenCreateOptions): Promise<WaitpointResponseToken>;
         };
-        readonly complete: {
-            (token: WaitpointResponseToken, opts: WaitpointTokenCompleteOptions): Promise<void>;
-            (id: string, token: string, opts: WaitpointTokenCompleteOptions): Promise<void>;
+        readonly respond: {
+            (token: WaitpointResponseToken, opts: WaitpointTokenRespondOptions): Promise<void>;
+            (id: string, token: string, opts: WaitpointTokenRespondOptions): Promise<void>;
         };
     };
 }
-export type WaitpointTokenAction = "approve" | "deny" | "message" | "reply";
+export interface SchedulesApi {
+    readonly create: (opts: ScheduleCreateOptions) => Promise<Schedule>;
+    readonly update: (id: string, opts: ScheduleUpdateOptions & RetrieveScheduleOptions) => Promise<Schedule>;
+    readonly list: (opts?: ListSchedulesOptions) => Promise<Schedule[]>;
+    readonly retrieve: (id: string, opts?: RetrieveScheduleOptions) => Promise<Schedule>;
+    readonly activate: (id: string, opts?: RetrieveScheduleOptions) => Promise<Schedule>;
+    readonly deactivate: (id: string, opts?: RetrieveScheduleOptions) => Promise<Schedule>;
+    readonly delete: (id: string, opts?: RetrieveScheduleOptions) => Promise<void>;
+}
+export interface ScheduleCreateOptions {
+    readonly deduplicationKey?: string;
+    readonly externalId?: string;
+    readonly projectId?: string;
+    readonly environmentId?: string;
+    readonly task: string;
+    readonly cron: string;
+    readonly timezone?: string;
+    readonly active?: boolean;
+    readonly secretBindings?: Record<string, string>;
+    readonly options?: ScheduleRunOptions;
+}
+export type ScheduleUpdateOptions = Omit<ScheduleCreateOptions, "deduplicationKey"> & {
+    readonly externalId?: string;
+};
+export interface ScheduleRunOptions {
+    readonly deploymentId?: string;
+    readonly version?: string;
+    readonly queue?: string;
+    readonly concurrencyKey?: string;
+    readonly priority?: number;
+    readonly ttl?: string;
+    readonly maxDurationSeconds?: number;
+}
+export interface ListSchedulesOptions {
+    readonly projectId?: string;
+    readonly environmentId?: string;
+    readonly signal?: AbortSignal;
+}
+export interface RetrieveScheduleOptions {
+    readonly projectId?: string;
+    readonly environmentId?: string;
+    readonly signal?: AbortSignal;
+}
+export interface Schedule {
+    readonly id: string;
+    readonly type: "imperative" | "declarative";
+    readonly projectId: string;
+    readonly environmentId: string;
+    readonly task: string;
+    readonly deduplicationKey?: string;
+    readonly externalId?: string;
+    readonly cron: string;
+    readonly timezone: string;
+    readonly active: boolean;
+    readonly status: "active" | "inactive" | "errored";
+    readonly lastError?: string;
+    readonly nextScheduledAt?: string;
+    readonly lastScheduledAt?: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
 type WaitpointTokenExpirationOptions = {
     readonly expiresInSeconds?: number;
     readonly expiresAt?: never;
@@ -54,39 +98,44 @@ type WaitpointTokenExpirationOptions = {
     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 type WaitpointTokenRespondOptions = WaitpointRespondOptions;
+export interface WaitpointCreateOptions {
+    readonly projectId?: string;
+    readonly environmentId?: string;
+    readonly request?: unknown;
+    readonly displayText?: string;
+    readonly expiresAt: string;
+    readonly idempotencyKey?: string;
+    readonly idempotencyKeyExpiresAt?: string;
+    readonly idempotencyKeyTTLSeconds?: number;
+}
+export interface Waitpoint {
+    readonly id: string;
+    readonly projectId: string;
+    readonly environmentId: string;
+    readonly kind: "manual" | "delay";
+    readonly status: "pending" | "completed" | "expired" | "cancelled";
+    readonly request: unknown;
+    readonly displayText: string;
+    readonly expiresAt: string | null;
+    readonly createdAt: string;
+}
 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>>;
+        trigger: <TTask extends AnyTask>(...args: TasksTriggerArgs<TTask>) => Promise<RunHandle<TaskOutput<TTask>>>;
     };
+    [triggerTaskClientMethod]<TTask extends AnyTask>(task: TTask, ...args: DirectTaskTriggerArgs<TTask>): Promise<RunHandle<TaskOutput<TTask>>>;
     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>>;
@@ -102,6 +151,7 @@ export declare class HelmrClient {
         };
     };
     readonly waitpoints: WaitpointsApi;
+    readonly schedules: SchedulesApi;
 }
 export interface RunResponse {
     readonly id: string;
@@ -112,7 +162,7 @@ export interface RunResponse {
     readonly exit_code?: number | null;
     readonly created_at?: string;
     readonly updated_at?: string;
-    readonly pending_wait?: PendingWaitpointResponse | null;
+    readonly pending_waitpoint?: PendingWaitpointResponse | null;
     readonly output?: unknown;
 }
 export interface ListRunsResponse {

package/dist/runtime/run.d.ts

@@ -1,4 +1,4 @@
-export type RunStatus = "queued" | "running" | "waiting" | "succeeded" | "failed" | "cancelled";
+export type RunStatus = "queued" | "running" | "waiting" | "succeeded" | "failed" | "cancelled" | "expired";
 declare const runOutputBrand: unique symbol;
 export interface RunHandle<TOutput = unknown> {
     readonly id: string;
@@ -28,30 +28,29 @@ export interface RunSnapshot<TOutput = unknown> extends RunStateBooleans {
     readonly output?: TOutput;
 }
 export type RunSummary<TOutput = unknown> = RunSnapshot<TOutput>;
-export type PendingWaitpoint = PendingApprovalWaitpoint | PendingMessageWaitpoint;
+export type PendingWaitpoint = PendingManualWaitpoint | PendingDelayWaitpoint;
 interface PendingWaitpointBase {
     readonly runId: string;
     readonly waitpointId: string;
     readonly timeout: number | null;
     readonly requestedAt: string;
+    readonly request: unknown;
+    readonly displayText: string;
 }
-export interface PendingApprovalWaitpoint extends PendingWaitpointBase {
-    readonly kind: "approval";
-    readonly message: string;
+export interface PendingManualWaitpoint extends PendingWaitpointBase {
+    readonly kind: "manual";
 }
-export interface PendingMessageWaitpoint extends PendingWaitpointBase {
-    readonly kind: "message";
-    readonly prompt: string | null;
+export interface PendingDelayWaitpoint extends PendingWaitpointBase {
+    readonly kind: "delay";
 }
 export interface WaitpointRef {
-    readonly runId: string;
     readonly waitpointId: string;
+    readonly kind?: never;
 }
-export interface WaitpointApprovalOptions {
-    readonly reason?: string;
-}
-export interface WaitpointReplyOptions {
-    readonly text: string;
+export interface WaitpointRespondOptions {
+    readonly value?: unknown;
+    readonly externalSubject?: string;
+    readonly metadata?: Record<string, unknown>;
 }
 export interface RunWaitOptions {
     readonly timeoutMs?: number;
@@ -85,31 +84,21 @@ export type RunEvent = {
     readonly observed_seq: number;
     readonly at: string;
 } | {
-    readonly type: "approval_request";
-    readonly run_id: string;
-    readonly waitpoint_id: string;
-    readonly message: string;
-    readonly timeout?: number;
-    readonly at: string;
-} | {
-    readonly type: "approval_decided";
+    readonly type: "waitpoint_request";
     readonly run_id: string;
     readonly waitpoint_id: string;
-    readonly decision: "approved" | "denied";
-    readonly reason?: string;
-    readonly at: string;
-} | {
-    readonly type: "message_request";
-    readonly run_id: string;
-    readonly waitpoint_id: string;
-    readonly prompt?: string;
+    readonly kind: string;
+    readonly displayText: string;
+    readonly request: unknown;
     readonly timeout?: number;
     readonly at: string;
 } | {
-    readonly type: "message_received";
+    readonly type: "waitpoint_resolved";
     readonly run_id: string;
     readonly waitpoint_id: string;
-    readonly text: string;
+    readonly kind: string;
+    readonly resolutionKind: string;
+    readonly value: unknown;
     readonly at: string;
 } | {
     readonly type: "emit";
@@ -118,7 +107,7 @@ export type RunEvent = {
     readonly content: unknown;
     readonly at: string;
 } | {
-    readonly type: "task_complete";
+    readonly type: "task_result";
     readonly run_id: string;
     readonly exit_code: number;
     readonly at: string;
@@ -129,15 +118,15 @@ export type RunEvent = {
     readonly detail?: unknown;
     readonly at: string;
 } | {
-    readonly type: "run_timeout";
+    readonly type: "run_cancelled";
     readonly run_id: string;
-    readonly elapsed_secs: number;
-    readonly limit_secs: number;
+    readonly reason?: string;
     readonly at: string;
 } | {
-    readonly type: "run_cancelled";
+    readonly type: "run_expired";
     readonly run_id: string;
-    readonly reason?: string;
+    readonly ttl?: string;
+    readonly message?: string;
     readonly at: string;
 };
 export interface RunEventRecord {
@@ -164,19 +153,14 @@ export interface LogSnapshot {
     readonly cursor: string;
     readonly truncated: boolean;
 }
-export type PendingWaitpointResponse = {
-    readonly kind: "approval";
+export interface PendingWaitpointResponse {
+    readonly kind: "manual" | "delay";
     readonly waitpoint_id: string;
-    readonly message?: string | null;
     readonly timeout?: number | null;
+    readonly request?: unknown;
+    readonly display_text?: string | null;
     readonly requested_at: string;
-} | {
-    readonly kind: "message";
-    readonly waitpoint_id: string;
-    readonly prompt?: string | null;
-    readonly timeout?: number | null;
-    readonly requested_at: string;
-};
+}
 export declare function runHandle<TOutput = unknown>(id: string, taskId: string): RunHandle<TOutput>;
 export declare function runSnapshot<TOutput = unknown>(snapshot: {
     readonly id: string;

package/dist/schedules.d.ts

@@ -0,0 +1,28 @@
+import { type MarkedTask, type MaybePromise, type SecretDecls, type TaskContext, type TaskConfigBase } from "./internal.js";
+import type { PayloadSchema } from "./schema/payload.js";
+export interface ScheduledTaskPayload {
+    readonly timestamp: Date;
+    readonly lastTimestamp?: Date;
+    readonly timezone: string;
+    readonly scheduleId: string;
+    readonly externalId?: string;
+    readonly upcoming: readonly Date[];
+}
+export type ScheduleCron = string | {
+    readonly pattern: string;
+    readonly timezone?: string;
+};
+type DeclarativeScheduleFields = {
+    readonly cron: ScheduleCron;
+    readonly secretBindings?: Record<string, string>;
+} | {
+    readonly cron?: undefined;
+    readonly secretBindings?: undefined;
+};
+export type ScheduledTaskConfig<TOutput = unknown, TSecrets extends SecretDecls = Record<never, never>> = Omit<TaskConfigBase<TSecrets>, "payload"> & DeclarativeScheduleFields & {
+    readonly payload?: never;
+    readonly run: (payload: ScheduledTaskPayload, ctx: TaskContext) => MaybePromise<TOutput>;
+};
+export declare function task<TOutput = unknown, TSecrets extends SecretDecls = Record<never, never>>(config: ScheduledTaskConfig<TOutput, TSecrets>): MarkedTask<ScheduledTaskPayload, Awaited<TOutput>, TSecrets, typeof scheduledTaskPayloadSchema>;
+declare const scheduledTaskPayloadSchema: PayloadSchema<unknown, ScheduledTaskPayload>;
+export {};

package/dist/schema/payload.d.ts

@@ -0,0 +1,40 @@
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly "~standard": {
+        readonly version: 1;
+        readonly vendor: string;
+        validate(value: unknown): StandardSchemaV1.Result<Output> | PromiseLike<StandardSchemaV1.Result<Output>>;
+        readonly types?: StandardSchemaV1.Types<Input, Output> | undefined;
+    };
+}
+export declare namespace StandardSchemaV1 {
+    interface Types<Input = unknown, Output = Input> {
+        readonly input: Input;
+        readonly output: Output;
+    }
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    interface SuccessResult<Output> {
+        readonly value: Output;
+        readonly issues?: undefined;
+    }
+    interface FailureResult {
+        readonly issues: readonly Issue[];
+    }
+    interface Issue {
+        readonly message: string;
+        readonly path?: readonly (PropertyKey | PathSegment)[];
+    }
+    interface PathSegment {
+        readonly key: PropertyKey;
+    }
+}
+export type PayloadSchema<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output>;
+export type PayloadSchemaInput<TSchema> = TSchema extends StandardSchemaV1<infer Input, any> ? Input : unknown;
+export type PayloadSchemaOutput<TSchema> = TSchema extends StandardSchemaV1<any, infer Output> ? Output : unknown;
+export declare class PayloadSchemaValidationError extends Error {
+    readonly issues: readonly StandardSchemaV1.Issue[];
+    constructor(label: string, issues: readonly StandardSchemaV1.Issue[]);
+    static [Symbol.hasInstance](value: unknown): boolean;
+}
+export declare function assertPayloadSchema(value: unknown, label?: string): asserts value is PayloadSchema;
+export declare function assertStandardSchema(value: unknown, label?: string): asserts value is StandardSchemaV1;
+export declare function parsePayloadWithSchema<TSchema extends StandardSchemaV1<any, any>>(schema: TSchema, payload: unknown, label: string): Promise<PayloadSchemaOutput<TSchema>>;

package/dist/schema/task.d.ts

@@ -3,6 +3,8 @@ export declare const TASK_ID_MAX_LENGTH = 128;
 export declare const DEFAULT_MAX_DURATION_SECONDS = 900;
 export declare const MIN_MAX_DURATION_SECONDS = 5;
 export declare const MAX_DURATION_SECONDS = 86400;
+export declare const QUEUE_NAME_PATTERN: "^[A-Za-z0-9][A-Za-z0-9._/-]{0,255}$";
+export declare const QUEUE_NAME_MAX_LENGTH = 256;
 export declare class TaskIdError extends Error {
     readonly name = "TaskIdError";
     readonly value: string;
@@ -18,3 +20,16 @@ export declare class TaskMaxDurationError extends Error {
 }
 export declare function readOptionalMaxDurationSeconds(value: unknown, label?: string): number;
 export declare function validateOptionalMaxDurationSeconds(value: unknown, label?: string): void;
+export declare class TaskQueueNameError extends Error {
+    readonly name = "TaskQueueNameError";
+    readonly value: string;
+    constructor(value: string);
+}
+export declare class TaskQueueConcurrencyLimitError extends Error {
+    readonly name = "TaskQueueConcurrencyLimitError";
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+export declare function validateQueueName(value: string): void;
+export declare function isValidQueueName(value: string): boolean;
+export declare function validateOptionalQueueConcurrencyLimit(value: unknown): void;

package/dist/task.d.ts

@@ -1,3 +1,6 @@
-import { type SecretDecls, type Task, type TaskConfig, type TaskOutput, type TaskPayload } from "./internal.js";
-export declare function task<TPayload, TOutput, TSecrets extends SecretDecls = Record<never, never>>(config: TaskConfig<TPayload, TOutput, TSecrets>): Task<TPayload, Awaited<TOutput>, TSecrets>;
-export type { Task, TaskConfig, TaskOutput, TaskPayload };
+import { type NoPayload, type SecretDecls, type Task, type TaskConfig, type TaskQueueConfig, type TaskConfigWithPayload, type TaskConfigWithoutPayload, type TaskRunOptions, type TaskOutput, type TaskPayload, type TaskTriggerPayload } from "./internal.js";
+import type { PayloadSchema, PayloadSchemaInput, PayloadSchemaOutput } from "./schema/payload.js";
+export declare function task<TPayloadSchema extends PayloadSchema<any, any>, TOutput, TSecrets extends SecretDecls = Record<never, never>>(config: TaskConfigWithPayload<TPayloadSchema, TOutput, TSecrets>): Task<PayloadSchemaOutput<TPayloadSchema>, Awaited<TOutput>, TSecrets, PayloadSchemaInput<TPayloadSchema>>;
+export declare function task<TOutput = unknown, TSecrets extends SecretDecls = Record<never, never>>(config: TaskConfigWithoutPayload<TOutput, TSecrets>): Task<NoPayload, Awaited<TOutput>, TSecrets, NoPayload>;
+export declare function queue(config: TaskQueueConfig): TaskQueueConfig;
+export type { NoPayload, Task, TaskConfig, TaskOutput, TaskPayload, TaskQueueConfig, TaskRunOptions, TaskTriggerPayload };

package/dist/trigger.d.ts

@@ -1,25 +1,15 @@
-import type { SecretDecls, Task, WorkspaceSpec } from "./internal.js";
+import type { AnyTask, NoPayload, SecretDecls, TaskOutput, TaskRunOptions, TaskSecrets, TaskTriggerPayload } from "./internal.js";
 import { HelmrClient } from "./runtime/client.js";
 import type { RunHandle } from "./runtime/run.js";
 export declare function getDefaultClient(): HelmrClient;
-export type TriggerSecrets<TSecrets extends SecretDecls> = {
-    readonly [K in keyof TSecrets]: string;
-};
-export type TriggerOptions<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: TriggerSecrets<TSecrets>;
-});
+export type TriggerOptions<TSecrets extends SecretDecls> = TaskRunOptions<TSecrets>;
+export type TriggerArgs<TTask extends AnyTask> = [
+    TaskTriggerPayload<TTask>
+] extends [NoPayload] ? [id: string, opts: TriggerOptions<TaskSecrets<TTask>>] : [id: string, payload: TaskTriggerPayload<TTask>, opts: TriggerOptions<TaskSecrets<TTask>>];
+export type TaskTriggerArgs<TTask extends AnyTask> = [
+    TaskTriggerPayload<TTask>
+] extends [NoPayload] ? [opts: TriggerOptions<TaskSecrets<TTask>>] : [payload: TaskTriggerPayload<TTask>, opts: TriggerOptions<TaskSecrets<TTask>>];
 export declare const tasks: {
-    trigger<TPayload, TOutput, TSecrets extends SecretDecls>(task: Task<TPayload, TOutput, TSecrets>, opts: TriggerOptions<TPayload, TSecrets>): Promise<RunHandle<TOutput>>;
+    trigger<TTask extends AnyTask>(...args: TriggerArgs<TTask>): Promise<RunHandle<TaskOutput<TTask>>>;
 };
+export declare function triggerTask<TTask extends AnyTask>(task: TTask, ...args: TaskTriggerArgs<TTask>): Promise<RunHandle<TaskOutput<TTask>>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helmr/sdk",
-  "version": "0.1.1-rc.4",
+  "version": "0.1.1-rc.6",
   "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.4"
+    "@helmr/proto": "0.1.1-rc.6"
   }
 }

package/dist/runtime/source.d.ts

@@ -1,7 +0,0 @@
-import type { WorkspaceSpec } from "../internal.js";
-export type RunWorkspace = {
-    readonly repository: string;
-    readonly ref: string;
-    readonly subpath?: string;
-};
-export declare function runWorkspaceFromSpec(spec: WorkspaceSpec): RunWorkspace;