@trigger.dev/sdk 3.0.0-beta.40 → 3.0.0-beta.41

package/dist/v3/index.d.ts

@@ -1,4 +1,4 @@
-import { RetryOptions, FetchRetryOptions, TaskRunContext, QueueOptions, InitOutput, MachineCpu, MachineMemory, RunFnParams, InitFnParams, HandleErrorFnParams, HandleErrorResult, MiddlewareFnParams, StartFnParams, SuccessFnParams, FailureFnParams, ListProjectRunsQueryParams, CursorPagePromise, ListRunResponseItem, ListRunsQueryParams, ApiPromise, ReplayRunResponse, CanceledRunResponse, RetrieveRunResponse, ScheduledTaskPayload, CreateScheduleOptions, ScheduleObject, UpdateScheduleOptions, DeletedScheduleObject, ListScheduleOptions, OffsetLimitPagePromise, ImportEnvironmentVariablesParams, EnvironmentVariableResponseBody, EnvironmentVariables, CreateEnvironmentVariableParams, EnvironmentVariableValue, UpdateEnvironmentVariableParams, ApiClientConfiguration } from '@trigger.dev/core/v3';
+import { RetryOptions, FetchRetryOptions, ListProjectRunsQueryParams, CursorPagePromise, ListRunResponseItem, ListRunsQueryParams, ApiPromise, ReplayRunResponse, CanceledRunResponse, RetrieveRunResponse, TaskRunContext, QueueOptions, InitOutput, MachineCpu, MachineMemory, RunFnParams, InitFnParams, HandleErrorFnParams, HandleErrorResult, MiddlewareFnParams, StartFnParams, SuccessFnParams, FailureFnParams, ScheduledTaskPayload, CreateScheduleOptions, ScheduleObject, UpdateScheduleOptions, DeletedScheduleObject, ListScheduleOptions, OffsetLimitPagePromise, ImportEnvironmentVariablesParams, EnvironmentVariableResponseBody, EnvironmentVariables, CreateEnvironmentVariableParams, EnvironmentVariableValue, UpdateEnvironmentVariableParams, ApiClientConfiguration } from '@trigger.dev/core/v3';
 export { ApiClientConfiguration, ApiError, AuthenticationError, BadRequestError, ConflictError, HandleErrorArgs, HandleErrorFunction, ImportEnvironmentVariablesParams, InternalServerError, LogLevel, NotFoundError, PermissionDeniedError, RateLimitError, ResolveEnvironmentVariablesFunction, ResolveEnvironmentVariablesParams, ResolveEnvironmentVariablesResult, RetryOptions, ProjectConfig as TriggerConfig, UnprocessableEntityError, logger } from '@trigger.dev/core/v3';
 import { HttpHandler } from 'msw';
 
@@ -48,6 +48,206 @@ declare const retry: {
     };
 };
 
