@usehelical/workflows 0.0.1-alpha.18 → 0.0.1-alpha.19

package/dist/index.js

@@ -1,5 +1,5 @@
-import { withDbRetry, getRun, deserialize, returnOrThrowOperationResult, executeAndRecordOperation, serialize, deserializeError, WorkflowNotFoundError, createExecutionContext, runWithExecutionContext, RunCancelledError, serializeError, MaxRecoveryAttemptsExceededError, RunNotFoundError, TERMINAL_STATES, UnknownError, getExecutionContext, RunTimedOutError, RunDeadlineExceededError } from './chunk-6L2Y7WUY.js';
-export { BaseError, ErrorType, FatalError, MaxRecoveryAttemptsExceededError, MaxRetriesExceededError, OperationTimedOutError, RunCancelledError, RunDeadlineExceededError, RunNotFoundError, RunOutsideOfWorkflowError, RunTimedOutError, SerializationError, UnknownError, WorkflowNotFoundError } from './chunk-6L2Y7WUY.js';
+import { getState2, sendMessage, resumeRun, cancelRun, createRunHandle, queueWorkflow, runWorkflow, waitForRunResult, getRunStatus, withDbRetry, getState, getRun, executeWorkflow, deserialize, MaxRecoveryAttemptsExceededError, RunNotFoundError } from './chunk-7I6XZ2V3.js';
+export { BaseError, ErrorType, FatalError, MaxRecoveryAttemptsExceededError, MaxRetriesExceededError, OperationTimedOutError, RunCancelledError, RunDeadlineExceededError, RunNotFoundError, RunOutsideOfWorkflowError, RunTimedOutError, SerializationError, UnknownError, WorkflowNotFoundError } from './chunk-7I6XZ2V3.js';
 import crypto from 'crypto';
 import { Kysely, PostgresDialect, sql } from 'kysely';
 import { Pool } from 'pg';
@@ -121,15 +121,6 @@ function splitSubscriptionKey(subscriptionKey) {
   return subscriptionKey.split("::");
 }
 
-// src/internal/db/queries/get-state.ts
-async function getState(db, runId, key) {
-  const result = await db.selectFrom("state").select(["key", "value", "change_id"]).where("run_id", "=", runId).where("key", "=", key).executeTakeFirst();
-  if (!result) {
-    return void 0;
-  }
-  return result.value;
-}
-
 // src/internal/db/queries/get-state-batch.ts
 async function getStateBatch(db, stateRetrievalRequests) {
   const results = await db.selectFrom("state").select(["key", "value", "change_id", "run_id", "change_id"]).where(
@@ -271,347 +262,6 @@ function getMessageRetrievalRequests(subscriptionKeys) {
     messageType
   }));
 }
