Method executeTask

packages/trigger-sdk/src/io.ts:1251–1374

()

    this.#detectAutoYield("before_execute_task", 1500);

    const executeTask = async () => {
      try {
        const result = await callback(task, this);

        if (task.status === "WAITING" && task.callbackUrl) {
          this._logger.debug("Waiting for remote callback", {
            idempotencyKey,
            task,
          });
          return {} as T;
        }

        const output = this._outputSerializer.serialize(result);

        this._logger.debug("Completing using output", {
          idempotencyKey,
          task,
        });

        this.#detectAutoYield("before_complete_task", 500, task, output);

        const completedTask = await this.#doCompleteTask(task.id, {
          output,
          properties: task.outputProperties ?? undefined,
        });

        if (!completedTask) {
          this.#forceYield("before_complete_task", task, output);
          throw new Error("Failed to complete task"); // this shouldn't actually happen, because forceYield will throw
        }

        if (completedTask.forceYield) {
          this._logger.debug("Forcing yield after task completed", {
            idempotencyKey,
          });

          this.#forceYield("after_complete_task");
        }

        this._stats.executedTasks++;

        if (completedTask.status === "CANCELED") {
          throw new CanceledWithTaskError(completedTask);
        }

        this.#detectAutoYield("after_complete_task", 500);

        const deserializedOutput = this._outputSerializer.deserialize<T>(output);

        return options?.parseOutput ? options.parseOutput(deserializedOutput) : deserializedOutput;
      } catch (error) {
        if (isTriggerError(error)) {
          throw error;
        }

        let skipRetrying = false;

        if (onError) {