@oneuptime/common 9.2.15 → 9.2.17

package/Server/Services/AIService.ts

@@ -0,0 +1,239 @@
+import { IsBillingEnabled } from "../EnvironmentConfig";
+import BaseService from "./BaseService";
+import LlmProviderService from "./LlmProviderService";
+import LlmLogService from "./LlmLogService";
+import ProjectService from "./ProjectService";
+import Project from "../../Models/DatabaseModels/Project";
+import AIBillingService from "./AIBillingService";
+import LLMService, {
+  LLMProviderConfig,
+  LLMCompletionResponse,
+  LLMMessage,
+} from "../Utils/LLM/LLMService";
+import LlmProvider from "../../Models/DatabaseModels/LlmProvider";
+import LlmLog from "../../Models/DatabaseModels/LlmLog";
+import LlmLogStatus from "../../Types/LlmLogStatus";
+import ObjectID from "../../Types/ObjectID";
+import BadDataException from "../../Types/Exception/BadDataException";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger from "../Utils/Logger";
+
+export interface AILogRequest {
+  projectId: ObjectID;
+  userId?: ObjectID;
+  feature: string; // e.g., "IncidentPostmortem", "IncidentNote"
+  incidentId?: ObjectID;
+  alertId?: ObjectID;
+  scheduledMaintenanceId?: ObjectID;
+  messages: Array<LLMMessage>;
+  maxTokens?: number;
+  temperature?: number;
+}
+
+export interface AILogResponse {
+  content: string;
+  llmLog: LlmLog;
+}
+
+export class Service extends BaseService {
+  public constructor() {
+    super();
+  }
+
+  @CaptureSpan()
+  public async executeWithLogging(
+    request: AILogRequest,
+  ): Promise<AILogResponse> {
+    const startTime: Date = new Date();
+
+    // Get LLM provider for the project
+    const llmProvider: LlmProvider | null =
+      await LlmProviderService.getLLMProviderForProject(request.projectId);
+
+    if (!llmProvider) {
+      throw new BadDataException(
+        "No LLM provider configured for this project. Please configure an LLM provider in Settings > AI > LLM Providers.",
+      );
+    }
+
+    if (!llmProvider.llmType) {
+      throw new BadDataException(
+        "LLM provider type is not configured properly.",
+      );
+    }
+
+    // Create log entry (will be updated after completion)
+    const logEntry: LlmLog = new LlmLog();
+    logEntry.projectId = request.projectId;
+    logEntry.isGlobalProvider = llmProvider.isGlobalLlm || false;
+    logEntry.feature = request.feature;
+    logEntry.requestPrompt = request.messages
+      .map((m: LLMMessage) => {
+        return m.content;
+      })
+      .join("\n")
+      .substring(0, 5000); // Store first 5000 chars
+    logEntry.requestStartedAt = startTime;
+
+    // Set optional fields only if they have values
+    if (llmProvider.id) {
+      logEntry.llmProviderId = llmProvider.id;
+    }
+    if (llmProvider.name) {
+      logEntry.llmProviderName = llmProvider.name;
+    }
+    if (llmProvider.llmType) {
+      logEntry.llmType = llmProvider.llmType;
+    }
+    if (llmProvider.modelName) {
+      logEntry.modelName = llmProvider.modelName;
+    }
+    if (request.userId) {
+      logEntry.userId = request.userId;
+    }
+    if (request.incidentId) {
+      logEntry.incidentId = request.incidentId;
+    }
+    if (request.alertId) {
+      logEntry.alertId = request.alertId;
+    }
+    if (request.scheduledMaintenanceId) {
+      logEntry.scheduledMaintenanceId = request.scheduledMaintenanceId;
+    }
+
+    // Check if billing should apply
+    const shouldBill: boolean =
+      IsBillingEnabled && (llmProvider.isGlobalLlm || false);
+
+    // Check balance if billing enabled and using global provider
+    if (shouldBill) {
+      const project: Project | null = await ProjectService.findOneById({
+        id: request.projectId,
+        select: { aiCurrentBalanceInUSDCents: true },
+        props: { isRoot: true },
+      });
+
+      if (!project || (project.aiCurrentBalanceInUSDCents || 0) <= 0) {
+        logEntry.status = LlmLogStatus.InsufficientBalance;
+        logEntry.statusMessage = "Insufficient AI balance";
+        logEntry.requestCompletedAt = new Date();
+        logEntry.durationMs = new Date().getTime() - startTime.getTime();
+
+        await LlmLogService.create({
+          data: logEntry,
+          props: { isRoot: true },
+        });
+
+        throw new BadDataException(
+          "Insufficient AI balance. Please recharge your AI balance in Project Settings > Billing.",
+        );
+      }
+    }
+
+    try {
+      // Build LLM config
+      const llmConfig: LLMProviderConfig = {
+        llmType: llmProvider.llmType,
+      };
+
+      if (llmProvider.apiKey) {
+        llmConfig.apiKey = llmProvider.apiKey;
+      }
+
+      if (llmProvider.baseUrl) {
+        llmConfig.baseUrl = llmProvider.baseUrl.toString();
+      }
+
+      if (llmProvider.modelName) {
+        llmConfig.modelName = llmProvider.modelName;
+      }
+
+      // Execute LLM call
+      const response: LLMCompletionResponse = await LLMService.getCompletion({
+        llmProviderConfig: llmConfig,
+        messages: request.messages,
+        maxTokens: request.maxTokens || 4096,
+        temperature: request.temperature ?? 0.7,
+      });
+
+      const endTime: Date = new Date();
+
+      // Update log with success info
+      logEntry.status = LlmLogStatus.Success;
+      logEntry.totalTokens = response.usage?.totalTokens || 0;
+      logEntry.responsePreview = response.content.substring(0, 2000); // Store first 2000 chars
+      logEntry.requestCompletedAt = endTime;
+      logEntry.durationMs = endTime.getTime() - startTime.getTime();
+
+      // Calculate and apply costs if using global provider with billing enabled
+      if (shouldBill && response.usage) {
+        const totalCost: number = Math.ceil(
+          (response.usage.totalTokens / 1_000_000) *
+            (llmProvider.costPerMillionTokensInUSDCents || 0),
+        );
+
+        logEntry.costInUSDCents = totalCost;
+        logEntry.wasBilled = true;
+
+        // Deduct from project balance
+        if (totalCost > 0) {
+          const project: Project | null = await ProjectService.findOneById({
+            id: request.projectId,
+            select: { aiCurrentBalanceInUSDCents: true },
+            props: { isRoot: true },
+          });
+
+          if (project) {
+            const newBalance: number = Math.max(
+              0,
+              (project.aiCurrentBalanceInUSDCents || 0) - totalCost,
+            );
+
+            await ProjectService.updateOneById({
+              id: request.projectId,
+              data: {
+                aiCurrentBalanceInUSDCents: newBalance,
+              },
+              props: { isRoot: true },
+            });
+          }
+
+          // Check if auto-recharge is needed (do this async, don't wait)
+          AIBillingService.rechargeIfBalanceIsLow(request.projectId).catch(
+            (err: Error) => {
+              logger.error("Error during AI balance auto-recharge check:");
+              logger.error(err);
+            },
+          );
+        }
+      }
+
+      // Save log entry
+      const savedLog: LlmLog = await LlmLogService.create({
+        data: logEntry,
+        props: { isRoot: true },
+      });
+
+      return {
+        content: response.content,
+        llmLog: savedLog,
+      };
+    } catch (error) {
+      // Log the error
+      logEntry.status = LlmLogStatus.Error;
+      logEntry.statusMessage =
+        error instanceof Error ? error.message : String(error);
+      logEntry.requestCompletedAt = new Date();
+      logEntry.durationMs = new Date().getTime() - startTime.getTime();
+
+      await LlmLogService.create({
+        data: logEntry,
+        props: { isRoot: true },
+      });
+
+      throw error;
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/CodeRepositoryService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/CodeRepository";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/IncidentService.ts

@@ -65,6 +65,16 @@ import OnCallDutyPolicy from "../../Models/DatabaseModels/OnCallDutyPolicy";
 import Dictionary from "../../Types/Dictionary";
 import IncidentTemplateService from "./IncidentTemplateService";
 import IncidentTemplate from "../../Models/DatabaseModels/IncidentTemplate";
+import LLMService, {
+  LLMProviderConfig,
+  LLMCompletionResponse,
+} from "../Utils/LLM/LLMService";
+import LlmProviderService from "./LlmProviderService";
+import LlmProvider from "../../Models/DatabaseModels/LlmProvider";
+import IncidentAIContextBuilder, {
+  AIGenerationContext,
+  IncidentContextData,
+} from "../Utils/AI/IncidentAIContextBuilder";
 
 // key is incidentId for this dictionary.
 type UpdateCarryForward = Dictionary<{
@@ -2388,6 +2398,85 @@ ${incidentSeverity.name}
       );
     }
   }
+
+  @CaptureSpan()
+  public async generatePostmortemFromAI(data: {
+    incidentId: ObjectID;
+    template?: string;
+  }): Promise<string> {
+    // Get the incident to verify it exists and get the project ID
+    const incident: Model | null = await this.findOneById({
+      id: data.incidentId,
+      select: {
+        _id: true,
+        projectId: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!incident || !incident.projectId) {
+      throw new BadDataException("Incident not found");
+    }
+
+    // Get LLM provider for the project
+    const llmProvider: LlmProvider | null =
+      await LlmProviderService.getLLMProviderForProject(incident.projectId);
+
+    if (!llmProvider) {
+      throw new BadDataException(
+        "No LLM provider configured for this project. Please configure an LLM provider in Settings > AI > LLM Providers.",
+      );
+    }
+
+    if (!llmProvider.llmType) {
+      throw new BadDataException(
+        "LLM provider type is not configured properly.",
+      );
+    }
+
+    // Build incident context - always include workspace messages
+    const contextData: IncidentContextData =
+      await IncidentAIContextBuilder.buildIncidentContext({
+        incidentId: data.incidentId,
+        includeWorkspaceMessages: true,
+        workspaceMessageLimit: 500,
+      });
+
+    // Format context for postmortem generation
+    const aiContext: AIGenerationContext =
+      IncidentAIContextBuilder.formatIncidentContextForPostmortem(
+        contextData,
+        data.template,
+      );
+
+    // Generate postmortem using LLM
+    const llmConfig: LLMProviderConfig = {
+      llmType: llmProvider.llmType,
+    };
+
+    if (llmProvider.apiKey) {
+      llmConfig.apiKey = llmProvider.apiKey;
+    }
+
+    if (llmProvider.baseUrl) {
+      llmConfig.baseUrl = llmProvider.baseUrl.toString();
+    }
+
+    if (llmProvider.modelName) {
+      llmConfig.modelName = llmProvider.modelName;
+    }
+
+    const response: LLMCompletionResponse = await LLMService.getCompletion({
+      llmProviderConfig: llmConfig,
+      messages: aiContext.messages,
+      maxTokens: 8192,
+      temperature: 0.7,
+    });
+
+    return response.content;
+  }
 }
 
 export default new Service();

package/Server/Services/Index.ts

@@ -87,6 +87,7 @@ import ServiceCatalogOwnerUserService from "./ServiceCatalogOwnerUserService";
 import ServiceCatalogService from "./ServiceCatalogService";
 import ServiceCatalogMonitorService from "./ServiceCatalogMonitorService";
 import ServiceCatalogTelemetryServiceService from "./ServiceCatalogTelemetryServiceService";
+import ServiceCatalogCodeRepositoryService from "./ServiceCatalogCodeRepositoryService";
 import ShortLinkService from "./ShortLinkService";
 // SMS Log Service
 import SmsLogService from "./SmsLogService";
@@ -321,6 +322,7 @@ const services: Array<BaseService> = [
   ServiceCatalogDependencyService,
   ServiceCatalogMonitorService,
   ServiceCatalogTelemetryServiceService,
+  ServiceCatalogCodeRepositoryService,
 
   TelemetryExceptionService,
 

package/Server/Services/LlmLogService.ts

@@ -0,0 +1,14 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/LlmLog";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3);
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/LlmProviderService.ts

@@ -6,6 +6,7 @@ import ObjectID from "../../Types/ObjectID";
 import UpdateBy from "../Types/Database/UpdateBy";
 import QueryHelper from "../Types/Database/QueryHelper";
 import LIMIT_MAX from "../../Types/Database/LimitMax";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -95,6 +96,63 @@ export class Service extends DatabaseService<Model> {
 
     return { updateBy, carryForward: null };
   }
+
+  @CaptureSpan()
+  public async getLLMProviderForProject(
+    projectId: ObjectID,
+  ): Promise<Model | null> {
+    // First try to get the default provider for the project
+    let provider: Model | null = await this.findOneBy({
+      query: {
+        projectId: projectId,
+        isDefault: true,
+      },
+      select: {
+        _id: true,
+        name: true,
+        llmType: true,
+        apiKey: true,
+        baseUrl: true,
+        modelName: true,
+        isGlobalLlm: true,
+        costPerMillionTokensInUSDCents: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (provider) {
+      return provider;
+    }
+
+    // If no default provider, get any global provider for the project.
+    provider = await this.findOneBy({
+      query: {
+        projectId: QueryHelper.isNull(),
+        isGlobalLlm: true,
+      },
+      select: {
+        _id: true,
+        name: true,
+        llmType: true,
+        apiKey: true,
+        baseUrl: true,
+        modelName: true,
+        isGlobalLlm: true,
+        costPerMillionTokensInUSDCents: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (provider) {
+      return provider;
+    }
+
+    return null;
+  }
 }
 
 export default new Service();

package/Server/Services/ServiceCatalogCodeRepositoryService.ts

@@ -0,0 +1,55 @@
+import BadDataException from "../../Types/Exception/BadDataException";
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/ServiceCatalogCodeRepository";
+import ObjectID from "../../Types/ObjectID";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    if (!createBy.data.serviceCatalogId && !createBy.data.serviceCatalog) {
+      throw new BadDataException("serviceCatalog is required");
+    }
+
+    if (!createBy.data.codeRepository && !createBy.data.codeRepositoryId) {
+      throw new BadDataException("codeRepository is required");
+    }
+
+    const serviceCatalogId: string | ObjectID | undefined =
+      createBy.data.serviceCatalogId || createBy.data.serviceCatalog?._id;
+    const codeRepositoryId: string | ObjectID | undefined =
+      createBy.data.codeRepositoryId || createBy.data.codeRepository?._id;
+
+    // check if this code repository is already added to the service catalog for this service.
+    const existingCodeRepository: Model | null = await this.findOneBy({
+      query: {
+        serviceCatalogId: serviceCatalogId as ObjectID,
+        codeRepositoryId: codeRepositoryId as ObjectID,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (existingCodeRepository) {
+      throw new BadDataException(
+        "Code Repository already exists for this service",
+      );
+    }
+
+    return {
+      carryForward: null,
+      createBy: createBy,
+    };
+  }
+}
+
+export default new Service();