@oneuptime/common 9.2.27 → 9.3.0

package/Server/Services/AIAgentTaskService.ts

@@ -0,0 +1,178 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/AIAgentTask";
+import AIAgent from "../../Models/DatabaseModels/AIAgent";
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate } from "../Types/Database/Hooks";
+import BadDataException from "../../Types/Exception/BadDataException";
+import AIAgentService from "./AIAgentService";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import ObjectID from "../../Types/ObjectID";
+import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import logger from "../Utils/Logger";
+import OneUptimeDate from "../../Types/Date";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    // If no aiAgentId is provided, assign one automatically
+    if (!createBy.data.aiAgentId) {
+      createBy.data.aiAgentId = await this.getDefaultAgentId(createBy);
+    } else {
+      // Validate the provided aiAgentId
+      await this.validateAgentBelongsToProject(createBy);
+    }
+
+    // Generate task number
+    if (!createBy.data.projectId) {
+      throw new BadDataException(
+        "Project ID is required to create an AI Agent Task",
+      );
+    }
+
+    const projectId: ObjectID = createBy.data.projectId;
+
+    let mutex: SemaphoreMutex | null = null;
+
+    try {
+      mutex = await Semaphore.lock({
+        key: projectId.toString(),
+        namespace: "AIAgentTaskService.task-create",
+        lockTimeout: 15000,
+        acquireTimeout: 20000,
+      });
+
+      logger.debug(
+        "Mutex acquired - AIAgentTaskService.task-create " +
+          projectId.toString() +
+          " at " +
+          OneUptimeDate.getCurrentDateAsFormattedString(),
+      );
+    } catch (err) {
+      logger.debug(
+        "Mutex acquire failed - AIAgentTaskService.task-create " +
+          projectId.toString() +
+          " at " +
+          OneUptimeDate.getCurrentDateAsFormattedString(),
+      );
+      logger.error(err);
+    }
+
+    try {
+      const taskNumberForThisTask: number =
+        (await this.getExistingTaskNumberForProject({
+          projectId: projectId,
+        })) + 1;
+
+      createBy.data.taskNumber = taskNumberForThisTask;
+    } finally {
+      if (mutex) {
+        await Semaphore.release(mutex);
+      }
+    }
+
+    return { createBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  public async getExistingTaskNumberForProject(data: {
+    projectId: ObjectID;
+  }): Promise<number> {
+    // get last task number.
+    const lastTask: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+      },
+      select: {
+        taskNumber: true,
+      },
+      sort: {
+        createdAt: SortOrder.Descending,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!lastTask) {
+      return 0;
+    }
+
+    return lastTask.taskNumber ? Number(lastTask.taskNumber) : 0;
+  }
+
+  @CaptureSpan()
+  private async getDefaultAgentId(
+    createBy: CreateBy<Model>,
+  ): Promise<ObjectID> {
+    if (!createBy.data.projectId) {
+      throw new BadDataException(
+        "Project ID is required to assign an AI Agent",
+      );
+    }
+
+    // Try to get the default agent for the project (or global fallback)
+    const agent: AIAgent | null = await AIAgentService.getAIAgentForProject(
+      createBy.data.projectId,
+    );
+
+    if (!agent || !agent.id) {
+      throw new BadDataException(
+        "No AI Agent available. Please configure an AI Agent for this project or ensure a global AI Agent is available.",
+      );
+    }
+
+    return agent.id!;
+  }
+
+  @CaptureSpan()
+  private async validateAgentBelongsToProject(
+    createBy: CreateBy<Model>,
+  ): Promise<void> {
+    if (!createBy.data.aiAgentId || !createBy.data.projectId) {
+      return;
+    }
+
+    const agent: AIAgent | null = await AIAgentService.findOneById({
+      id: createBy.data.aiAgentId,
+      select: {
+        _id: true,
+        projectId: true,
+        isGlobalAIAgent: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!agent) {
+      throw new BadDataException("AI Agent not found");
+    }
+
+    // Allow if it's a global agent
+    if (agent.isGlobalAIAgent) {
+      return;
+    }
+
+    // Allow if the agent belongs to the same project
+    if (
+      agent.projectId &&
+      agent.projectId.toString() === createBy.data.projectId.toString()
+    ) {
+      return;
+    }
+
+    // Reject if the agent belongs to a different project
+    throw new BadDataException(
+      "The specified AI Agent does not belong to this project. Please use an AI Agent from your project or a global AI Agent.",
+    );
+  }
+}
+
+export default new Service();

package/Server/Services/AIAgentTaskTelemetryExceptionService.ts

@@ -0,0 +1,39 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/AIAgentTaskTelemetryException";
+import ObjectID from "../../Types/ObjectID";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export interface LinkTaskToTelemetryExceptionParams {
+  projectId: ObjectID;
+  aiAgentTaskId: ObjectID;
+  telemetryExceptionId: ObjectID;
+  props: DatabaseCommonInteractionProps;
+}
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  public async linkTaskToTelemetryException(
+    params: LinkTaskToTelemetryExceptionParams,
+  ): Promise<Model> {
+    const { projectId, aiAgentTaskId, telemetryExceptionId, props } = params;
+
+    const taskExceptionLink: Model = new Model();
+    taskExceptionLink.projectId = projectId;
+    taskExceptionLink.aiAgentTaskId = aiAgentTaskId;
+    taskExceptionLink.telemetryExceptionId = telemetryExceptionId;
+
+    return await this.create({
+      data: taskExceptionLink,
+      props: {
+        ...props,
+      },
+    });
+  }
+}
+
+export default new Service();

