@oneuptime/common 11.5.3 → 11.5.5

package/Server/API/AIAgentTaskAPI.ts

@@ -1,38 +1,52 @@
 import AIAgentService from "../Services/AIAgentService";
-import AIAgentTaskService, {
-  Service as AIAgentTaskServiceType,
-} from "../Services/AIAgentTaskService";
-import {
+import AIRunService from "../Services/AIRunService";
+import AIRunEventService from "../Services/AIRunEventService";
+import Express, {
   ExpressRequest,
   ExpressResponse,
+  ExpressRouter,
   NextFunction,
 } from "../Utils/Express";
 import Response from "../Utils/Response";
-import BaseAPI from "./BaseAPI";
-import AIAgentTask from "../../Models/DatabaseModels/AIAgentTask";
 import AIAgent from "../../Models/DatabaseModels/AIAgent";
+import AIRun from "../../Models/DatabaseModels/AIRun";
 import BadDataException from "../../Types/Exception/BadDataException";
 import { JSONObject } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
 import OneUptimeDate from "../../Types/Date";
 import AIAgentTaskStatus from "../../Types/AI/AIAgentTaskStatus";
+import AIRunStatus from "../../Types/AI/AIRunStatus";
+import AIRunType from "../../Types/AI/AIRunType";
+import AIRunEventType from "../../Types/AI/AIRunEventType";
+import { CodeFixTaskTypeHelper } from "../../Types/AI/CodeFixTaskType";
 import PositiveNumber from "../../Types/PositiveNumber";
 
-export default class AIAgentTaskAPI extends BaseAPI<
-  AIAgentTask,
-  AIAgentTaskServiceType
-> {
+/*
+ * The agent worker's task protocol. The route names and request shapes are
+ * unchanged from the legacy AIAgentTask days (the wire keeps the
+ * AIAgentTaskStatus strings), but the substrate underneath is the unified
+ * AIRun table: `taskId` carries an AIRun id, claims are CAS status
+ * transitions, and progress reports touch the run heartbeat that the
+ * stale-run sweeper watches. The legacy AIAgentTask MODEL is gone — this is
+ * a plain protocol router, not a CRUD API.
+ */
+
+const API_BASE_PATH: string = "/ai-agent-task";
+
+export default class AIAgentTaskAPI {
+  public router!: ExpressRouter;
+
   public constructor() {
-    super(AIAgentTask, AIAgentTaskService);
+    this.router = Express.getRouter();
 
     /*
-     * Claim the next pending (scheduled) task for processing.
-     * Validates aiAgentId and aiAgentKey before claiming. The task is
-     * atomically transitioned Scheduled -> InProgress before it is
-     * returned, so concurrent workers can never receive the same task.
+     * Claim the next pending code-fix run for processing.
+     * Validates aiAgentId and aiAgentKey before claiming. The run is
+     * atomically transitioned Queued -> Running before it is returned, so
+     * concurrent workers can never receive the same run.
      */
     this.router.post(
-      `${new this.entityType().getCrudApiPath()?.toString()}/get-pending-task`,
+      `${API_BASE_PATH}/get-pending-task`,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
           const data: JSONObject = req.body;
@@ -48,12 +62,12 @@ export default class AIAgentTaskAPI extends BaseAPI<
             );
           }
 
-          const task: AIAgentTask | null =
-            await AIAgentTaskService.claimNextScheduledTask({
+          const run: AIRun | null =
+            await AIRunService.claimNextQueuedCodeFixRun({
               aiAgentId: aiAgent.id,
             });
 
-          if (!task) {
+          if (!run) {
             return Response.sendJsonObjectResponse(req, res, {
               task: null,
               message: "No pending tasks available",
@@ -62,11 +76,24 @@ export default class AIAgentTaskAPI extends BaseAPI<
 
           return Response.sendJsonObjectResponse(req, res, {
             task: {
-              _id: task._id?.toString(),
-              projectId: task.projectId?.toString(),
-              taskType: task.taskType,
-              metadata: task.metadata as JSONObject | undefined,
-              createdAt: task.createdAt,
+              id: run.id!.toString(),
+              projectId: run.projectId?.toString(),
+              /*
+               * exceptionId is present only for exception-based recipes.
+               * ImproveInstrumentation / FixFromIncident runs carry an
+               * incident/alert subject instead — the worker fetches their
+               * context via /ai-agent-data/get-instrumentation-task-details
+               * with the run id, so this field is optional on the wire.
+               */
+              exceptionId: run.triggeredByTelemetryExceptionId?.toString(),
+              /*
+               * The worker dispatches its task handler on this. The claim
+               * already normalized legacy null to FixException; normalize
+               * again here so the wire contract can never regress.
+               */
+              taskType: CodeFixTaskTypeHelper.fromDatabaseValue(
+                run.codeFixTaskType,
+              ),
             },
             message: "Task claimed successfully",
           });
@@ -77,11 +104,11 @@ export default class AIAgentTaskAPI extends BaseAPI<
     );
 
     /*
-     * Get the count of pending (scheduled) tasks for KEDA autoscaling
+     * Get the count of pending (queued) code-fix runs for KEDA autoscaling
      * Validates aiAgentId and aiAgentKey before returning count
      */
     this.router.post(
-      `${new this.entityType().getCrudApiPath()?.toString()}/get-pending-task-count`,
+      `${API_BASE_PATH}/get-pending-task-count`,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
           const data: JSONObject = req.body;
@@ -97,10 +124,11 @@ export default class AIAgentTaskAPI extends BaseAPI<
             );
           }
 
-          /* Count scheduled tasks */
-          const count: PositiveNumber = await AIAgentTaskService.countBy({
+          /* Count queued code-fix runs */
+          const count: PositiveNumber = await AIRunService.countBy({
             query: {
-              status: AIAgentTaskStatus.Scheduled,
+              runType: AIRunType.CodeFix,
+              status: AIRunStatus.Queued,
             },
             props: {
               isRoot: true,
@@ -118,11 +146,14 @@ export default class AIAgentTaskAPI extends BaseAPI<
     );
 
     /*
-     * Update task status (InProgress, Completed, Error)
-     * Validates aiAgentId and aiAgentKey before updating
+     * Update task status (InProgress, Completed, Error).
+     * `taskId` is an AIRun id. InProgress is a heartbeat touch (the run is
+     * already Running from the claim); Completed/Error are CAS transitions
+     * Running -> Completed/Error that also write the terminal
+     * RunCompleted/RunFailed event to the run's glass-box trail.
      */
     this.router.post(
-      `${new this.entityType().getCrudApiPath()?.toString()}/update-task-status`,
+      `${API_BASE_PATH}/update-task-status`,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
           const data: JSONObject = req.body;
@@ -155,7 +186,7 @@ export default class AIAgentTaskAPI extends BaseAPI<
             );
           }
 
-          const taskId: ObjectID = new ObjectID(data["taskId"] as string);
+          const runId: ObjectID = new ObjectID(data["taskId"] as string);
           const status: AIAgentTaskStatus = data["status"] as AIAgentTaskStatus;
           const statusMessage: string | undefined = data["statusMessage"] as
             | string
@@ -178,20 +209,20 @@ export default class AIAgentTaskAPI extends BaseAPI<
             );
           }
 
-          /* Check if task exists */
-          const existingTask: AIAgentTask | null =
-            await AIAgentTaskService.findOneById({
-              id: taskId,
-              select: {
-                _id: true,
-                status: true,
-              },
-              props: {
-                isRoot: true,
-              },
-            });
+          /* Check if the run exists */
+          const existingRun: AIRun | null = await AIRunService.findOneById({
+            id: runId,
+            select: {
+              _id: true,
+              projectId: true,
+              status: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
 
-          if (!existingTask) {
+          if (!existingRun) {
             return Response.sendErrorResponse(
               req,
               res,
@@ -199,39 +230,67 @@ export default class AIAgentTaskAPI extends BaseAPI<
             );
           }
 
-          /* Update the task based on status */
           if (status === AIAgentTaskStatus.InProgress) {
-            await AIAgentTaskService.updateOneById({
-              id: taskId,
-              data: {
-                status: status,
-                ...(aiAgent.id && { aiAgentId: aiAgent.id }),
-                startedAt: OneUptimeDate.getCurrentDate(),
-                ...(statusMessage && { statusMessage: statusMessage }),
-              },
-              props: {
-                isRoot: true,
+            /*
+             * Back-compat no-op refresh: the run went Running at claim time,
+             * so an InProgress report only keeps it visibly alive for the
+             * stale-run sweeper.
+             */
+            await AIRunService.updateOneBy({
+              query: {
+                _id: runId.toString(),
+                status: AIRunStatus.Running,
               },
-            });
-          } else if (
-            status === AIAgentTaskStatus.Completed ||
-            status === AIAgentTaskStatus.Error
-          ) {
-            await AIAgentTaskService.updateOneById({
-              id: taskId,
               data: {
-                status: status,
-                completedAt: OneUptimeDate.getCurrentDate(),
-                ...(statusMessage && { statusMessage: statusMessage }),
-              },
+                lastHeartbeatAt: OneUptimeDate.getCurrentDate(),
+              } as never,
               props: {
                 isRoot: true,
               },
             });
+          } else {
+            const toStatus: AIRunStatus =
+              status === AIAgentTaskStatus.Completed
+                ? AIRunStatus.Completed
+                : AIRunStatus.Error;
+
+            /*
+             * CAS Running -> Completed/Error. Losing the race (0 rows) means
+             * another actor already finalized the run — e.g. the sweeper
+             * marked it Error after a heartbeat gap — and that outcome wins;
+             * we do not clobber it or write a duplicate terminal event.
+             */
+            const transitionedCount: number =
+              await AIRunService.attemptStatusTransition({
+                aiRunId: runId,
+                fromStatus: AIRunStatus.Running,
+                set: {
+                  status: toStatus,
+                  completedAt: OneUptimeDate.getCurrentDate(),
+                  lastHeartbeatAt: OneUptimeDate.getCurrentDate(),
+                  ...(toStatus === AIRunStatus.Error && statusMessage
+                    ? { errorMessage: statusMessage }
+                    : {}),
+                },
+              });
+
+            if (transitionedCount > 0 && existingRun.projectId) {
+              await AIRunEventService.appendEventToRun({
+                projectId: existingRun.projectId,
+                aiRunId: runId,
+                eventType:
+                  toStatus === AIRunStatus.Completed
+                    ? AIRunEventType.RunCompleted
+                    : AIRunEventType.RunFailed,
+                ...(statusMessage
+                  ? { resultSummary: { message: statusMessage } }
+                  : {}),
+              });
+            }
           }
 
           return Response.sendJsonObjectResponse(req, res, {
-            taskId: taskId.toString(),
+            taskId: runId.toString(),
             status: status,
             message: "Task status updated successfully",
           });
@@ -242,6 +301,10 @@ export default class AIAgentTaskAPI extends BaseAPI<
     );
   }
 
+  public getRouter(): ExpressRouter {
+    return this.router;
+  }
+
   /*
    * Validate AI Agent credentials from request body
    * Returns AIAgent if valid, null otherwise

package/Server/API/AIAgentTaskLogAPI.ts

@@ -1,36 +1,48 @@
-import AIAgentTaskLogService, {
-  Service as AIAgentTaskLogServiceType,
-} from "../Services/AIAgentTaskLogService";
 import AIAgentService from "../Services/AIAgentService";
-import AIAgentTaskService from "../Services/AIAgentTaskService";
-import {
+import AIRunService from "../Services/AIRunService";
+import AIRunEventService from "../Services/AIRunEventService";
+import Express, {
   ExpressRequest,
   ExpressResponse,
+  ExpressRouter,
   NextFunction,
 } from "../Utils/Express";
 import Response from "../Utils/Response";
-import BaseAPI from "./BaseAPI";
-import AIAgentTaskLog from "../../Models/DatabaseModels/AIAgentTaskLog";
 import AIAgent from "../../Models/DatabaseModels/AIAgent";
-import AIAgentTask from "../../Models/DatabaseModels/AIAgentTask";
+import AIRun from "../../Models/DatabaseModels/AIRun";
 import BadDataException from "../../Types/Exception/BadDataException";
 import { JSONObject } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
+import OneUptimeDate from "../../Types/Date";
+import AIRunStatus from "../../Types/AI/AIRunStatus";
+import AIRunEventType from "../../Types/AI/AIRunEventType";
 import LogSeverity from "../../Types/Log/LogSeverity";
 
-export default class AIAgentTaskLogAPI extends BaseAPI<
-  AIAgentTaskLog,
-  AIAgentTaskLogServiceType
-> {
+/*
+ * The agent worker's progress-log protocol. The route name predates the
+ * AIRun substrate (the legacy AIAgentTaskLog MODEL is gone — this is a
+ * plain protocol router, not a CRUD API); log lines land as ProgressLog
+ * AIRunEvents on the run's glass-box trail.
+ */
+
+const API_BASE_PATH: string = "/ai-agent-task-log";
+
+export default class AIAgentTaskLogAPI {
+  public router!: ExpressRouter;
+
   public constructor() {
-    super(AIAgentTaskLog, AIAgentTaskLogService);
+    this.router = Express.getRouter();
 
     /*
-     * Create a log entry for an AI Agent task
-     * Validates aiAgentId and aiAgentKey before creating log
+     * Record a progress log line for a code-fix run. The route name and
+     * request shape are unchanged from the legacy AIAgentTaskLog days, but
+     * `taskId` now carries an AIRun id and the line lands as a ProgressLog
+     * AIRunEvent in the run's glass-box trail (message + severity in
+     * resultSummary). Each log also touches the run heartbeat so a chatty
+     * agent is never swept as stale. Validates aiAgentId and aiAgentKey.
      */
     this.router.post(
-      `${new this.entityType().getCrudApiPath()?.toString()}/create-log`,
+      `${API_BASE_PATH}/create-log`,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
           const data: JSONObject = req.body;
@@ -71,7 +83,7 @@ export default class AIAgentTaskLogAPI extends BaseAPI<
             );
           }
 
-          const taskId: ObjectID = new ObjectID(data["taskId"] as string);
+          const runId: ObjectID = new ObjectID(data["taskId"] as string);
           const severity: LogSeverity = data["severity"] as LogSeverity;
           const message: string = data["message"] as string;
 
@@ -88,20 +100,19 @@ export default class AIAgentTaskLogAPI extends BaseAPI<
             );
           }
 
-          /* Check if task exists and get project ID */
-          const existingTask: AIAgentTask | null =
-            await AIAgentTaskService.findOneById({
-              id: taskId,
-              select: {
-                _id: true,
-                projectId: true,
-              },
-              props: {
-                isRoot: true,
-              },
-            });
-
-          if (!existingTask) {
+          /* Check if the run exists and get its project ID */
+          const existingRun: AIRun | null = await AIRunService.findOneById({
+            id: runId,
+            select: {
+              _id: true,
+              projectId: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          if (!existingRun || !existingRun.projectId) {
             return Response.sendErrorResponse(
               req,
               res,
@@ -109,23 +120,32 @@ export default class AIAgentTaskLogAPI extends BaseAPI<
             );
           }
 
-          /* Create the log entry */
-          const logEntry: AIAgentTaskLog = new AIAgentTaskLog();
-          logEntry.projectId = existingTask.projectId!;
-          logEntry.aiAgentTaskId = taskId;
-          logEntry.aiAgentId = aiAgent.id!;
-          logEntry.severity = severity;
-          logEntry.message = message;
+          await AIRunEventService.appendEventToRun({
+            projectId: existingRun.projectId,
+            aiRunId: runId,
+            eventType: AIRunEventType.ProgressLog,
+            resultSummary: {
+              message: message,
+              severity: severity,
+            },
+          });
 
-          await AIAgentTaskLogService.create({
-            data: logEntry,
+          /* A progress report proves the agent is alive — refresh the heartbeat. */
+          await AIRunService.updateOneBy({
+            query: {
+              _id: runId.toString(),
+              status: AIRunStatus.Running,
+            },
+            data: {
+              lastHeartbeatAt: OneUptimeDate.getCurrentDate(),
+            } as never,
             props: {
               isRoot: true,
             },
           });
 
           return Response.sendJsonObjectResponse(req, res, {
-            taskId: taskId.toString(),
+            taskId: runId.toString(),
             message: "Log entry created successfully",
           });
         } catch (err) {
@@ -135,6 +155,10 @@ export default class AIAgentTaskLogAPI extends BaseAPI<
     );
   }
 
+  public getRouter(): ExpressRouter {
+    return this.router;
+  }
+
   /*
    * Validate AI Agent credentials from request body
    * Returns AIAgent if valid, null otherwise

package/Server/API/AIAgentTaskPullRequestAPI.ts

@@ -1,8 +1,18 @@
 import AIAgentTaskPullRequestService, {
+  AIFixOutcomeStats,
   Service as AIAgentTaskPullRequestServiceType,
 } from "../Services/AIAgentTaskPullRequestService";
 import BaseAPI from "./BaseAPI";
+import CommonAPI from "./CommonAPI";
+import UserMiddleware from "../Middleware/UserAuthorization";
+import Response from "../Utils/Response";
 import AIAgentTaskPullRequest from "../../Models/DatabaseModels/AIAgentTaskPullRequest";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
 
 export default class AIAgentTaskPullRequestAPI extends BaseAPI<
   AIAgentTaskPullRequest,
@@ -10,5 +20,36 @@ export default class AIAgentTaskPullRequestAPI extends BaseAPI<
 > {
   public constructor() {
     super(AIAgentTaskPullRequest, AIAgentTaskPullRequestService);
+
+    /*
+     * Outcome counts for the project's AI-authored fix PRs (merged /
+     * closed-unmerged / open + acceptance rate + CI-verified-green rate)
+     * — the G11 baseline surface.
+     */
+    this.router.get(
+      `${new this.entityType().getCrudApiPath()?.toString()}/outcome-stats`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const props: DatabaseCommonInteractionProps =
+            await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+          const stats: AIFixOutcomeStats =
+            await this.service.getOutcomeStats(props);
+
+          return Response.sendJsonObjectResponse(req, res, {
+            total: stats.total,
+            open: stats.open,
+            merged: stats.merged,
+            closedUnmerged: stats.closedUnmerged,
+            acceptanceRatePercent: stats.acceptanceRatePercent,
+            verifiedGreen: stats.verifiedGreen,
+            verifiedGreenRatePercent: stats.verifiedGreenRatePercent,
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
   }
 }