@oneuptime/common 9.2.17 → 9.2.20

package/Server/API/AlertAPI.ts

@@ -0,0 +1,139 @@
+import Alert from "../../Models/DatabaseModels/Alert";
+import NotFoundException from "../../Types/Exception/NotFoundException";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import AlertService, {
+  Service as AlertServiceType,
+} from "../Services/AlertService";
+import UserMiddleware from "../Middleware/UserAuthorization";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import CommonAPI from "./CommonAPI";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import AIService, { AILogRequest, AILogResponse } from "../Services/AIService";
+import AlertAIContextBuilder, {
+  AIGenerationContext,
+  AlertContextData,
+} from "../Utils/AI/AlertAIContextBuilder";
+import JSONFunctions from "../../Types/JSONFunctions";
+import Permission from "../../Types/Permission";
+
+export default class AlertAPI extends BaseAPI<Alert, AlertServiceType> {
+  public constructor() {
+    super(Alert, AlertService);
+
+    // Generate note from AI
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/generate-note-from-ai/:alertId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          await this.generateNoteFromAI(req, res);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+  }
+
+  private async generateNoteFromAI(
+    req: ExpressRequest,
+    res: ExpressResponse,
+  ): Promise<void> {
+    const alertIdParam: string | undefined = req.params["alertId"];
+
+    if (!alertIdParam) {
+      throw new BadDataException("Alert ID is required");
+    }
+
+    let alertId: ObjectID;
+
+    try {
+      alertId = new ObjectID(alertIdParam);
+    } catch {
+      throw new BadDataException("Invalid Alert ID");
+    }
+
+    const props: DatabaseCommonInteractionProps =
+      await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+    // Verify user has permission
+    const permissions: Array<Permission> | undefined = props
+      .userTenantAccessPermission?.["permissions"] as
+      | Array<Permission>
+      | undefined;
+
+    const hasPermission: boolean = permissions
+      ? permissions.some((p: Permission) => {
+          return (
+            p === Permission.ProjectOwner ||
+            p === Permission.ProjectAdmin ||
+            p === Permission.EditAlert ||
+            p === Permission.CreateAlertInternalNote
+          );
+        })
+      : false;
+
+    if (!hasPermission && !props.isMasterAdmin) {
+      throw new BadDataException(
+        "You do not have permission to generate notes for this alert.",
+      );
+    }
+
+    // Get the template from request body
+    const template: string | undefined = JSONFunctions.getJSONValueInPath(
+      req.body,
+      "template",
+    ) as string | undefined;
+
+    // Get the alert to verify it exists and get the project ID
+    const alert: Alert | null = await this.service.findOneById({
+      id: alertId,
+      select: {
+        _id: true,
+        projectId: true,
+      },
+      props,
+    });
+
+    if (!alert || !alert.projectId) {
+      throw new NotFoundException("Alert not found");
+    }
+
+    // Build alert context
+    const contextData: AlertContextData =
+      await AlertAIContextBuilder.buildAlertContext({
+        alertId,
+      });
+
+    // Format context for note generation
+    const aiContext: AIGenerationContext =
+      AlertAIContextBuilder.formatAlertContextForNote(contextData, template);
+
+    // Generate note using AIService (handles billing and logging)
+    const aiLogRequest: AILogRequest = {
+      projectId: alert.projectId,
+      feature: "Alert Internal Note",
+      alertId: alertId,
+      messages: aiContext.messages,
+      maxTokens: 4096,
+      temperature: 0.7,
+    };
+
+    if (props.userId) {
+      aiLogRequest.userId = props.userId;
+    }
+
+    const response: AILogResponse =
+      await AIService.executeWithLogging(aiLogRequest);
+
+    return Response.sendJsonObjectResponse(req, res, {
+      note: response.content,
+    });
+  }
+}

package/Server/API/IncidentAPI.ts

@@ -59,6 +59,21 @@ export default class IncidentAPI extends BaseAPI<
         }
       },
     );
+
+    // Generate note from AI
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/generate-note-from-ai/:incidentId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          await this.generateNoteFromAI(req, res);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
   }
 
   private async getPostmortemAttachment(
@@ -229,4 +244,121 @@ export default class IncidentAPI extends BaseAPI<
       postmortemNote: response.content,
     });
   }
