Method startWorkflow

src/node/services/workflows/WorkflowService.ts:491–543

(input: StartWorkflowInput)

  }

  async startWorkflow(input: StartWorkflowInput): Promise<StartNamedWorkflowResult> {
    const createdRun = await this.createWorkflowRun(input);
    const runId = createdRun.id;
    await this.notifyRunStatusChanged(createdRun);
    await input.onRunCreated?.({ runId, status: "pending", result: null, run: createdRun });
    if (isAbortSignalAborted(input.abortSignal)) {
      await this.interruptRun({ workspaceId: input.workspaceId, runId });
      throw new Error(`Workflow run interrupted: ${runId}`);
    }

    const runnerAbortController = new AbortController();
    let unregisterRunnerAbort: () => void = () => undefined;
    const abortInterrupt = this.interruptRunOnAbort(
      input.workspaceId,
      runId,
      input.abortSignal,
      runnerAbortController
    );
    try {
      const runner = await this.createRunner(runId);
      const result = await runner.run(runId, {
        abortSignal: runnerAbortController.signal,
        ...(input.backgroundOnMessageQueued !== undefined
          ? { backgroundOnMessageQueued: input.backgroundOnMessageQueued }
          : {}),
        onLeaseAcquired: () => {
          unregisterRunnerAbort = this.registerActiveRunnerAbortController(
            runId,
            runnerAbortController
          );
        },
      });
      await this.notifyRunStatusChanged(createdRun, "completed");
      return { runId, status: "completed", result };
    } catch (error) {
      if (error instanceof WorkflowRunBackgroundedError) {
        await this.runStore.setAttentionPolicy(runId, "notify_on_terminal");
        await this.notifyRunStatusChanged(createdRun, "backgrounded");
        if (!runnerAbortController.signal.aborted) {
          void this.runInBackground(runId, "Backgrounded workflow run failed:", {
            projectTrusted: input.projectTrusted,
          }).catch(() => undefined);
        }
        return { runId, status: "backgrounded", result: null };
      }
      await this.notifyLatestRunStatus(runId);
      throw error;
    } finally {
      abortInterrupt.remove();
      await abortInterrupt.wait();
      unregisterRunnerAbort();
    }
  }

  private async resumeCrashRecoveredRun(input: {
    runId: string;