-async function recordRunResult(db, runId, result, cancelled) {
-  const [{ change_id }] = await db.updateTable("runs").set({
-    output: result.result,
-    error: result.error,
-    status: cancelled ? "cancelled" : result.error ? "error" : "success",
-    updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
-  }).where("id", "=", runId).returning(["change_id"]).execute();
-  return change_id;
-}
-
-// src/internal/execute-workflow.ts
-async function executeWorkflow(ctx, params) {
-  const { db, runRegistry } = ctx;
-  const { options, runId, runPath, fn, args, operations } = params;
-  const abortController = new AbortController();
-  const [deadline, deadlineReason] = getDeadlineAndReason({
-    timeout: options?.timeout,
-    deadline: options?.deadline
-  });
-  const runStore = createExecutionContext({
-    ctx,
-    abortSignal: AbortSignal.any(
-      [abortController.signal].concat(deadline ? [AbortSignal.timeout(deadline - Date.now())] : [])
-    ),
-    runId,
-    runPath,
-    operations
-  });
-  const executionPromise = (async () => {
-    try {
-      const result = await runWithExecutionContext(runStore, async () => {
-        return await runWithTimeout(async () => {
-          return await fn(...args);
-        }, deadlineReason);
-      });
-      await recordRunResult(db, runId, { result: result ? serialize(result) : void 0 });
-      return result;
-    } catch (error) {
-      if (error instanceof RunCancelledError) {
-        await recordRunResult(db, runId, { error: serializeError(error) }, true);
-      } else {
-        await recordRunResult(db, runId, { error: serializeError(error) });
-      }
-      throw error;
-    } finally {
-      runRegistry.unregisterRun(runId);
-    }
-  })();
-  runRegistry.registerRun(runId, {
-    store: runStore,
-    promise: executionPromise,
-    abortController
-  });
-}
-function getDeadlineAndReason({
-  timeout,
-  deadline
-}) {
-  const now = Date.now();
-  const timeoutDeadline = timeout ? now + timeout : void 0;
-  if (timeoutDeadline && deadline) {
-    return [
-      Math.min(timeoutDeadline, deadline),
-      timeoutDeadline < deadline ? "timeout" : "deadline"
-    ];
-  } else if (timeoutDeadline) {
-    return [timeoutDeadline, "timeout"];
-  } else if (deadline) {
-    return [deadline, "deadline"];
-  }
-  return [void 0, void 0];
-}
-async function runWithTimeout(fn, deadlineReason) {
-  const { abortSignal } = getExecutionContext();
-  const abortPromise = new Promise((_, reject) => {
-    abortSignal.throwIfAborted();
-    abortSignal.addEventListener(
-      "abort",
-      () => {
-        if (abortSignal.reason?.name === "TimeoutError") {
-          reject(new RunTimedOutError());
-          return;
-        }
-        reject(new RunCancelledError());
-      },
-      { once: true }
-    );
-  });
-  const callPromise = fn();
-  try {
-    return await Promise.race([callPromise, abortPromise]);
-  } catch (error) {
-    if (error instanceof RunTimedOutError) {
-      if (deadlineReason === "timeout") {
-        throw new RunTimedOutError();
-      } else if (deadlineReason === "deadline") {
-        throw new RunDeadlineExceededError();
-      }
-      throw error;
-    }
-    await callPromise.catch(() => {
-    });
-    throw error;
-  }
-}
-
-// src/internal/db/queries/get-run-status.ts
-async function getRunStatus(db, runId) {
-  const run = await db.selectFrom("runs").select("status").where("id", "=", runId).executeTakeFirst();
-  if (!run) {
-    throw new RunNotFoundError(runId);
-  }
-  return run.status;
-}
-
-// src/internal/get-run-status.ts
-async function getRunStatus2(ctx, runId) {
-  const { db } = ctx;
-  if (ctx.type === "runtime") {
-    const { runRegistry } = ctx;
-    const run = runRegistry.getRun(runId);
-    if (run) {
-      return deriveRunStatus(run);
-    }
-    return getRunStatus(db, runId);
-  }
-  if (ctx.type === "execution") {
-    const { operationManager, runRegistry } = ctx;
-    const op = operationManager.getOperationResult();
-    if (op) {
-      returnOrThrowOperationResult(op);
-    }
-    const status = await executeAndRecordOperation(operationManager, "getRunStatus", async () => {
-      const run = runRegistry.getRun(runId);
-      if (run) {
-        return deriveRunStatus(run);
-      }
-      return await getRunStatus(db, runId);
-    });
-    return status;
-  }
-  return await getRunStatus(db, runId);
-}
-async function deriveRunStatus(runEntry) {
-  if (runEntry.store.abortSignal.aborted) {
-    return "cancelled";
-  }
-  const promiseState = runEntry.getPromiseState();
-  if (promiseState === "pending") {
-    return "pending";
-  }
-  if (promiseState === "fulfilled") {
-    return "success";
-  }
-  return "error";
-}
-
-// src/internal/wait-for-run-result.ts
-async function waitForRunResult(ctx, runId) {
-  if (ctx.type === "execution") {
-    const { operationManager } = ctx;
-    const op = operationManager.getOperationResult();
-    if (op) {
-      returnOrThrowOperationResult(op);
-    }
-    const result = await executeAndRecordOperation(
-      operationManager,
-      "waitForRunResult",
-      async () => {
-        return await getOrSubscribeToRunResult(ctx, runId);
-      }
-    );
-    return result;
-  }
-  return await getOrSubscribeToRunResult(ctx, runId);
-}
-async function getOrSubscribeToRunResult(ctx, runId) {
-  const { db, runEventBus } = ctx;
-  const run = await getRun(db, runId);
-  if (!run) {
-    return {
-      error: new RunNotFoundError(runId),
-      success: false
-    };
-  }
-  switch (run.status) {
-    case "success":
-      return {
-        data: run.output ? deserialize(run.output) : void 0,
-        success: true
-      };
-    case "error":
-      return {
-        error: run.error ? deserializeError(run.error) : new UnknownError(),
-        success: false
-      };
-    case "cancelled":
-      return {
-        error: new RunCancelledError(),
-        success: false
-      };
-    case "max_recovery_attempts_exceeded":
-      return {
-        error: run.error ? deserializeError(run.error) : new MaxRecoveryAttemptsExceededError(runId, run.recoveryAttempts),
-        success: false
-      };
-  }
-  return new Promise((resolve, reject) => {
-    const unsubscribe = runEventBus.subscribe(runId, "*", async (e) => {
-      if (TERMINAL_STATES.includes(e.status)) {
-        unsubscribe();
-        try {
-          const run2 = await getRun(db, runId);
-          if (!run2) {
-            reject(new RunNotFoundError(runId));
-            return;
-          }
-          switch (run2.status) {
-            case "success":
-              resolve({
-                data: run2.output ? deserialize(run2.output) : void 0,
-                success: true
-              });
-              return;
-            case "error":
-              resolve({
-                error: run2.error ? deserializeError(run2.error) : new UnknownError(),
-                success: false
-              });
-              return;
-            case "cancelled":
-              resolve({
-                error: new RunCancelledError(),
-                success: false
-              });
-              return;
-            case "max_recovery_attempts_exceeded":
-              resolve({
-                error: run2.error ? deserializeError(run2.error) : new MaxRecoveryAttemptsExceededError(runId, run2.recoveryAttempts),
-                success: false
-              });
-              return;
-          }
-        } catch (error) {
-          if (error instanceof RunNotFoundError) {
-            reject(error);
-            return;
-          }
-          resolve({
-            error,
-            success: false
-          });
-        }
-      }
-    });
-  });
-}
-
-// src/internal/run.ts
-function createRunHandle(runtimeContext, id) {
-  return {
-    id,
-    getStatus: () => getRunStatus2(runtimeContext, id),
-    waitForResult: () => waitForRunResult(runtimeContext, id)
-  };
-}
-async function insertPendingRun(db, options) {
-  const result = await db.insertInto("runs").values({
-    id: options.runId,
-    path: options.path,
-    inputs: options.inputs,
-    executor_id: options.executorId,
-    workflow_name: options.workflowName,
-    status: "pending",
-    started_at_epoch_ms: sql`(extract(epoch from now()) * 1000)::bigint`,
-    created_at: sql`(extract(epoch from now()) * 1000)::bigint`,
-    updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
-  }).returning(["id", "path", "change_id"]).executeTakeFirst();
-  return {
-    runId: result.id,
-    path: result.path,
-    changeId: result.change_id
-  };
-}
-
-// src/internal/run-workflow.ts
-async function runWorkflow(ctx, workflowName, args = [], options = {}) {
-  const { db, executorId, workflowsMap, type } = ctx;
-  const workflow = workflowsMap[workflowName];
-  if (!workflow) {
-    throw new WorkflowNotFoundError(workflowName);
-  }
-  const newRunId = options.id ?? crypto.randomUUID();
-  let newRunPath = [];
-  if (type === "execution") {
-    const { operationManager, runPath } = ctx;
-    const op = operationManager.getOperationResult();
-    if (op) {
-      if (op.error) {
-        throw deserializeError(op.error);
-      }
-      const newRun2 = deserialize(op.result);
-      return createRunHandle(ctx, newRun2.runId);
-    }
-    const newRun = await executeAndRecordOperation(operationManager, "runWorkflow", async () => {
-      const newRun2 = {
-        runId: newRunId,
-        runPath: [...runPath, newRunId],
-        workflowName
-      };
-      withDbRetry(async () => {
-        return await insertPendingRun(db, {
-          ...newRun2,
-          path: newRun2.runPath,
-          inputs: serialize(args),
-          executorId
-        });
-      });
-      return newRun2;
-    });
-    newRunPath = newRun.runPath;
-  }
-  if (type === "runtime") {
-    const { path } = await insertPendingRun(db, {
-      runId: newRunId,
-      path: [newRunId],
-      inputs: serialize(args),
-      executorId,
-      workflowName
-    });
-    newRunPath = path;
-  }
-  await executeWorkflow(ctx, {
-    runId: newRunId,
-    runPath: newRunPath,
-    fn: workflow.fn,
-    args,
-    options
-  });
-  return createRunHandle(ctx, newRunId);
-}
 
 // src/internal/context/run-registry.ts
 var RunRegistry = class {
@@ -854,136 +504,6 @@ var RunEventBus = class {
     this.pollingLoop.stop();
   }
 };