+
+  private async generateNoteFromAI(
+    req: ExpressRequest,
+    res: ExpressResponse,
+  ): Promise<void> {
+    const incidentIdParam: string | undefined = req.params["incidentId"];
+
+    if (!incidentIdParam) {
+      throw new BadDataException("Incident ID is required");
+    }
+
+    let incidentId: ObjectID;
+
+    try {
+      incidentId = new ObjectID(incidentIdParam);
+    } catch {
+      throw new BadDataException("Invalid Incident ID");
+    }
+
+    const props: DatabaseCommonInteractionProps =
+      await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+    // Verify user has permission to edit the incident
+    const permissions: Array<Permission> | undefined = props
+      .userTenantAccessPermission?.["permissions"] as
+      | Array<Permission>
+      | undefined;
+
+    const hasPermission: boolean = permissions
+      ? permissions.some((p: Permission) => {
+          return (
+            p === Permission.ProjectOwner ||
+            p === Permission.ProjectAdmin ||
+            p === Permission.EditProjectIncident ||
+            p === Permission.CreateIncidentInternalNote ||
+            p === Permission.CreateIncidentPublicNote
+          );
+        })
+      : false;
+
+    if (!hasPermission && !props.isMasterAdmin) {
+      throw new BadDataException(
+        "You do not have permission to generate notes for this incident.",
+      );
+    }
+
+    // Get the template and note type from request body
+    const template: string | undefined = JSONFunctions.getJSONValueInPath(
+      req.body,
+      "template",
+    ) as string | undefined;
+
+    const noteType: string =
+      (JSONFunctions.getJSONValueInPath(req.body, "noteType") as string) ||
+      "internal";
+
+    if (noteType !== "public" && noteType !== "internal") {
+      throw new BadDataException("Note type must be 'public' or 'internal'");
+    }
+
+    // Always include workspace messages for comprehensive context
+    const includeWorkspaceMessages: boolean = true;
+
+    // Get the incident to verify it exists and get the project ID
+    const incident: Incident | null = await this.service.findOneById({
+      id: incidentId,
+      select: {
+        _id: true,
+        projectId: true,
+      },
+      props,
+    });
+
+    if (!incident || !incident.projectId) {
+      throw new NotFoundException("Incident not found");
+    }
+
+    // Build incident context
+    const contextData: IncidentContextData =
+      await IncidentAIContextBuilder.buildIncidentContext({
+        incidentId,
+        includeWorkspaceMessages,
+        workspaceMessageLimit: 300,
+      });
+
+    // Format context for note generation
+    const aiContext: AIGenerationContext =
+      IncidentAIContextBuilder.formatIncidentContextForNote(
+        contextData,
+        noteType as "public" | "internal",
+        template,
+      );
+
+    // Generate note using AIService (handles billing and logging)
+    const aiLogRequest: AILogRequest = {
+      projectId: incident.projectId,
+      feature:
+        noteType === "public"
+          ? "Incident Public Note"
+          : "Incident Internal Note",
+      incidentId: incidentId,
+      messages: aiContext.messages,
+      maxTokens: 4096,
+      temperature: 0.7,
+    };
+
+    if (props.userId) {
+      aiLogRequest.userId = props.userId;
+    }
+
+    const response: AILogResponse =
+      await AIService.executeWithLogging(aiLogRequest);
+
+    return Response.sendJsonObjectResponse(req, res, {
+      note: response.content,
+    });
+  }
 }

package/Server/API/ScheduledMaintenanceAPI.ts

