Method requestAgentFinalReportForTimeout

src/node/services/taskService.ts:5010–5144

(
    taskId: string,
    options: {
      workflowRunId: string;
      stepId: string;
      inputHash: string;
      finalizationToken: string;
      finalInstructions?: string;
    }
  )

  }

  async requestAgentFinalReportForTimeout(
    taskId: string,
    options: {
      workflowRunId: string;
      stepId: string;
      inputHash: string;
      finalizationToken: string;
      finalInstructions?: string;
    }
  ): Promise<"prompted" | "queued" | "already_reported" | "not_active"> {
    assert(taskId.length > 0, "requestAgentFinalReportForTimeout: taskId must be non-empty");
    assert(
      options.finalizationToken.length > 0,
      "requestAgentFinalReportForTimeout: finalizationToken must be non-empty"
    );

    const reservation = await this.workspaceEventLocks.withLock(taskId, async () => {
      const cfg = this.config.loadConfigOrDefault();
      const entry = findWorkspaceEntry(cfg, taskId);
      if (!entry?.workspace.parentWorkspaceId) {
        return { status: "not_active" as const };
      }
      if (hasCompletedAgentReport(entry.workspace) || this.completedReportsByTaskId.has(taskId)) {
        return { status: "already_reported" as const };
      }
      if (entry.workspace.taskStatus === "interrupted" && !this.aiService.isStreaming(taskId)) {
        return { status: "not_active" as const };
      }

      const tokens = entry.workspace.taskTimeoutFinalizationTokens ?? [];
      const alreadyPrompted = tokens.includes(options.finalizationToken);
      if (!alreadyPrompted) {
        await this.editWorkspaceEntry(
          taskId,
          (workspace) => {
            workspace.taskStatus = "awaiting_report";
          },
          { allowMissing: true }
        );
      }
      return { status: "reserved" as const, alreadyPrompted };
    });

    if (reservation.status !== "reserved") {
      return reservation.status;
    }
    if (reservation.alreadyPrompted) {
      return "prompted";
    }
    if (this.aiService.isStreaming(taskId)) {
      await this.aiService.stopStream(taskId, {
        soft: true,
        abandonPartial: false,
        abortReason: "system",
      });
    }

    const freshConfig = this.config.loadConfigOrDefault();