-async function cancelRun(runId, db, options = {}) {
-  if (options.cascade) {
-    return db.transaction().execute(async (tx) => {
-      const result = await tx.updateTable("runs").set({
-        status: "cancelled",
-        updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
-      }).where((eb) => eb.and([eb("id", "=", runId), eb("status", "not in", TERMINAL_STATES)])).returning(["change_id", "path"]).executeTakeFirst();
-      if (!result) {
-        const exists = await tx.selectFrom("runs").select([]).where("id", "=", runId).executeTakeFirst();
-        if (exists) {
-          return void 0;
-        }
-        throw new RunNotFoundError(runId);
-      }
-      await sql`
-          UPDATE runs
-          SET 
-              status = ${"cancelled"},
-              updated_at = (extract(epoch from now()) * 1000)::bigint
-          WHERE path @> ARRAY[${runId}]::text[]
-          AND id != ${runId}
-          AND status NOT IN (${"cancelled"}, ${"success"}, ${"error"})
-      `.execute(tx);
-      return {
-        path: result.path,
-        changeId: result.change_id
-      };
-    });
-  } else {
-    const result = await db.updateTable("runs").set({
-      status: "cancelled",
-      updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
-    }).where((eb) => eb.and([eb("id", "=", runId), eb("status", "not in", TERMINAL_STATES)])).returning(["path", "change_id"]).executeTakeFirst();
-    if (!result) {
-      throw new RunNotFoundError(runId);
-    }
-    return {
-      path: result.path,
-      changeId: result.change_id
-    };
-  }
-}
-
-// src/internal/cancel-run.ts
-async function cancelRun2(ctx, runId, options = {}) {
-  if (ctx.type === "execution" || ctx.type === "runtime") {
-    const { db, runRegistry } = ctx;
-    const run = await cancelRun(runId, db, options);
-    if (!run) {
-      return;
-    }
-    if (options.cascade) {
-      for (const pathPart of run.path) {
-        const run2 = runRegistry.getRun(pathPart);
-        if (run2) {
-          run2.abortController.abort();
-        }
-      }
-      return;
-    }
-    runRegistry.getRun(runId)?.abortController.abort();
-  } else {
-    const { db } = ctx;
-    const run = await cancelRun(runId, db, options);
-    if (!run) {
-      return;
-    }
-  }
-}
-async function enqueueRun(db, options) {
-  const result = await db.insertInto("runs").values({
-    id: options.runId,
-    path: options.path,
-    inputs: options.inputs,
-    queue_name: options.queueName,
-    queue_partition_key: options.queuePartitionKey,
-    queue_deduplication_id: options.deduplicationId,
-    workflow_name: options.workflowName,
-    status: "queued",
-    recovery_attempts: options.recoveryAttempts,
-    created_at: sql`(extract(epoch from now()) * 1000)::bigint`,
-    updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
-  }).onConflict((oc) => oc.columns(["queue_name", "queue_deduplication_id"]).doNothing()).returning(["id", "change_id"]).executeTakeFirst();
-  return {
-    runId: result?.id,
-    changeId: result?.change_id
-  };
-}
-
-// src/internal/queue-workflow.ts
-async function queueWorkflow(ctx, queueName, workflowName, args, options) {
-  const { db } = ctx;
-  const newRunId = options?.id ?? crypto.randomUUID();
-  if (ctx.type === "execution") {
-    const { operationManager, runPath } = ctx;
-    const op = operationManager.getOperationResult();
-    if (op) {
-      if (op.error) {
-        throw deserializeError(op.error);
-      }
-      const newRunId2 = deserialize(op.result);
-      return createRunHandle(ctx, newRunId2);
-    }
-    await executeAndRecordOperation(operationManager, "queueWorkflow", async () => {
-      const { runId } = await enqueueRun(db, {
-        runId: newRunId,
-        path: [...runPath, newRunId],
-        inputs: serialize(args),
-        workflowName,
-        queueName,
-        timeout: options?.timeout,
-        deadline: options?.deadline
-      });
-      return runId;
-    });
-    return createRunHandle(ctx, newRunId);
-  }
-  await withDbRetry(
-    async () => await enqueueRun(db, {
-      runId: newRunId,
-      path: [newRunId],
-      inputs: serialize(args),
-      workflowName,
-      queueName,
-      timeout: options?.timeout,
-      deadline: options?.deadline
-    })
-  );
-  return createRunHandle(ctx, newRunId);
-}
 async function dequeueRun(tx, runId, executorId) {
   const result = await tx.updateTable("runs").set({
     status: "pending",
@@ -1096,8 +616,8 @@ var QueueManager = class {
   pollingLoop;
   queues;
   async handlePoll() {
-    for (const [queueName, queue] of Object.entries(this.queues)) {
-      await this.dispatch(queueName, queue);
+    for (const queue of this.queues) {
+      await this.dispatch(queue.name, queue);
     }
   }
   async dispatch(queueName, queue) {
@@ -1211,122 +731,6 @@ function createPgDriver({ connectionString }) {
     db: new Kysely({ dialect: new PostgresDialect({ pool }) })
   };
 }
-var INTERNAL_QUEUE_NAME = "_helical_internal_queue";
-async function resumeRun(db, runId) {
-  const result = await db.updateTable("runs").set({
-    status: "queued",
-    queue_name: INTERNAL_QUEUE_NAME,
-    deadline_epoch_ms: null,
-    timeout_ms: null,
-    recovery_attempts: 0,
-    started_at_epoch_ms: sql`(extract(epoch from now()) * 1000)::bigint`,
-    updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
-  }).where("id", "=", runId).where("status", "=", "pending").execute();
-  if (!result) {
-    throw new RunNotFoundError(runId);
-  }
-}
-
-// src/internal/resume-run.ts
-async function resumeRun2(ctx, runId) {
-  const { db } = ctx;
-  if (ctx.type === "execution") {
-    const { operationManager } = ctx;
-    const op = operationManager.getOperationResult();
-    if (op) {
-      returnOrThrowOperationResult(op);
-    }
-    await executeAndRecordOperation(operationManager, "resumeRun", async () => {
-      await withDbRetry(async () => await resumeRun(db, runId));
-    });
-  } else {
-    await withDbRetry(async () => await resumeRun(db, runId));
-  }
-}
-
-// src/internal/db/commands/insert-message.ts
-async function insertMessage(db, options) {
-  return await db.insertInto("messages").values({
-    destination_run_id: options.destinationWorkflowId,
-    type: options.messageType,
-    payload: options.data
-  }).execute();
-}
-
-// src/internal/send-message.ts
-async function sendMessage(ctx, target, name, data) {
-  const { db } = ctx;
-  const destinationWorkflowId = typeof target === "string" ? target : target.id;
-  const messageType = typeof name === "string" ? name : name.name;
-  const serializedData = serialize(data);
-  if (ctx.type === "execution") {
-    const { operationManager } = ctx;
-    const op = operationManager.getOperationResult();
-    if (op) {
-      return returnOrThrowOperationResult(op);
-    }
-    await executeAndRecordOperation(operationManager, "sendMessage", async () => {
-      await insertMessage(db, {
-        destinationWorkflowId,
-        messageType,
-        data: serializedData
-      });
-    });
-  } else {
-    await insertMessage(db, {
-      destinationWorkflowId,
-      messageType,
-      data: serializedData
-    });
-  }
-}
-
-// src/internal/get-state.ts
-var StateNotAvailableError = class extends Error {
-};
-async function getState2(ctx, target, key) {
-  const { db, stateEventBus } = ctx;
-  const destinationWorkflowId = typeof target === "string" ? target : target.id;
-  const stateKey = typeof key === "string" ? key : key.name;
-  if (ctx.type === "execution") {
-    const { operationManager } = ctx;
-    const op = operationManager.getOperationResult();
-    if (op) {
-      return returnOrThrowOperationResult(op);
-    }
-  }
-  while (true) {
-    try {
-      return await withDbRetry(async () => {
-        const state = await getState(db, destinationWorkflowId, stateKey);
-        if (!state) {
-          throw new StateNotAvailableError();
-        }
-        if (ctx.type === "execution") {
-          const { operationManager } = ctx;
-          await executeAndRecordOperation(operationManager, "getState", async () => {
-            return state;
-          });
-        }
-        return deserialize(state);
-      });
-    } catch (error) {
-      if (error instanceof StateNotAvailableError) {
-        await waitForStateNotification(stateEventBus, destinationWorkflowId, stateKey);
-        continue;
-      }
-      throw error;
-    }
-  }
-}
-async function waitForStateNotification(stateEventBus, runId, key) {
-  return new Promise((resolve) => {
-    const unsubscribe = stateEventBus.subscribe(runId, key, (state) => {
-      unsubscribe();
-      resolve(state);
-    });
-  });
-}
 
 // src/main/worker/worker.ts
 function createWorker(props) {
@@ -1336,7 +740,13 @@ function createWorker(props) {
   const executorId = props.options.instanceId || crypto.randomUUID();
   const runRegistry = new RunRegistry();
   const runEventBus = new RunEventBus(db);
-  const workflowsMap = props.workflows;
+  const workflowsMap = props.workflows.reduce(
+    (acc, workflow) => {
+      acc[workflow.name] = workflow;
+      return acc;
+    },
+    {}
+  );
   const runtimeContext = {
     type: "runtime",
     db,
@@ -1345,7 +755,7 @@ function createWorker(props) {
     stateEventBus,
     runRegistry,
     workflowsMap,
-    queueRegistry: props.queues || {},
+    queueRegistry: props.queues || [],
     runEventBus
   };
   const notifySetupPromise = setupPostgresNotify(client, {
@@ -1357,7 +767,7 @@ function createWorker(props) {
   queueManager.start();
   recoverPendingRuns(runtimeContext);
   return {
-    runWorkflow: async (workflowName, argsOrOptions, options) => {
+    runWorkflow: async (workflow, argsOrOptions, options) => {
       await notifySetupPromise;
       let args, opts;
       if (argsOrOptions !== void 0) {
@@ -1368,9 +778,9 @@ function createWorker(props) {
           opts = argsOrOptions;
         }
       }
-      return runWorkflow(runtimeContext, workflowName, args, opts);
+      return runWorkflow(runtimeContext, workflow.name, args, opts);
     },
-    queueWorkflow: async (queueName, workflowName, argsOrOptions, options) => {
+    queueWorkflow: async (queue, workflow, argsOrOptions, options) => {
       await notifySetupPromise;
       let args, opts;
       if (argsOrOptions !== void 0) {
@@ -1381,19 +791,14 @@ function createWorker(props) {
           opts = argsOrOptions;
         }
       }
-      return queueWorkflow(runtimeContext, queueName, workflowName, args, opts);
+      return queueWorkflow(runtimeContext, queue.name, workflow.name, args, opts);
     },
     getRun: async (runId) => {
       await notifySetupPromise;
       return createRunHandle(runtimeContext, runId);
     },
-    waitForRunResult: async (runId) => {
-      await notifySetupPromise;
-      return waitForRunResult(runtimeContext, runId);
-    },
-    cancelRun: async (runId) => cancelRun2(runtimeContext, runId),
-    resumeRun: async (runId) => resumeRun2(runtimeContext, runId),
-    getRunStatus: async (runId) => getRunStatus2(runtimeContext, runId),
+    cancelRun: async (runId) => cancelRun(runtimeContext, runId),
+    resumeRun: async (runId) => resumeRun(runtimeContext, runId),
     sendMessage: async (target, name, data) => {
       await notifySetupPromise;
       return sendMessage(runtimeContext, target, name, data);
@@ -1437,13 +842,13 @@ function createClient(options) {
       }
       return queueWorkflow(clientContext, queueName, workflowName, args, opts);
     },
-    cancelRun: async (runId) => cancelRun2(clientContext, runId),
-    resumeRun: async (runId) => resumeRun2(clientContext, runId),
+    cancelRun: async (runId) => cancelRun(clientContext, runId),
+    resumeRun: async (runId) => resumeRun(clientContext, runId),
     getRun: async (runId) => {
       await notifySetupPromise;
       return createRunHandle(clientContext, runId);
     },
-    getRunStatus: async (runId) => getRunStatus2(clientContext, runId),
+    getRunStatus: async (runId) => getRunStatus(clientContext, runId),
     waitForRunResult: async (runId) => waitForRunResult(clientContext, runId),
     sendMessage: async (runId, name, data) => {
       await notifySetupPromise;