+type RetrieveRunResult<TOutput> = Prettify<TOutput extends RunHandle<infer THandleOutput> ? Omit<RetrieveRunResponse, "output"> & {
+    output?: THandleOutput;
+} : Omit<RetrieveRunResponse, "output"> & {
+    output?: TOutput;
+}>;
+declare const runs: {
+    replay: typeof replayRun;
+    cancel: typeof cancelRun;
+    retrieve: typeof retrieveRun;
+    list: typeof listRuns;
+    poll: typeof poll;
+};
+declare function listRuns(projectRef: string, params?: ListProjectRunsQueryParams): CursorPagePromise<typeof ListRunResponseItem>;
+declare function listRuns(params?: ListRunsQueryParams): CursorPagePromise<typeof ListRunResponseItem>;
+declare function retrieveRun<TRunId extends RunHandle<any> | string>(runId: TRunId): ApiPromise<RetrieveRunResult<TRunId>>;
+declare function replayRun(runId: string): ApiPromise<ReplayRunResponse>;
+declare function cancelRun(runId: string): ApiPromise<CanceledRunResponse>;
+type PollOptions = {
+    pollIntervalMs?: number;
+};
+declare function poll<TRunHandle extends RunHandle<any> | string>(handle: TRunHandle, options?: {
+    pollIntervalMs?: number;
+}): Promise<(TRunHandle extends RunHandle<infer THandleOutput> ? Omit<{
+    status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE";
+    id: string;
+    isTest: boolean;
+    createdAt: Date;
+    attempts: ({
+        status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED" | "EXECUTING" | "PAUSED";
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        startedAt?: Date | undefined;
+        completedAt?: Date | undefined;
+        error?: {
+            message: string;
+            name?: string | undefined;
+            stackTrace?: string | undefined;
+        } | undefined;
+    } | undefined)[];
+    updatedAt: Date;
+    taskIdentifier: string;
+    isQueued: boolean;
+    isExecuting: boolean;
+    isCompleted: boolean;
+    isSuccess: boolean;
+    isFailed: boolean;
+    isCancelled: boolean;
+    payload?: any;
+    output?: any;
+    schedule?: {
+        id: string;
+        generator: {
+            type: "CRON";
+            expression: string;
+            description: string;
+        };
+        externalId?: string | undefined;
+        deduplicationKey?: string | undefined;
+    } | undefined;
+    idempotencyKey?: string | undefined;
+    version?: string | undefined;
+    startedAt?: Date | undefined;
+    finishedAt?: Date | undefined;
+}, "output"> & {
+    output?: THandleOutput | undefined;
+} : Omit<{
+    status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE";
+    id: string;
+    isTest: boolean;
+    createdAt: Date;
+    attempts: ({
+        status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED" | "EXECUTING" | "PAUSED";
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        startedAt?: Date | undefined;
+        completedAt?: Date | undefined;
+        error?: {
+            message: string;
+            name?: string | undefined;
+            stackTrace?: string | undefined;
+        } | undefined;
+    } | undefined)[];
+    updatedAt: Date;
+    taskIdentifier: string;
+    isQueued: boolean;
+    isExecuting: boolean;
+    isCompleted: boolean;
+    isSuccess: boolean;
+    isFailed: boolean;
+    isCancelled: boolean;
+    payload?: any;
+    output?: any;
+    schedule?: {
+        id: string;
+        generator: {
+            type: "CRON";
+            expression: string;
+            description: string;
+        };
+        externalId?: string | undefined;
+        deduplicationKey?: string | undefined;
+    } | undefined;
+    idempotencyKey?: string | undefined;
+    version?: string | undefined;
+    startedAt?: Date | undefined;
+    finishedAt?: Date | undefined;
+}, "output"> & {
+    output?: TRunHandle | undefined;
+}) extends infer T ? { [K in keyof T]: (TRunHandle extends RunHandle<infer THandleOutput> ? Omit<{
+    status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE";
+    id: string;
+    isTest: boolean;
+    createdAt: Date;
+    attempts: ({
+        status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED" | "EXECUTING" | "PAUSED";
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        startedAt?: Date | undefined;
+        completedAt?: Date | undefined;
+        error?: {
+            message: string;
+            name?: string | undefined;
+            stackTrace?: string | undefined;
+        } | undefined;
+    } | undefined)[];
+    updatedAt: Date;
+    taskIdentifier: string;
+    isQueued: boolean;
+    isExecuting: boolean;
+    isCompleted: boolean;
+    isSuccess: boolean;
+    isFailed: boolean;
+    isCancelled: boolean;
+    payload?: any;
+    output?: any;
+    schedule?: {
+        id: string;
+        generator: {
+            type: "CRON";
+            expression: string;
+            description: string;
+        };
+        externalId?: string | undefined;
+        deduplicationKey?: string | undefined;
+    } | undefined;
+    idempotencyKey?: string | undefined;
+    version?: string | undefined;
+    startedAt?: Date | undefined;
+    finishedAt?: Date | undefined;
+}, "output"> & {
+    output?: THandleOutput | undefined;
+} : Omit<{
+    status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE";
+    id: string;
+    isTest: boolean;
+    createdAt: Date;
+    attempts: ({
+        status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED" | "EXECUTING" | "PAUSED";
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        startedAt?: Date | undefined;
+        completedAt?: Date | undefined;
+        error?: {
+            message: string;
+            name?: string | undefined;
+            stackTrace?: string | undefined;
+        } | undefined;
+    } | undefined)[];
+    updatedAt: Date;
+    taskIdentifier: string;
+    isQueued: boolean;
+    isExecuting: boolean;
+    isCompleted: boolean;
+    isSuccess: boolean;
+    isFailed: boolean;
+    isCancelled: boolean;
+    payload?: any;
+    output?: any;
+    schedule?: {
+        id: string;
+        generator: {
+            type: "CRON";
+            expression: string;
+            description: string;
+        };
+        externalId?: string | undefined;
+        deduplicationKey?: string | undefined;
+    } | undefined;
+    idempotencyKey?: string | undefined;
+    version?: string | undefined;
+    startedAt?: Date | undefined;
+    finishedAt?: Date | undefined;
+}, "output"> & {
+    output?: TRunHandle | undefined;
+})[K]; } : never>;
+
 type Context = TaskRunContext;
 type RequireOne<T, K extends keyof T> = {
     [X in Exclude<keyof T, K>]?: T[X];
@@ -58,9 +258,9 @@ type Queue = RequireOne<QueueOptions, "name">;
 declare function queue(options: {
     name: string;
 } & QueueOptions): Queue;
-type TaskOptions<TPayload = void, TOutput = unknown, TInitOutput extends InitOutput = any> = {
+type TaskOptions<TIdentifier extends string, TPayload = void, TOutput = unknown, TInitOutput extends InitOutput = any> = {
     /** An id for your task. This must be unique inside your project and not change between versions.  */
-    id: string;
+    id: TIdentifier;
     /** The retry settings when an uncaught error is thrown.
      *
      * If omitted it will use the values in your `trigger.config.ts` file.
@@ -195,13 +395,21 @@ type TaskOptions<TPayload = void, TOutput = unknown, TInitOutput extends InitOut
      */
     onFailure?: (payload: TPayload, error: unknown, params: FailureFnParams<TInitOutput>) => Promise<void>;
 };
-type InvokeHandle = {
-    id: string;
+declare const __output: unique symbol;
+type BrandOutput<B> = {
+    [__output]: B;
 };
-type InvokeBatchHandle = {
+type BrandedOutput<T, B> = T & BrandOutput<B>;
+type RunHandle<TOutput> = BrandedOutput<{
+    id: string;
+}, TOutput>;
+/**
+ * A BatchRunHandle can be used to retrieve the runs of a batch trigger in a typesafe manner.
+ */
+type BatchRunHandle<TOutput> = BrandedOutput<{
     batchId: string;
-    runs: string[];
-};
+    runs: Array<RunHandle<TOutput>>;
+}, TOutput>;
 type TaskRunResult<TOutput = any> = {
     ok: true;
     id: string;
@@ -222,19 +430,19 @@ type BatchItem<TInput> = TInput extends void ? {
     payload: TInput;
     options?: TaskRunOptions;
 };
-interface Task<TInput = void, TOutput = any> {
+interface Task<TIdentifier extends string, TInput = void, TOutput = any> {
     /**
      * The id of the task.
      */
-    id: string;
+    id: TIdentifier;
     /**
      * Trigger a task with the given payload, and continue without waiting for the result. If you want to wait for the result, use `triggerAndWait`. Returns the id of the triggered task run.
      * @param payload
      * @param options
-     * @returns InvokeHandle
+     * @returns RunHandle
      * - `id` - The id of the triggered task run.
      */
-    trigger: (payload: TInput, options?: TaskRunOptions) => Promise<InvokeHandle>;
+    trigger: (payload: TInput, options?: TaskRunOptions) => Promise<RunHandle<TOutput>>;
     /**
      * Batch trigger multiple task runs with the given payloads, and continue without waiting for the results. If you want to wait for the results, use `batchTriggerAndWait`. Returns the id of the triggered batch.
      * @param items
@@ -242,7 +450,7 @@ interface Task<TInput = void, TOutput = any> {
      * - `batchId` - The id of the triggered batch.
      * - `runs` - The ids of the triggered task runs.
      */
-    batchTrigger: (items: Array<BatchItem<TInput>>) => Promise<InvokeBatchHandle>;
+    batchTrigger: (items: Array<BatchItem<TInput>>) => Promise<BatchRunHandle<TOutput>>;
     /**
      * Trigger a task with the given payload, and wait for the result. Returns the result of the task run
      * @param payload
@@ -282,6 +490,12 @@ interface Task<TInput = void, TOutput = any> {
      */
     batchTriggerAndWait: (items: Array<BatchItem<TInput>>) => Promise<BatchResult<TOutput>>;
 }
+type AnyTask = Task<string, any, any>;
+type TaskPayload<TTask extends AnyTask> = TTask extends Task<string, infer TInput, any> ? TInput : never;
+type TaskOutput<TTask extends AnyTask> = TTask extends Task<string, any, infer TOutput> ? TOutput : never;
+type TaskOutputHandle<TTask extends AnyTask> = TTask extends Task<string, any, infer TOutput> ? RunHandle<TOutput> : never;
+type TaskBatchOutputHandle<TTask extends AnyTask> = TTask extends Task<string, any, infer TOutput> ? BatchRunHandle<TOutput> : never;
+type TaskIdentifier<TTask extends AnyTask> = TTask extends Task<infer TIdentifier, any, any> ? TIdentifier : never;
 type TaskRunOptions = {
     idempotencyKey?: string;
     maxAttempts?: number;
@@ -291,6 +505,43 @@ type TaskRunOptions = {
     concurrencyKey?: string;
 };
 type TaskRunConcurrencyOptions = Queue;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Trigger a task by its identifier with the given payload. Returns a typesafe `RunHandle`.
+ *
+ * @example
+ *
+ * ```ts
+ * import { tasks, runs } from "@trigger.dev/sdk/v3";
+ * import type { myTask } from "./myTasks"; // Import just the type of the task
+ *
+ * const handle = await tasks.trigger<typeof myTask>("my-task", { foo: "bar" }); // The id and payload are fully typesafe
+ * const run = await runs.retrieve(handle);
+ * console.log(run.output) // The output is also fully typed
+ * ```
+ *
+ * @returns {RunHandle} An object with the `id` of the run. Can be used to retrieve the completed run output in a typesafe manner.
+ */
+declare function trigger<TTask extends AnyTask>(id: TaskIdentifier<TTask>, payload: TaskPayload<TTask>, options?: TaskRunOptions): Promise<TaskOutputHandle<TTask>>;
+/**
+ * Trigger a task by its identifier with the given payload and poll until the run is completed.
+ *
+ * @example
+ *
+ * ```ts
+ * import { tasks, runs } from "@trigger.dev/sdk/v3";
+ * import type { myTask } from "./myTasks"; // Import just the type of the task
+ *
+ * const run = await tasks.triggerAndPoll<typeof myTask>("my-task", { foo: "bar" }); // The id and payload are fully typesafe
+ * console.log(run.output) // The output is also fully typed
+ * ```
+ *
+ * @returns {Run} The completed run, either successful or failed.
+ */
+declare function triggerAndPoll<TTask extends AnyTask>(id: TaskIdentifier<TTask>, payload: TaskPayload<TTask>, options?: TaskRunOptions & PollOptions): Promise<RetrieveRunResult<TaskOutputHandle<TTask>>>;
+declare function batchTrigger<TTask extends AnyTask>(id: TaskIdentifier<TTask>, items: Array<BatchItem<TaskPayload<TTask>>>): Promise<TaskBatchOutputHandle<TTask>>;
 
 /** Creates a task that can be triggered
  * @param options - Task options
@@ -310,7 +561,12 @@ type TaskRunConcurrencyOptions = Queue;
  *
  * @returns A task that can be triggered
  */
-declare function task$1<TInput = void, TOutput = unknown, TInitOutput extends InitOutput = any>(options: TaskOptions<TInput, TOutput, TInitOutput>): Task<TInput, TOutput>;
+declare function task$1<TIdentifier extends string, TInput = void, TOutput = unknown, TInitOutput extends InitOutput = any>(options: TaskOptions<TIdentifier, TInput, TOutput, TInitOutput>): Task<TIdentifier, TInput, TOutput>;
+declare const tasks: {
+    trigger: typeof trigger;
+    triggerAndPoll: typeof triggerAndPoll;
+    batchTrigger: typeof batchTrigger;
+};
 
 type WaitOptions = {
     seconds: number;
@@ -413,20 +669,7 @@ declare const usage: {
     }>;
 };
 
-type RetrieveRunResult = RetrieveRunResponse;
-declare const runs: {
-    replay: typeof replayRun;
-    cancel: typeof cancelRun;
-    retrieve: typeof retrieveRun;
-    list: typeof listRuns;
-};
-declare function listRuns(projectRef: string, params?: ListProjectRunsQueryParams): CursorPagePromise<typeof ListRunResponseItem>;
-declare function listRuns(params?: ListRunsQueryParams): CursorPagePromise<typeof ListRunResponseItem>;
-declare function retrieveRun(runId: string): ApiPromise<RetrieveRunResult>;
-declare function replayRun(runId: string): ApiPromise<ReplayRunResponse>;
-declare function cancelRun(runId: string): ApiPromise<CanceledRunResponse>;
-
-declare function task<TOutput, TInitOutput extends InitOutput>(params: TaskOptions<ScheduledTaskPayload, TOutput, TInitOutput>): Task<ScheduledTaskPayload, TOutput>;
+declare function task<TIdentifier extends string, TOutput, TInitOutput extends InitOutput>(params: TaskOptions<TIdentifier, ScheduledTaskPayload, TOutput, TInitOutput>): Task<TIdentifier, ScheduledTaskPayload, TOutput>;
 /**
  * Creates a new schedule
  * @param options
@@ -540,4 +783,4 @@ declare namespace envvars {
  */
 declare function configure(options: ApiClientConfiguration): void;
 
-export { type CacheEntry, type CacheFunction, type CacheMetadata, type CacheStore, type ComputeUsage, type Context, type CurrentUsage, type Eventually, InMemoryCache, type Task, type TaskOptions, type WaitOptions, configure, createCache, envvars, queue, retry, runs, index as schedules, task$1 as task, usage, wait };
+export { type BatchItem, type BatchResult, type BatchRunHandle, type CacheEntry, type CacheFunction, type CacheMetadata, type CacheStore, type ComputeUsage, type Context, type CurrentUsage, type Eventually, InMemoryCache, type Queue, type RunHandle, type Task, type TaskIdentifier, type TaskOptions, type TaskOutput, type TaskPayload, type TaskRunOptions, type TaskRunResult, type WaitOptions, configure, createCache, envvars, queue, retry, runs, index as schedules, task$1 as task, tasks, usage, wait };

package/dist/v3/index.js

@@ -4,6 +4,7 @@ var v3 = require('@trigger.dev/core/v3');
 var api = require('@opentelemetry/api');
 var semanticConventions = require('@opentelemetry/semantic-conventions');
 var node_async_hooks = require('node:async_hooks');
+var promises = require('timers/promises');
 var zodfetch = require('@trigger.dev/core/v3/zodfetch');
 
 var __defProp = Object.defineProperty;
@@ -19,7 +20,7 @@ var __publicField = (obj, key, value) => {
 };
 
 // package.json
-var version = "3.0.0-beta.40";
+var version = "3.0.0-beta.41";
 
 // src/v3/tracer.ts
 var tracer = new v3.TriggerTracer({
@@ -502,6 +503,64 @@ var retry = {
   fetch: retryFetch,
   interceptFetch
 };
+var runs = {
+  replay: replayRun,
+  cancel: cancelRun,
+  retrieve: retrieveRun,
+  list: listRuns,
+  poll
+};
+function listRuns(paramsOrProjectRef, params) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  if (typeof paramsOrProjectRef === "string") {
+    return apiClient.listProjectRuns(paramsOrProjectRef, params);
+  }
+  return apiClient.listRuns(params);
+}
+__name(listRuns, "listRuns");
+function retrieveRun(runId) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  if (typeof runId === "string") {
+    return apiClient.retrieveRun(runId);
+  } else {
+    return apiClient.retrieveRun(runId.id);
+  }
+}
+__name(retrieveRun, "retrieveRun");
+function replayRun(runId) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.replayRun(runId);
+}
+__name(replayRun, "replayRun");
+function cancelRun(runId) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.cancelRun(runId);
+}
+__name(cancelRun, "cancelRun");
+async function poll(handle, options) {
+  while (true) {
+    const run = await runs.retrieve(handle);
+    if (run.isCompleted) {
+      return run;
+    }
+    await promises.setTimeout(Math.max(options?.pollIntervalMs ?? 5e3, 1e3));
+  }
+}
+__name(poll, "poll");
+
+// src/v3/shared.ts
 function queue(options) {
   return options;
 }
@@ -577,7 +636,13 @@ function createTask(params) {
           spanParentAsLink: true
         });
         span.setAttribute("messaging.message.id", response2.batchId);
-        return response2;
+        const handle = {
+          batchId: response2.batchId,
+          runs: response2.runs.map((id) => ({
+            id
+          }))
+        };
+        return handle;
       }, {
         kind: api.SpanKind.PRODUCER,
         attributes: {
@@ -779,6 +844,59 @@ function createTask(params) {
   return task3;
 }
 __name(createTask, "createTask");
+async function trigger(id, payload, options) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const payloadPacket = await v3.stringifyIO(payload);
+  const handle = await apiClient.triggerTask(id, {
+    payload: payloadPacket.data,
+    options: {
+      queue: options?.queue,
+      concurrencyKey: options?.concurrencyKey,
+      test: v3.taskContext.ctx?.run.isTest,
+      payloadType: payloadPacket.dataType,
+      idempotencyKey: options?.idempotencyKey
+    }
+  });
+  return handle;
+}
+__name(trigger, "trigger");
+async function triggerAndPoll(id, payload, options) {
+  const handle = await trigger(id, payload, options);
+  return runs.poll(handle);
+}
+__name(triggerAndPoll, "triggerAndPoll");
+async function batchTrigger(id, items) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const response = await apiClient.batchTriggerTask(id, {
+    items: await Promise.all(items.map(async (item) => {
+      const payloadPacket = await v3.stringifyIO(item.payload);
+      return {
+        payload: payloadPacket.data,
+        options: {
+          queue: item.options?.queue,
+          concurrencyKey: item.options?.concurrencyKey,
+          test: v3.taskContext.ctx?.run.isTest,
+          payloadType: payloadPacket.dataType,
+          idempotencyKey: item.options?.idempotencyKey
+        }
+      };
+    }))
+  });
+  const handle = {
+    batchId: response.batchId,
+    runs: response.runs.map((id2) => ({
+      id: id2
+    }))
+  };
+  return handle;
+}
+__name(batchTrigger, "batchTrigger");
 async function handleBatchTaskRunExecutionResult(items) {
   const someObjectStoreOutputs = items.some((item) => item.ok && item.outputType === "application/store");
   if (!someObjectStoreOutputs) {
@@ -838,6 +956,11 @@ function task(options) {
   return createTask(options);
 }
 __name(task, "task");
+var tasks = {
+  trigger,
+  triggerAndPoll,
+  batchTrigger
+};
 var wait = {
   for: async (options) => {
     return tracer.startActiveSpan(`wait.for()`, async (span) => {
@@ -1042,47 +1165,6 @@ var usage = {
     };
   }
 };
-var runs = {
-  replay: replayRun,
-  cancel: cancelRun,
-  retrieve: retrieveRun,
-  list: listRuns
-};
-function listRuns(paramsOrProjectRef, params) {
-  const apiClient = v3.apiClientManager.client;
-  if (!apiClient) {
-    throw apiClientMissingError();
-  }
-  if (typeof paramsOrProjectRef === "string") {
-    return apiClient.listProjectRuns(paramsOrProjectRef, params);
-  }
-  return apiClient.listRuns(params);
-}
-__name(listRuns, "listRuns");
-function retrieveRun(runId) {
-  const apiClient = v3.apiClientManager.client;
-  if (!apiClient) {
-    throw apiClientMissingError();
-  }
-  return apiClient.retrieveRun(runId);
-}
-__name(retrieveRun, "retrieveRun");
-function replayRun(runId) {
-  const apiClient = v3.apiClientManager.client;
-  if (!apiClient) {
-    throw apiClientMissingError();
-  }
-  return apiClient.replayRun(runId);
-}
-__name(replayRun, "replayRun");
-function cancelRun(runId) {
-  const apiClient = v3.apiClientManager.client;
-  if (!apiClient) {
-    throw apiClientMissingError();
-  }
-  return apiClient.cancelRun(runId);
-}
-__name(cancelRun, "cancelRun");
 
 // src/v3/schedules/index.ts
 var schedules_exports = {};
@@ -1378,43 +1460,43 @@ function configure(options) {
 }
 __name(configure, "configure");
 
-Object.defineProperty(exports, 'ApiError', {
+Object.defineProperty(exports, "ApiError", {
   enumerable: true,
   get: function () { return v3.ApiError; }
 });
-Object.defineProperty(exports, 'AuthenticationError', {
+Object.defineProperty(exports, "AuthenticationError", {
   enumerable: true,
   get: function () { return v3.AuthenticationError; }
 });
-Object.defineProperty(exports, 'BadRequestError', {
+Object.defineProperty(exports, "BadRequestError", {
   enumerable: true,
   get: function () { return v3.BadRequestError; }
 });
-Object.defineProperty(exports, 'ConflictError', {
+Object.defineProperty(exports, "ConflictError", {
   enumerable: true,
   get: function () { return v3.ConflictError; }
 });
-Object.defineProperty(exports, 'InternalServerError', {
+Object.defineProperty(exports, "InternalServerError", {
   enumerable: true,
   get: function () { return v3.InternalServerError; }
 });
-Object.defineProperty(exports, 'NotFoundError', {
+Object.defineProperty(exports, "NotFoundError", {
   enumerable: true,
   get: function () { return v3.NotFoundError; }
 });
-Object.defineProperty(exports, 'PermissionDeniedError', {
+Object.defineProperty(exports, "PermissionDeniedError", {
   enumerable: true,
   get: function () { return v3.PermissionDeniedError; }
 });
-Object.defineProperty(exports, 'RateLimitError', {
+Object.defineProperty(exports, "RateLimitError", {
   enumerable: true,
   get: function () { return v3.RateLimitError; }
 });
-Object.defineProperty(exports, 'UnprocessableEntityError', {
+Object.defineProperty(exports, "UnprocessableEntityError", {
   enumerable: true,
   get: function () { return v3.UnprocessableEntityError; }
 });
-Object.defineProperty(exports, 'logger', {
+Object.defineProperty(exports, "logger", {
   enumerable: true,
   get: function () { return v3.logger; }
 });
@@ -1427,6 +1509,7 @@ exports.retry = retry;
 exports.runs = runs;
 exports.schedules = schedules_exports;
 exports.task = task;
+exports.tasks = tasks;
 exports.usage = usage;
 exports.wait = wait;
 //# sourceMappingURL=out.js.map