@@ -0,0 +1,164 @@
+import ScheduledMaintenance from "../../Models/DatabaseModels/ScheduledMaintenance";
+import NotFoundException from "../../Types/Exception/NotFoundException";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import ScheduledMaintenanceService, {
+  Service as ScheduledMaintenanceServiceType,
+} from "../Services/ScheduledMaintenanceService";
+import UserMiddleware from "../Middleware/UserAuthorization";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import CommonAPI from "./CommonAPI";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import AIService, { AILogRequest, AILogResponse } from "../Services/AIService";
+import ScheduledMaintenanceAIContextBuilder, {
+  AIGenerationContext,
+  ScheduledMaintenanceContextData,
+} from "../Utils/AI/ScheduledMaintenanceAIContextBuilder";
+import JSONFunctions from "../../Types/JSONFunctions";
+import Permission from "../../Types/Permission";
+
+export default class ScheduledMaintenanceAPI extends BaseAPI<
+  ScheduledMaintenance,
+  ScheduledMaintenanceServiceType
+> {
+  public constructor() {
+    super(ScheduledMaintenance, ScheduledMaintenanceService);
+
+    // Generate note from AI
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/generate-note-from-ai/:scheduledMaintenanceId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          await this.generateNoteFromAI(req, res);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+  }
+
+  private async generateNoteFromAI(
+    req: ExpressRequest,
+    res: ExpressResponse,
+  ): Promise<void> {
+    const scheduledMaintenanceIdParam: string | undefined =
+      req.params["scheduledMaintenanceId"];
+
+    if (!scheduledMaintenanceIdParam) {
+      throw new BadDataException("Scheduled Maintenance ID is required");
+    }
+
+    let scheduledMaintenanceId: ObjectID;
+
+    try {
+      scheduledMaintenanceId = new ObjectID(scheduledMaintenanceIdParam);
+    } catch {
+      throw new BadDataException("Invalid Scheduled Maintenance ID");
+    }
+
+    const props: DatabaseCommonInteractionProps =
+      await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+    // Verify user has permission
+    const permissions: Array<Permission> | undefined = props
+      .userTenantAccessPermission?.["permissions"] as
+      | Array<Permission>
+      | undefined;
+
+    const hasPermission: boolean = permissions
+      ? permissions.some((p: Permission) => {
+          return (
+            p === Permission.ProjectOwner ||
+            p === Permission.ProjectAdmin ||
+            p === Permission.EditProjectScheduledMaintenance ||
+            p === Permission.CreateScheduledMaintenanceInternalNote ||
+            p === Permission.CreateScheduledMaintenancePublicNote
+          );
+        })
+      : false;
+
+    if (!hasPermission && !props.isMasterAdmin) {
+      throw new BadDataException(
+        "You do not have permission to generate notes for this scheduled maintenance.",
+      );
+    }
+
+    // Get the template and note type from request body
+    const template: string | undefined = JSONFunctions.getJSONValueInPath(
+      req.body,
+      "template",
+    ) as string | undefined;
+
+    const noteType: string =
+      (JSONFunctions.getJSONValueInPath(req.body, "noteType") as string) ||
+      "internal";
+
+    if (noteType !== "public" && noteType !== "internal") {
+      throw new BadDataException("Note type must be 'public' or 'internal'");
+    }
+
+    // Get the scheduled maintenance to verify it exists and get the project ID
+    const scheduledMaintenance: ScheduledMaintenance | null =
+      await this.service.findOneById({
+        id: scheduledMaintenanceId,
+        select: {
+          _id: true,
+          projectId: true,
+        },
+        props,
+      });
+
+    if (!scheduledMaintenance || !scheduledMaintenance.projectId) {
+      throw new NotFoundException("Scheduled Maintenance not found");
+    }
+
+    // Build scheduled maintenance context
+    const contextData: ScheduledMaintenanceContextData =
+      await ScheduledMaintenanceAIContextBuilder.buildScheduledMaintenanceContext(
+        {
+          scheduledMaintenanceId,
+        },
+      );
+
+    // Format context for note generation
+    const aiContext: AIGenerationContext =
+      ScheduledMaintenanceAIContextBuilder.formatScheduledMaintenanceContextForNote(
+        contextData,
+        noteType as "public" | "internal",
+        template,
+      );
+
+    // Generate note using AIService (handles billing and logging)
+    const aiLogRequest: AILogRequest = {
+      projectId: scheduledMaintenance.projectId,
+      feature:
+        noteType === "public"
+          ? "Scheduled Maintenance Public Note"
+          : "Scheduled Maintenance Internal Note",
+      scheduledMaintenanceId: scheduledMaintenanceId,
+      messages: aiContext.messages,
+      maxTokens: 4096,
+      temperature: 0.7,
+    };
+
+    if (props.userId) {
+      aiLogRequest.userId = props.userId;
+    }
+
+    const response: AILogResponse =
+      await AIService.executeWithLogging(aiLogRequest);
+
+    return Response.sendJsonObjectResponse(req, res, {
+      note: response.content,
+    });
+  }
+}

package/Server/Services/AIService.ts

@@ -152,7 +152,6 @@ export class Service extends BaseService {
       const response: LLMCompletionResponse = await LLMService.getCompletion({
         llmProviderConfig: llmConfig,
         messages: request.messages,
-        maxTokens: request.maxTokens || 4096,
         temperature: request.temperature ?? 0.7,
       });
 

package/Server/Services/IncidentService.ts

@@ -2471,7 +2471,6 @@ ${incidentSeverity.name}
     const response: LLMCompletionResponse = await LLMService.getCompletion({
       llmProviderConfig: llmConfig,
       messages: aiContext.messages,
-      maxTokens: 8192,
       temperature: 0.7,
     });