@oneuptime/common 11.7.3 → 12.0.0

package/Server/Utils/AI/SRE/AIInvestigationEngine.ts

@@ -17,6 +17,7 @@ import LlmProviderService from "../../../Services/LlmProviderService";
 import AIInvestigationQueue from "./InvestigationQueue";
 import AIConfidenceSignal, { ConfidenceSignal } from "./ConfidenceSignal";
 import ObservabilityAssistant, {
+  ObservabilityAssistantExtraTool,
   ObservabilityAssistantResult,
   ObservabilityAssistantStep,
   ObservabilityAssistantStepType,
@@ -104,6 +105,37 @@ export interface InvestigationRequest {
     confidence: ConfidenceSignal;
     result: ObservabilityAssistantResult;
   }) => Promise<void>;
+  /*
+   * Optional: called exactly once when THIS attempt settles the run into a
+   * terminal state — Completed (with or without an analysis, and even when
+   * only postAnalysis failed afterwards) or Error once retries are
+   * exhausted. NOT called when the attempt was requeued (a later attempt
+   * settles) or when another actor won the terminal transition (that actor
+   * settles). The investigation runners use it to hand the subject to
+   * auto-remediation AFTER the RCA had its chance to post (RCA-first
+   * ordering — see RemediationHandoff). Errors are logged, never allowed
+   * to fail the run.
+   */
+  onSettled?: (() => Promise<void>) | undefined;
+  /*
+   * Optional overrides for non-investigation run kinds that reuse this
+   * engine (remediation planning/execution). Defaults preserve the classic
+   * investigation behavior exactly.
+   */
+  // Replaces INVESTIGATION_PERSONA as the appended system instructions.
+  personaOverride?: string | undefined;
+  // Replaces the "A new signal has just been declared..." user preamble.
+  questionOverride?: string | undefined;
+  /*
+   * Run-scoped tools grafted onto the loop (see
+   * ObservabilityAssistantExtraTool). The read-only toolbox is always
+   * present; extras are additive and own their own authorization.
+   */
+  extraTools?: Array<ObservabilityAssistantExtraTool> | undefined;
+  maxLlmCalls?: number | undefined;
+  maxToolCalls?: number | undefined;
+  maxWallClockMs?: number | undefined;
+  maxOutputTokens?: number | undefined;
 }
 
 export default class AIInvestigationEngine {
@@ -235,6 +267,14 @@ export default class AIInvestigationEngine {
       await this.touchHeartbeat(aiRunId);
     };
 
+    /*
+     * Whether THIS attempt won the Running -> Completed transition. Once it
+     * did, the run is terminally settled by this attempt no matter what
+     * happens afterwards (a postAnalysis failure does not un-complete it),
+     * so the settlement callback must still fire from the catch block.
+     */
+    let settledAsCompleted: boolean = false;
+
     try {
       const result: ObservabilityAssistantResult =
         await ObservabilityAssistant.answerQuestion({
@@ -242,13 +282,17 @@ export default class AIInvestigationEngine {
           // System run — full read access to the project's telemetry.
           props: { isRoot: true },
           feature: request.feature,
-          systemInstructions: INVESTIGATION_PERSONA,
-          question: `A new signal has just been declared and you have been woken to investigate it. Investigate now and produce your root cause analysis.\n\n${request.contextSummary}`,
-          maxLlmCalls: MAX_LLM_CALLS,
-          maxToolCalls: MAX_TOOL_CALLS,
-          maxWallClockMs: MAX_WALL_CLOCK_MS,
-          maxOutputTokens: MAX_OUTPUT_TOKENS,
+          systemInstructions: request.personaOverride ?? INVESTIGATION_PERSONA,
+          question: `${
+            request.questionOverride ??
+            "A new signal has just been declared and you have been woken to investigate it. Investigate now and produce your root cause analysis."
+          }\n\n${request.contextSummary}`,
+          maxLlmCalls: request.maxLlmCalls ?? MAX_LLM_CALLS,
+          maxToolCalls: request.maxToolCalls ?? MAX_TOOL_CALLS,
+          maxWallClockMs: request.maxWallClockMs ?? MAX_WALL_CLOCK_MS,
+          maxOutputTokens: request.maxOutputTokens ?? MAX_OUTPUT_TOKENS,
           onStep,
+          extraTools: request.extraTools,
         });
 
       /*
@@ -281,6 +325,8 @@ export default class AIInvestigationEngine {
         return;
       }
 
+      settledAsCompleted = true;
+
       await this.emitEvent({
         projectId,
         aiRunId,
@@ -294,6 +340,12 @@ export default class AIInvestigationEngine {
         logger.debug(
           `AI: investigation (run ${aiRunId.toString()}) produced no analysis; nothing posted.`,
         );
+
+        /*
+         * No analysis is still a settled run — the subject must not lose
+         * its deferred remediation because the model had nothing to say.
+         */
+        await this.invokeOnSettled(request, aiRunId);
         return;
       }
 
@@ -330,6 +382,9 @@ export default class AIInvestigationEngine {
       logger.debug(
         `AI: investigation complete (run ${aiRunId.toString()}, confident=${confidence.confident} via ${confidence.source}, ${result.llmCallCount} LLM calls, ${result.toolCallCount} tools, ${result.totalTokens} tokens).`,
       );
+
+      // The run is settled and the RCA posted — release deferred follow-ups.
+      await this.invokeOnSettled(request, aiRunId);
     } catch (error) {
       const message: string =
         error instanceof Error ? error.message : String(error);
@@ -351,12 +406,26 @@ export default class AIInvestigationEngine {
        * Only configuration/budget gating — which a retry cannot change
        * within the run's usefulness window — counts as permanent.
        */
-      await AIInvestigationQueue.failOrRequeue({
-        aiRunId,
-        attemptCount: data.attemptCount,
-        errorMessage: message,
-        isPermanent: PERMANENT_FAILURE_RE.test(message),
-      });
+      const outcome: "requeued" | "finalized" | "noop" =
+        await AIInvestigationQueue.failOrRequeue({
+          aiRunId,
+          attemptCount: data.attemptCount,
+          errorMessage: message,
+          isPermanent: PERMANENT_FAILURE_RE.test(message),
+        });
+
+      /*
+       * Settle-once discipline: fire the settlement callback when this
+       * attempt terminally owns the run — either it already won the
+       * Completed transition (the error came from confidence/postAnalysis
+       * afterwards; failOrRequeue no-ops on a Completed run) or this
+       * failOrRequeue finalized it as Error. A requeued attempt is NOT
+       * settled (the retry owns it), and "noop" without a won Completed
+       * means another actor moved the run and owns settlement.
+       */
+      if (settledAsCompleted || outcome === "finalized") {
+        await this.invokeOnSettled(request, aiRunId);
+      }
 
       logger.error(
         `AI: investigation attempt ${data.attemptCount} failed (run ${aiRunId.toString()}): ${message}`,
@@ -364,6 +433,28 @@ export default class AIInvestigationEngine {
     }
   }
 
+  /*
+   * Fire the caller's settlement callback, exactly at the points where this
+   * attempt terminally settled the run. Best-effort by contract: the run is
+   * already settled, so a hand-off failure is logged and swallowed.
+   */
+  private static async invokeOnSettled(
+    request: InvestigationRequest,
+    aiRunId: ObjectID,
+  ): Promise<void> {
+    if (!request.onSettled) {
+      return;
+    }
+
+    try {
+      await request.onSettled();
+    } catch (error) {
+      logger.error(
+        `AI: post-settlement follow-up failed for run ${aiRunId.toString()}: ${error}`,
+      );
+    }
+  }
+
   // Wrap the agent's analysis with AI branding + an evidence list.
   private static buildBrandedMarkdown(
     result: ObservabilityAssistantResult,

package/Server/Utils/AI/SRE/AlertInvestigationRunner.ts

@@ -20,7 +20,9 @@ import { AI_ALERT_INVESTIGATION_FEATURE } from "../../../Services/AIService";
 import AIInvestigationEngine from "./AIInvestigationEngine";
 import AIInvestigationQueue from "./InvestigationQueue";
 import AIConfidenceSignal, { ConfidenceSignal } from "./ConfidenceSignal";
+import FixFromIncidentTaskTrigger from "./FixFromIncidentTaskTrigger";
 import InstrumentationTaskTrigger from "./InstrumentationTaskTrigger";
+import RemediationHandoff from "./RemediationHandoff";
 import { ObservabilityAssistantResult } from "../Chat/ObservabilityAssistant";
 import logger from "../../Logger";
 import CaptureSpan from "../../Telemetry/CaptureSpan";
@@ -60,19 +62,25 @@ export default class AIAlertInvestigationRunner {
    * Entry point called (fire-and-forget) from AlertService.onCreateSuccess.
    * Cheap: gates + a Queued AIRun row; execution happens via the queue.
    * Never throws — all failures are logged.
+   *
+   * Returns whether an investigation run was actually enqueued: the create
+   * hook DEFERS auto-remediation when one was (the RCA-first ordering —
+   * remediation is released by RemediationHandoff when the run settles) and
+   * applies the rules immediately when none was, so remediation never
+   * silently depends on the AI lane.
    */
   @CaptureSpan()
   public static async investigateNewAlert(data: {
     alertId: ObjectID;
     projectId: ObjectID;
-  }): Promise<void> {
+  }): Promise<boolean> {
     const { alertId, projectId } = data;
 
     try {
       if (
         !(await AIInvestigationEngine.isEnabledForProject(projectId, "Alert"))
       ) {
-        return;
+        return false;
       }
 
       const gate: AlertGateDecision = await this.shouldInvestigateAlert({
@@ -84,18 +92,23 @@ export default class AIAlertInvestigationRunner {
         logger.debug(
           `AI: skipping investigation for alert ${alertId.toString()} — ${gate.reason}.`,
         );
-        return;
+        return false;
       }
 
-      await AIInvestigationQueue.enqueue({
-        projectId,
-        subjectAlertId: alertId,
-        subjectMonitorId: gate.monitorId,
-      });
+      const enqueuedRunId: ObjectID | null = await AIInvestigationQueue.enqueue(
+        {
+          projectId,
+          subjectAlertId: alertId,
+          subjectMonitorId: gate.monitorId,
+        },
+      );
+
+      return enqueuedRunId !== null;
     } catch (error) {
       logger.error(
         `AI: unexpected error enqueueing investigation for alert ${alertId.toString()}: ${error}`,
       );
+      return false;
     }
   }
 
@@ -125,16 +138,27 @@ export default class AIAlertInvestigationRunner {
     } catch (error) {
       /*
        * Context assembly failed — the run is claimed, so hand it to the
-       * retry policy rather than leaving it Running until the sweeper.
+       * retry policy rather than leaving it Running until the sweeper. When
+       * this failure FINALIZED the run (retries exhausted), the alert is
+       * terminally settled here and must still be released to
+       * auto-remediation (RCA-first ordering).
        */
-      await AIInvestigationQueue.failOrRequeue({
-        aiRunId,
-        attemptCount,
-        errorMessage: `Failed to build alert context: ${
-          error instanceof Error ? error.message : String(error)
-        }`,
-        isPermanent: false,
-      });
+      const outcome: "requeued" | "finalized" | "noop" =
+        await AIInvestigationQueue.failOrRequeue({
+          aiRunId,
+          attemptCount,
+          errorMessage: `Failed to build alert context: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+          isPermanent: false,
+        });
+
+      if (outcome === "finalized") {
+        await RemediationHandoff.runForSettledInvestigation({
+          projectId,
+          alertId,
+        });
+      }
       return;
     }
 
@@ -194,6 +218,40 @@ export default class AIAlertInvestigationRunner {
               },
             );
           }
+
+          /*
+           * The confident twin: a POSITIVE confident classification means
+           * the posted analysis asserts an evidenced root cause — for
+           * opted-in projects (Project.enableAutomaticCodeFixes, default
+           * false), automatically queue the FixFromIncident task that
+           * opens a draft fix PR from this analysis (the automatic form
+           * of the "Open Fix PR from this analysis" button). Runs strictly
+           * AFTER the analysis is posted because the posted RootCause feed
+           * item IS the fix task's entire context, and the trigger never
+           * throws. Fail direction (G6): the deterministic floor and a
+           * failed classification never auto-open a PR.
+           */
+          if (
+            AIConfidenceSignal.shouldAutoEnqueueCodeFixTask(postData.confidence)
+          ) {
+            await FixFromIncidentTaskTrigger.autoEnqueueFromConfidentInvestigation(
+              {
+                projectId,
+                alertId,
+              },
+            );
+          }
+        },
+        /*
+         * RCA-first ordering: auto-remediation for this alert was deferred
+         * at creation because this investigation was enqueued — release it
+         * now that the run has settled (any terminal outcome).
+         */
+        onSettled: async (): Promise<void> => {
+          await RemediationHandoff.runForSettledInvestigation({
+            projectId,
+            alertId,
+          });
         },
       },
     });

package/Server/Utils/AI/SRE/ConfidenceSignal.ts

@@ -33,12 +33,12 @@ import CaptureSpan from "../../Telemetry/CaptureSpan";
  * degradation when the classification itself failed (unparseable response or
  * the call errored). As implemented:
  *
- *   | source                | confident | workspace ping | instrumentation PR |
- *   |-----------------------|-----------|----------------|--------------------|
- *   | deterministic-floor   | false     | no (quiet)     | yes (enqueue)      |
- *   | classification        | true      | yes            | no                 |
- *   | classification        | false     | no (quiet)     | yes (enqueue)      |
- *   | classification-failed | false (*) | YES — louder   | NO — no PR         |
+ *   | source                | confident | workspace ping | instrumentation PR | auto fix PR |
+ *   |-----------------------|-----------|----------------|--------------------|-------------|
+ *   | deterministic-floor   | false     | no (quiet)     | yes (enqueue)      | no          |
+ *   | classification        | true      | yes            | no                 | yes         |
+ *   | classification        | false     | no (quiet)     | yes (enqueue)      | no          |
+ *   | classification-failed | false (*) | YES — louder   | NO — no PR         | NO — no PR  |
  *
  *   - The workspace ping treats classification-failed as CONFIDENT: quiet
  *     mode's fail direction is "louder, not silent" (vision §6) — a broken
@@ -47,6 +47,11 @@ import CaptureSpan from "../../Telemetry/CaptureSpan";
  *     NOT-inconclusive: autonomous PR creation (G11 posture) requires a
  *     POSITIVE, verified inconclusive verdict — "we don't know" must fail
  *     toward doing nothing.
+ *   - The automatic fix-PR trigger requires a POSITIVE confident verdict
+ *     from the constrained classification: the deterministic floor (no
+ *     evidence) and a failed classification both fail toward doing
+ *     nothing — same G11 posture as the instrumentation trigger, opposite
+ *     verdict.
  *   - (*) When source is "classification-failed" the `confident` boolean is
  *     a placeholder, NOT a verdict — consumers must route decisions through
  *     the helpers below, never through the raw boolean.
@@ -216,6 +221,23 @@ export default class AIConfidenceSignal {
     return !signal.confident;
   }
 
+  /*
+   * Consumer decision: should a FixFromIncident code-fix task be enqueued
+   * automatically (projects opted in via Project.enableAutomaticCodeFixes —
+   * the trigger has its own gates)? Requires a POSITIVE confident verdict
+   * from the constrained classification: the analysis asserts a specific,
+   * evidenced root cause worth turning into a fix PR. Fail directions:
+   * the deterministic floor (no server-minted evidence) and
+   * classification-failed both return FALSE — autonomous PR creation fails
+   * toward doing nothing (G11 posture), mirroring the instrumentation
+   * trigger's direction on the opposite verdict.
+   */
+  public static shouldAutoEnqueueCodeFixTask(
+    signal: ConfidenceSignal,
+  ): boolean {
+    return signal.source === "classification" && signal.confident === true;
+  }
+
   /*
    * Compute the full signal: deterministic floor first (no LLM call when it
    * fails), then one constrained classification call. NEVER throws — an

package/Server/Utils/AI/SRE/FixFromIncidentTaskTrigger.ts

@@ -4,27 +4,53 @@ import AIRunStatus from "../../../../Types/AI/AIRunStatus";
 import CodeFixTaskType from "../../../../Types/AI/CodeFixTaskType";
 import BadDataException from "../../../../Types/Exception/BadDataException";
 import AIRun from "../../../../Models/DatabaseModels/AIRun";
+import Project from "../../../../Models/DatabaseModels/Project";
 import AIRunService from "../../../Services/AIRunService";
+import ProjectService from "../../../Services/ProjectService";
+import FixRunBudget, { FixRunBudgetDecision } from "../CodeFix/FixRunBudget";
 import SubjectCodeFixRun from "./SubjectCodeFixRun";
+import logger from "../../Logger";
 import CaptureSpan from "../../Telemetry/CaptureSpan";
 
 /*
  * AI SRE — the FixFromIncident trigger (the roadmap's headline `code_fix`
- * capability, vision §4.8, in human-triggered form).
+ * capability, vision §4.8), in two forms:
  *
- * After a AI investigation posts a root-cause analysis on an incident
- * or alert, the user can click "Open Fix PR from this analysis" on the
- * investigation panel: the agent takes the posted analysis (the RootCause
- * feed item) as its entire context and opens a fix pull request. Unlike the
- * ImproveInstrumentation sibling this is NOT automatic — a human reads the
- * analysis and decides a fix PR is worth opening, so no project opt-in flag
- * is needed: the human in the loop IS the gate (G11 posture preserved).
+ * HUMAN-TRIGGERED: after an AI investigation posts a root-cause analysis on
+ * an incident or alert, the user can click "Open Fix PR from this analysis"
+ * on the investigation panel: the agent takes the posted analysis (the
+ * RootCause feed item) as its entire context and opens a fix pull request.
+ * No project opt-in flag is needed for this form: the human in the loop IS
+ * the gate (G11 posture preserved). It runs inside a user-facing endpoint
+ * (POST /ai-investigation/create-fix-task) and FAILS EARLY with a clear
+ * message when a gate is not met.
  *
- * And unlike InstrumentationTaskTrigger (fire-and-forget inside the
- * investigation's postAnalysis, never throws), this runs inside a
- * user-facing endpoint (POST /ai-investigation/create-fix-task) and FAILS
- * EARLY with a clear message when a gate is not met.
+ * AUTOMATIC: for projects that opted in (Project.enableAutomaticCodeFixes,
+ * default FALSE — G11 posture: autonomous PR creation is opt-in only), an
+ * investigation that ends with a POSITIVE confident classification (per the
+ * structured G6 confidence signal, never the analysis prose) enqueues the
+ * same FixFromIncident task with no human click. Like its
+ * InstrumentationTaskTrigger sibling it is fire-and-forget inside the
+ * investigation's postAnalysis and never throws. The PR still opens as a
+ * DRAFT and is always human-reviewed — the opt-in moves the human gate from
+ * PR creation to PR review, never past it.
  */
+
+export interface AutoFixTaskGateInput {
+  // The project row with enableAi + enableAutomaticCodeFixes selected.
+  project: Project | null;
+  // Whether the project has at least one GitHub-App-connected repository.
+  hasConnectedRepository: boolean;
+  // A non-terminal FixFromIncident run for the same subject, if any.
+  existingRun: AIRun | null;
+}
+
+export interface AutoFixTaskGateDecision {
+  enqueue: boolean;
+  // Human-readable reason recorded in the debug log when skipping.
+  reason: string;
+}
+
 export default class FixFromIncidentTaskTrigger {
   /*
    * Gate and enqueue a FixFromIncident CodeFix run for the subject. The
@@ -112,4 +138,168 @@ export default class FixFromIncidentTaskTrigger {
       userId: data.userId,
     });
   }
+
+  /*
+   * The pure trigger decision for the AUTOMATIC form, separated from IO so
+   * it can be tested directly: strict opt-in (default FALSE), a repository
+   * the agent can actually open a PR against, and the per-subject dedupe
+   * guard. The caller has already established the confident-investigation
+   * prerequisite (this runs inside the investigation's postAnalysis, gated
+   * by AIConfidenceSignal.shouldAutoEnqueueCodeFixTask).
+   */
+  public static shouldAutoEnqueueFixTask(
+    input: AutoFixTaskGateInput,
+  ): AutoFixTaskGateDecision {
+    if (!input.project) {
+      return { enqueue: false, reason: "project not found" };
+    }
+
+    if (input.project.enableAi === false) {
+      return { enqueue: false, reason: "AI is disabled for the project" };
+    }
+
+    /*
+     * Strict opt-in — the column defaults to false, so unset/legacy rows
+     * never enqueue. Autonomous PR creation must never be default-on.
+     */
+    if (input.project.enableAutomaticCodeFixes !== true) {
+      return {
+        enqueue: false,
+        reason: "project has not opted in to automatic code fixes",
+      };
+    }
+
+    if (!input.hasConnectedRepository) {
+      return {
+        enqueue: false,
+        reason: "project has no GitHub-App-connected repository",
+      };
+    }
+
+    /*
+     * Dedupe: at most one non-terminal FixFromIncident run per
+     * incident/alert — an automatic trigger racing a human click (or a
+     * re-investigation) must not fan out into duplicate PRs.
+     */
+    if (input.existingRun) {
+      return {
+        enqueue: false,
+        reason:
+          "a non-terminal FixFromIncident run already exists for this subject",
+      };
+    }
+
+    return {
+      enqueue: true,
+      reason: "passed opt-in, repository and dedupe gates",
+    };
+  }
+
+  /*
+   * The AUTOMATIC form: enqueue a FixFromIncident run for a subject whose
+   * investigation just posted a CONFIDENT analysis. Exactly one of
+   * incidentId/alertId is expected. NEVER throws — every failure is logged
+   * and swallowed, because this runs inside the investigation's
+   * postAnalysis and must not fail it. No userId: the run stays
+   * system-authored.
+   */
+  @CaptureSpan()
+  public static async autoEnqueueFromConfidentInvestigation(data: {
+    projectId: ObjectID;
+    incidentId?: ObjectID | undefined;
+    alertId?: ObjectID | undefined;
+  }): Promise<void> {
+    const { projectId } = data;
+
+    try {
+      if (!data.incidentId && !data.alertId) {
+        return;
+      }
+
+      const project: Project | null = await ProjectService.findOneById({
+        id: projectId,
+        select: {
+          enableAi: true,
+          enableAutomaticCodeFixes: true,
+        },
+        props: { isRoot: true },
+      });
+
+      /*
+       * Cheapest gate first: skip the repository count for the (default)
+       * not-opted-in case.
+       */
+      const optInDecision: AutoFixTaskGateDecision =
+        this.shouldAutoEnqueueFixTask({
+          project,
+          hasConnectedRepository: true,
+          existingRun: null,
+        });
+
+      if (!optInDecision.enqueue) {
+        logger.debug(
+          `AI: not auto-enqueueing fix task for project ${projectId.toString()} — ${optInDecision.reason}.`,
+        );
+        return;
+      }
+
+      /*
+       * G11 guardrail: the per-project daily fix-run budget. For this
+       * AUTOMATIC trigger, over-budget is a logged skip — never an error
+       * thrown into the investigation.
+       */
+      const budget: FixRunBudgetDecision =
+        await FixRunBudget.getBudgetStatus(projectId);
+
+      if (!budget.allowed) {
+        logger.debug(
+          `AI: not auto-enqueueing fix task for project ${projectId.toString()} — ${FixRunBudget.describeRejection(budget)}`,
+        );
+        return;
+      }
+
+      const hasConnectedRepository: boolean =
+        await SubjectCodeFixRun.hasGitHubAppConnectedRepository(projectId);
+
+      const existingRun: AIRun | null =
+        await SubjectCodeFixRun.findNonTerminalRunForSubject({
+          taskType: CodeFixTaskType.FixFromIncident,
+          incidentId: data.incidentId,
+          alertId: data.alertId,
+        });
+
+      const decision: AutoFixTaskGateDecision = this.shouldAutoEnqueueFixTask({
+        project,
+        hasConnectedRepository,
+        existingRun,
+      });
+
+      if (!decision.enqueue) {
+        logger.debug(
+          `AI: not auto-enqueueing fix task for project ${projectId.toString()} — ${decision.reason}.`,
+        );
+        return;
+      }
+
+      const createdRun: AIRun =
+        await SubjectCodeFixRun.enqueueSubjectCodeFixRun({
+          projectId,
+          taskType: CodeFixTaskType.FixFromIncident,
+          incidentId: data.incidentId,
+          alertId: data.alertId,
+        });
+
+      logger.debug(
+        `AI: auto-enqueued FixFromIncident run ${createdRun.id?.toString()} for ${
+          data.incidentId
+            ? `incident ${data.incidentId.toString()}`
+            : `alert ${data.alertId?.toString()}`
+        } after a confident investigation.`,
+      );
+    } catch (error) {
+      logger.error(
+        `AI: failed to auto-enqueue fix task for project ${projectId.toString()}: ${error}`,
+      );
+    }
+  }
 }