package/Server/Services/Index.ts

@@ -64,6 +64,11 @@ import OnCallDutyPolicyScheduleService from "./OnCallDutyPolicyScheduleService";
 // On-Call Duty
 import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
 import ProbeService from "./ProbeService";
+import AIAgentService from "./AIAgentService";
+import AIAgentOwnerUserService from "./AIAgentOwnerUserService";
+import AIAgentOwnerTeamService from "./AIAgentOwnerTeamService";
+import AIAgentTaskLogService from "./AIAgentTaskLogService";
+import AIAgentTaskPullRequestService from "./AIAgentTaskPullRequestService";
 import ProjectCallSMSConfigService from "./ProjectCallSMSConfigService";
 import ProjectService from "./ProjectService";
 // Project SMTP Config.
@@ -241,6 +246,11 @@ const services: Array<BaseService> = [
   ProjectService,
   ProjectSmtpConfigService,
   ProbeService,
+  AIAgentService,
+  AIAgentOwnerUserService,
+  AIAgentOwnerTeamService,
+  AIAgentTaskLogService,
+  AIAgentTaskPullRequestService,
   ProjectSsoService,
 
   ScheduledMaintenanceCustomFieldService,

package/Server/Services/TelemetryExceptionService.ts

@@ -1,10 +1,172 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/TelemetryException";
+import AIAgentTask from "../../Models/DatabaseModels/AIAgentTask";
+import AIAgentTaskTelemetryException from "../../Models/DatabaseModels/AIAgentTaskTelemetryException";
+import ObjectID from "../../Types/ObjectID";
+import BadDataException from "../../Types/Exception/BadDataException";
+import AIAgentTaskType from "../../Types/AI/AIAgentTaskType";
+import AIAgentTaskStatus from "../../Types/AI/AIAgentTaskStatus";
+import { FixExceptionTaskMetadata } from "../../Types/AI/AIAgentTaskMetadata";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import AIAgentTaskService from "./AIAgentTaskService";
+import AIAgentTaskTelemetryExceptionService from "./AIAgentTaskTelemetryExceptionService";
+import QueryHelper from "../Types/Database/QueryHelper";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export interface CreateAIAgentTaskForExceptionParams {
+  telemetryExceptionId: ObjectID;
+  props: DatabaseCommonInteractionProps;
+}
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  @CaptureSpan()
+  public async createAIAgentTaskForException(
+    params: CreateAIAgentTaskForExceptionParams,
+  ): Promise<AIAgentTask> {
+    const { telemetryExceptionId, props } = params;
+
+    // Get the telemetry exception
+    const telemetryException: Model | null = await this.findOneById({
+      id: telemetryExceptionId,
+      select: {
+        _id: true,
+        projectId: true,
+        message: true,
+        stackTrace: true,
+        telemetryServiceId: true,
+        exceptionType: true,
+      },
+      props,
+    });
+
+    if (!telemetryException || !telemetryException.projectId) {
+      throw new BadDataException("Telemetry Exception not found");
+    }
+
+    // Check if an active AI agent task already exists for this exception
+    await this.validateNoActiveTaskExists(telemetryExceptionId);
+
+    // Create the AI Agent Task
+    const createdTask: AIAgentTask = await this.createFixExceptionTask({
+      telemetryException,
+      telemetryExceptionId,
+      props,
+    });
+
+    // Link the task to the telemetry exception
+    await AIAgentTaskTelemetryExceptionService.linkTaskToTelemetryException({
+      projectId: telemetryException.projectId,
+      aiAgentTaskId: createdTask.id!,
+      telemetryExceptionId,
+      props,
+    });
+
+    return createdTask;
+  }
+
+  @CaptureSpan()
+  private async validateNoActiveTaskExists(
+    telemetryExceptionId: ObjectID,
+  ): Promise<void> {
+    const existingTaskLink: AIAgentTaskTelemetryException | null =
+      await AIAgentTaskTelemetryExceptionService.findOneBy({
+        query: {
+          telemetryExceptionId: telemetryExceptionId,
+          aiAgentTask: {
+            status: QueryHelper.notIn([
+              AIAgentTaskStatus.Completed,
+              AIAgentTaskStatus.Error,
+            ]),
+          },
+        },
+        select: {
+          _id: true,
+          aiAgentTaskId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (existingTaskLink) {
+      throw new BadDataException(
+        "An AI agent task is already in progress for this exception. Please wait for it to complete before creating a new one.",
+      );
+    }
+  }
+
+  @CaptureSpan()
+  private async createFixExceptionTask(params: {
+    telemetryException: Model;
+    telemetryExceptionId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<AIAgentTask> {
+    const { telemetryException, telemetryExceptionId, props } = params;
+
+    const aiAgentTask: AIAgentTask = new AIAgentTask();
+    aiAgentTask.projectId = telemetryException.projectId!;
+    aiAgentTask.taskType = AIAgentTaskType.FixException;
+    aiAgentTask.status = AIAgentTaskStatus.Scheduled;
+
+    // Set name and description based on exception details
+    const exceptionType: string =
+      telemetryException.exceptionType || "Exception";
+    const exceptionMessage: string =
+      telemetryException.message || "No message available";
+
+    aiAgentTask.name = `Fix ${exceptionType}: ${exceptionMessage}`;
+    aiAgentTask.description = `AI Agent task to fix the exception: ${exceptionMessage}`;
+
+    // Build metadata
+    aiAgentTask.metadata = this.buildFixExceptionMetadata({
+      telemetryException,
+      telemetryExceptionId,
+    });
+
+    const createdTask: AIAgentTask = await AIAgentTaskService.create({
+      data: aiAgentTask,
+      props: {
+        ...props,
+      },
+    });
+
+    if (!createdTask.id) {
+      throw new BadDataException("Failed to create AI Agent Task");
+    }
+
+    return createdTask;
+  }
+
+  private buildFixExceptionMetadata(params: {
+    telemetryException: Model;
+    telemetryExceptionId: ObjectID;
+  }): FixExceptionTaskMetadata {
+    const { telemetryException, telemetryExceptionId } = params;
+
+    const metadata: FixExceptionTaskMetadata = {
+      taskType: AIAgentTaskType.FixException,
+      exceptionId: telemetryExceptionId.toString(),
+    };
+
+    if (telemetryException.stackTrace) {
+      metadata.stackTrace = telemetryException.stackTrace;
+    }
+
+    if (telemetryException.message) {
+      metadata.errorMessage = telemetryException.message;
+    }
+
+    if (telemetryException.telemetryServiceId) {
+      metadata.telemetryServiceId =
+        telemetryException.telemetryServiceId.toString();
+    }
+
+    return metadata;
+  }
 }
 
 export default new Service();

package/Server/Utils/Monitor/MonitorResource.ts

@@ -40,6 +40,17 @@ import CaptureSpan from "../Telemetry/CaptureSpan";
 import ExceptionMessages from "../../../Types/Exception/ExceptionMessages";
 import MonitorEvaluationSummary from "../../../Types/Monitor/MonitorEvaluationSummary";
 import MonitorStatusService from "../../Services/MonitorStatusService";
+import { ProbeConnectionStatus } from "../../../Models/DatabaseModels/Probe";
+import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
+
+interface ProbeAgreementResult {
+  hasAgreement: boolean;
+  agreementCount: number;
+  requiredCount: number;
+  totalActiveProbes: number;
+  agreedCriteriaId: string | null;
+  agreedRootCause: string | null;
+}
 
 export default class MonitorResourceUtil {
   @CaptureSpan()
@@ -125,6 +136,7 @@ export default class MonitorResourceUtil {
         currentMonitorStatusId: true,
         _id: true,
         name: true,
+        minimumProbeAgreement: true,
       },
       props: {
         isRoot: true,
@@ -500,6 +512,62 @@ export default class MonitorResourceUtil {
       evaluationSummary: evaluationSummary,
     });
 
+    // Check probe agreement for probe-based monitors
+    if (
+      monitor.monitorType &&
+      MonitorTypeHelper.isProbableMonitor(monitor.monitorType)
+    ) {
+      const probeAgreementResult: ProbeAgreementResult =
+        await MonitorResourceUtil.checkProbeAgreement({
+          monitor: monitor,
+          monitorStep: monitorStep,
+          currentCriteriaMetId: response.criteriaMetId || null,
+          currentRootCause: response.rootCause || null,
+        });
+
+      // Add probe agreement event to evaluation summary
+      evaluationSummary.events.push({
+        type: "probe-agreement",
+        title: "Probe Agreement Check",
+        message: probeAgreementResult.hasAgreement
+          ? `Probe agreement reached: ${probeAgreementResult.agreementCount}/${probeAgreementResult.requiredCount} probes agree (${probeAgreementResult.totalActiveProbes} active probes total).`
+          : `Probe agreement not reached: ${probeAgreementResult.agreementCount}/${probeAgreementResult.requiredCount} probes agree (${probeAgreementResult.totalActiveProbes} active probes total). Skipping status change.`,
+        at: OneUptimeDate.getCurrentDate(),
+      });
+
+      if (!probeAgreementResult.hasAgreement) {
+        logger.debug(
+          `${dataToProcess.monitorId.toString()} - Probe agreement not met. ${probeAgreementResult.agreementCount}/${probeAgreementResult.requiredCount} probes agree. Skipping status change.`,
+        );
+
+        // Release lock and return early - no status change
+        if (mutex) {
+          try {
+            await Semaphore.release(mutex);
+          } catch (err) {
+            logger.error(err);
+          }
+        }
+
+        await persistLatestMonitorPayload();
+
+        MonitorLogUtil.saveMonitorLog({
+          monitorId: monitor.id!,
+          projectId: monitor.projectId!,
+          dataToProcess: dataToProcess,
+        });
+
+        response.evaluationSummary = evaluationSummary;
+        return response;
+      }
+
+      // Use the agreed criteria result
+      response.criteriaMetId = probeAgreementResult.agreedCriteriaId
+        ? probeAgreementResult.agreedCriteriaId
+        : undefined;
+      response.rootCause = probeAgreementResult.agreedRootCause;
+    }
+
     if (response.criteriaMetId && response.rootCause) {
       logger.debug(
         `${dataToProcess.monitorId.toString()} - Criteria met: ${
@@ -735,4 +803,164 @@ export default class MonitorResourceUtil {
 
     return response;
   }
+
+  @CaptureSpan()
+  private static async checkProbeAgreement(input: {
+    monitor: Monitor;
+    monitorStep: MonitorStep;
+    currentCriteriaMetId: string | null;
+    currentRootCause: string | null;
+  }): Promise<ProbeAgreementResult> {
+    const { monitor, monitorStep, currentCriteriaMetId, currentRootCause } =
+      input;
+
+    /*
+     * If minimumProbeAgreement is not set, all probes must agree
+     * Get all MonitorProbes for this monitor with their probe connection status
+     */
+    const monitorProbes: Array<MonitorProbe> = await MonitorProbeService.findBy(
+      {
+        query: {
+          monitorId: monitor.id!,
+        },
+        select: {
+          probeId: true,
+          isEnabled: true,
+          lastMonitoringLog: true,
+          probe: {
+            connectionStatus: true,
+          },
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      },
+    );
+
+    // Filter to only active probes (enabled AND connected)
+    const activeProbes: Array<MonitorProbe> = monitorProbes.filter(
+      (mp: MonitorProbe) => {
+        return (
+          mp.isEnabled &&
+          mp.probe?.connectionStatus === ProbeConnectionStatus.Connected
+        );
+      },
+    );
+
+    // If no active probes, treat as agreement met (nothing to compare)
+    if (activeProbes.length === 0) {
+      logger.debug(
+        `${monitor.id?.toString()} - No active probes found. Treating as agreement met.`,
+      );
+      return {
+        hasAgreement: true,
+        agreementCount: 0,
+        requiredCount: 0,
+        totalActiveProbes: 0,
+        agreedCriteriaId: currentCriteriaMetId,
+        agreedRootCause: currentRootCause,
+      };
+    }
+
+    // Determine required count for agreement
+    const requiredCount: number =
+      monitor.minimumProbeAgreement ?? activeProbes.length;
+    // Effective threshold cannot exceed number of active probes
+    const effectiveThreshold: number = Math.min(
+      requiredCount,
+      activeProbes.length,
+    );
+
+    /*
+     * Count how many probes agree on each criteria result
+     * Key: criteriaId or "none" for no criteria met
+     * Value: { count, rootCause }
+     */
+    const criteriaAgreements: Map<
+      string,
+      { count: number; rootCause: string | null }
+    > = new Map();
+
+    const stepId: string = monitorStep.id.toString();
+
+    for (const monitorProbe of activeProbes) {
+      const probeResponse: ProbeMonitorResponse | undefined =
+        monitorProbe.lastMonitoringLog?.[stepId];
+
+      if (!probeResponse) {
+        // No response yet for this step from this probe - skip
+        logger.debug(
+          `${monitor.id?.toString()} - Probe ${monitorProbe.probeId?.toString()} has no response for step ${stepId}. Skipping.`,
+        );
+        continue;
+      }
+
+      // Evaluate this probe's response against criteria
+      const tempResponse: ProbeApiIngestResponse = {
+        monitorId: monitor.id!,
+        criteriaMetId: undefined,
+        rootCause: null,
+      };
+
+      const tempEvaluationSummary: MonitorEvaluationSummary = {
+        evaluatedAt: OneUptimeDate.getCurrentDate(),
+        criteriaResults: [],
+        events: [],
+      };
+
+      const evaluatedResponse: ProbeApiIngestResponse =
+        await MonitorCriteriaEvaluator.processMonitorStep({
+          dataToProcess: probeResponse as DataToProcess,
+          monitorStep: monitorStep,
+          monitor: monitor,
+          probeApiIngestResponse: tempResponse,
+          evaluationSummary: tempEvaluationSummary,
+        });
+
+      // Record the result
+      const criteriaKey: string = evaluatedResponse.criteriaMetId || "none";
+      const existing: { count: number; rootCause: string | null } | undefined =
+        criteriaAgreements.get(criteriaKey);
+
+      if (existing) {
+        existing.count += 1;
+      } else {
+        criteriaAgreements.set(criteriaKey, {
+          count: 1,
+          rootCause: evaluatedResponse.rootCause,
+        });
+      }
+    }
+
+    // Find the criteria with the most agreement
+    let maxCount: number = 0;
+    let winningCriteriaId: string | null = null;
+    let winningRootCause: string | null = null;
+
+    for (const [criteriaId, data] of criteriaAgreements) {
+      if (data.count > maxCount) {
+        maxCount = data.count;
+        winningCriteriaId = criteriaId === "none" ? null : criteriaId;
+        winningRootCause = data.rootCause;
+      }
+    }
+
+    // Check if the winning criteria has reached the agreement threshold
+    const hasAgreement: boolean = maxCount >= effectiveThreshold;
+
+    logger.debug(
+      `${monitor.id?.toString()} - Probe agreement check: ${maxCount}/${effectiveThreshold} probes agree on criteria "${winningCriteriaId || "none"}". Agreement ${hasAgreement ? "reached" : "not reached"}.`,
+    );
+
+    return {
+      hasAgreement,
+      agreementCount: maxCount,
+      requiredCount: effectiveThreshold,
+      totalActiveProbes: activeProbes.length,
+      agreedCriteriaId: hasAgreement ? winningCriteriaId : null,
+      agreedRootCause: hasAgreement ? winningRootCause : null,
+    };
+  }
 }

package/Server/Utils/PushNotificationUtil.ts

@@ -327,4 +327,33 @@ export default class PushNotificationUtil {
 
     return PushNotificationUtil.applyDefaults(notification);
   }
+
+  public static createAIAgentStatusChangedNotification(params: {
+    aiAgentName: string;
+    projectName: string;
+    connectionStatus: string;
+    clickAction?: string;
+  }): PushNotificationMessage {
+    const { aiAgentName, projectName, connectionStatus, clickAction } = params;
+    const notification: Partial<PushNotificationMessage> = {
+      title: `AI Agent ${connectionStatus}: ${aiAgentName}`,
+      body: `AI Agent ${aiAgentName} is ${connectionStatus} in ${projectName}. Click to view details.`,
+      tag: "ai-agent-status-changed",
+      requireInteraction: true,
+      data: {
+        type: "ai-agent-status-changed",
+        aiAgentName: aiAgentName,
+        projectName: projectName,
+        connectionStatus: connectionStatus,
+      },
+    };
+
+    if (clickAction) {
+      notification.clickAction = clickAction;
+      notification.url = clickAction;
+      notification.data!["url"] = clickAction;
+    }
+
+    return PushNotificationUtil.applyDefaults(notification);
+  }
 }