@oneuptime/common 11.5.7 → 11.5.9

package/Server/API/AIAgentTaskAPI.ts

@@ -196,6 +196,7 @@ export default class AIAgentTaskAPI {
           const validStatuses: Array<AIAgentTaskStatus> = [
             AIAgentTaskStatus.InProgress,
             AIAgentTaskStatus.Completed,
+            AIAgentTaskStatus.NoFixFound,
             AIAgentTaskStatus.Error,
           ];
 
@@ -249,16 +250,35 @@ export default class AIAgentTaskAPI {
               },
             });
           } else {
-            const toStatus: AIRunStatus =
-              status === AIAgentTaskStatus.Completed
-                ? AIRunStatus.Completed
-                : AIRunStatus.Error;
+            /*
+             * Agents that predate NoFixFound report a fruitless run as Error,
+             * so an Error report still maps straight through — those runs keep
+             * looking exactly as they do today until the agent is upgraded.
+             */
+            let toStatus: AIRunStatus = AIRunStatus.Error;
+
+            if (status === AIAgentTaskStatus.Completed) {
+              toStatus = AIRunStatus.Completed;
+            } else if (status === AIAgentTaskStatus.NoFixFound) {
+              toStatus = AIRunStatus.NoFixFound;
+            }
+
+            /*
+             * Both terminal outcomes that carry a reason store it in
+             * errorMessage — the column is the run's only message field, and
+             * every reader (the detail page, the exception page's
+             * statusMessage) already renders it.
+             */
+            const shouldStoreMessage: boolean =
+              Boolean(statusMessage) &&
+              (toStatus === AIRunStatus.Error ||
+                toStatus === AIRunStatus.NoFixFound);
 
             /*
-             * 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.
+             * CAS Running -> Completed/NoFixFound/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({
@@ -268,7 +288,7 @@ export default class AIAgentTaskAPI {
                   status: toStatus,
                   completedAt: OneUptimeDate.getCurrentDate(),
                   lastHeartbeatAt: OneUptimeDate.getCurrentDate(),
-                  ...(toStatus === AIRunStatus.Error && statusMessage
+                  ...(shouldStoreMessage
                     ? { errorMessage: statusMessage }
                     : {}),
                 },
@@ -278,10 +298,16 @@ export default class AIAgentTaskAPI {
               await AIRunEventService.appendEventToRun({
                 projectId: existingRun.projectId,
                 aiRunId: runId,
+                /*
+                 * Only a genuine failure closes the event trail with
+                 * RunFailed. A NoFixFound run ran to completion and reported
+                 * a conclusion, so it closes with RunCompleted and carries
+                 * the "no fix" reason in resultSummary.
+                 */
                 eventType:
-                  toStatus === AIRunStatus.Completed
-                    ? AIRunEventType.RunCompleted
-                    : AIRunEventType.RunFailed,
+                  toStatus === AIRunStatus.Error
+                    ? AIRunEventType.RunFailed
+                    : AIRunEventType.RunCompleted,
                 ...(statusMessage
                   ? { resultSummary: { message: statusMessage } }
                   : {}),

package/Server/API/AIAgentTaskLogAPI.ts

@@ -120,6 +120,31 @@ export default class AIAgentTaskLogAPI {
             );
           }
 
+          /*
+           * Optional verbatim tool detail (see TaskLogger.toolCall): the
+           * arguments as executed and the full output the model saw, recorded
+           * on the run's transcript for the Logs page. Absent it — an older
+           * agent — behaviour is exactly as before.
+           *
+           * The event type stays ProgressLog even when the detail is present.
+           * That is deliberate, not laziness: the Overview's ChatActivityFeed
+           * renders a ProgressLog by printing resultSummary.message, but
+           * renders a ToolCallCompleted by trying to COMPLETE a matching
+           * running step from an earlier ToolCallStarted — an event the
+           * code-fix path never emits. Typing these as ToolCallCompleted
+           * therefore matched nothing and silently erased every tool line from
+           * the Overview feed. The payload rides on the same event instead.
+           */
+          const toolName: string | undefined = data["toolName"] as
+            | string
+            | undefined;
+          const toolArguments: JSONObject | undefined = data[
+            "toolArguments"
+          ] as JSONObject | undefined;
+          const toolResult: string | undefined = data["toolResult"] as
+            | string
+            | undefined;
+
           await AIRunEventService.appendEventToRun({
             projectId: existingRun.projectId,
             aiRunId: runId,
@@ -128,6 +153,30 @@ export default class AIAgentTaskLogAPI {
               message: message,
               severity: severity,
             },
+            ...(toolName ? { toolName: toolName } : {}),
+            /*
+             * toolArguments (the column) is deliberately NOT written: its read
+             * ACL is project-member-wide, and a write_file call's arguments are
+             * the file's full new content. The same arguments go onto
+             * contentPayload below, whose read ACL is empty and which only the
+             * owner/admin-gated logs endpoint returns.
+             */
+            ...(toolName
+              ? {
+                  contentPayload: {
+                    ...(toolResult !== undefined
+                      ? { toolResult: toolResult }
+                      : {}),
+                    ...(toolArguments
+                      ? {
+                          responseToolCalls: [
+                            { name: toolName, arguments: toolArguments },
+                          ],
+                        }
+                      : {}),
+                  },
+                }
+              : {}),
           });
 
           /* A progress report proves the agent is alive — refresh the heartbeat. */

package/Server/API/AIChatAPI.ts

@@ -21,6 +21,10 @@ import SubscriptionPlan, {
 import { IsBillingEnabled, getAllEnvVars } from "../EnvironmentConfig";
 import AIChatMessageRole from "../../Types/AI/AIChatMessageRole";
 import AIChatMessageStatus from "../../Types/AI/AIChatMessageStatus";
+import {
+  AIChatPageContext,
+  AIChatPageContextHelper,
+} from "../../Types/AI/AIChatPageContext";
 import AIChatPermissionMode, {
   AIChatPermissionModeHelper,
 } from "../../Types/AI/AIChatPermissionMode";
@@ -143,6 +147,16 @@ router.post(
           ? (req.body["permissionMode"] as AIChatPermissionMode)
           : undefined;
 
+      /*
+       * Optional page context — what the user was looking at when they asked
+       * (an incident, a monitor, the logs explorer, …). It is a hint for the
+       * system prompt, so an invalid payload is dropped, never an error.
+       */
+      const pageContext: AIChatPageContext | undefined =
+        AIChatPageContextHelper.sanitize(
+          req.body["pageContext"] as JSONObject | undefined,
+        );
+
       // Plan gate: custom endpoints get no automatic billing check.
       if (
         IsBillingEnabled &&
@@ -435,6 +449,7 @@ router.post(
         aiRunId: createdRun.id!,
         llmProviderId: effectiveLlmProviderId,
         permissionMode: effectivePermissionMode,
+        pageContext: pageContext,
         props: props,
       }).catch((error: Error) => {
         logger.error(`AI chat turn crashed: ${error.message}`);
@@ -498,6 +513,7 @@ router.post(
           return {
             id: provider.id?.toString(),
             name: provider.name,
+            description: provider.description || null,
             llmType: provider.llmType?.toString() || null,
             modelName: provider.modelName || null,
             isDefault: provider.isDefault || false,

package/Server/API/AIReadinessAPI.ts

@@ -0,0 +1,84 @@
+import Express, {
+  ExpressRequest,
+  ExpressResponse,
+  ExpressRouter,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import UserMiddleware from "../Middleware/UserAuthorization";
+import CommonAPI from "./CommonAPI";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import NotAuthorizedException from "../../Types/Exception/NotAuthorizedException";
+import BadDataException from "../../Types/Exception/BadDataException";
+import { JSONArray } from "../../Types/JSON";
+import { AIFixReadiness } from "../../Types/AI/AIFixReadiness";
+import CodeFixReadiness from "../Utils/AI/CodeFix/CodeFixReadiness";
+
+/*
+ * Project-wide "can AI actually do anything here?" — the gates a CodeFix run
+ * passes through, answered for the whole project rather than one exception.
+ * The AI Tasks page renders this instead of a static prerequisites banner, so
+ * what the user reads reflects what the server would actually decide.
+ *
+ * The per-exception equivalent lives at
+ * GET /telemetry-exception/ai-fix-readiness/:id; both share the checks in
+ * CodeFixReadiness, so they cannot drift apart.
+ */
+const router: ExpressRouter = Express.getRouter();
+
+router.post(
+  "/ai-readiness/code-fix",
+  UserMiddleware.getUserMiddleware,
+  async (
+    req: ExpressRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const props: DatabaseCommonInteractionProps =
+        await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+      /*
+       * Authorize explicitly. getUserMiddleware admits anonymous callers
+       * (it sets userType = Public and calls next()), and tenantId is read
+       * straight off the caller-supplied `tenantid` header before any auth
+       * runs — so neither is evidence of anything on its own. The readiness
+       * checks below all query with `isRoot: true`, which means there is no
+       * RBAC layer underneath to catch an unauthorized caller: this handler
+       * is the only gate. The per-exception sibling gets away without this
+       * because it loads the exception with the caller's props first, and
+       * derives the project from that authorized row.
+       */
+      if (!props.userId) {
+        throw new NotAuthorizedException(
+          "AI readiness requires a logged-in user session.",
+        );
+      }
+
+      if (!props.tenantId) {
+        throw new BadDataException("Project ID is required (tenantid header).");
+      }
+
+      // Being logged in somewhere is not access to THIS project.
+      if (!props.userTenantAccessPermission?.[props.tenantId.toString()]) {
+        throw new NotAuthorizedException(
+          "You do not have access to this project.",
+        );
+      }
+
+      const readiness: AIFixReadiness =
+        await CodeFixReadiness.getProjectReadiness({
+          projectId: props.tenantId,
+        });
+
+      return Response.sendJsonObjectResponse(req, res, {
+        ready: readiness.ready,
+        checks: readiness.checks as unknown as JSONArray,
+      });
+    } catch (err) {
+      next(err);
+    }
+  },
+);
+
+export default router;

package/Server/API/CodeFixRunAPI.ts

@@ -8,37 +8,48 @@ import Express, {
 } from "../Utils/Express";
 import Response from "../Utils/Response";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import DatabaseCommonInteractionPropsUtil, {
+  PermissionType,
+} from "../../Types/BaseDatabase/DatabaseCommonInteractionPropsUtil";
 import ObjectID from "../../Types/ObjectID";
-import PositiveNumber from "../../Types/PositiveNumber";
 import BadDataException from "../../Types/Exception/BadDataException";
 import NotAuthorizedException from "../../Types/Exception/NotAuthorizedException";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
-import Query from "../../Types/BaseDatabase/Query";
 import Select from "../Types/Database/Select";
 import { JSONObject } from "../../Types/JSON";
+import Permission, { UserPermission } from "../../Types/Permission";
 import AIRunType from "../../Types/AI/AIRunType";
 import { CodeFixTaskTypeHelper } from "../../Types/AI/CodeFixTaskType";
 import AIRun from "../../Models/DatabaseModels/AIRun";
 import AIRunEvent from "../../Models/DatabaseModels/AIRunEvent";
+import LlmLog from "../../Models/DatabaseModels/LlmLog";
 import Project from "../../Models/DatabaseModels/Project";
 import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import ProjectService from "../Services/ProjectService";
 import AIRunService from "../Services/AIRunService";
 import AIRunEventService from "../Services/AIRunEventService";
+import LlmLogService from "../Services/LlmLogService";
 
-const DEFAULT_LIMIT: number = 25;
-const MAX_LIMIT: number = 100;
 const MAX_EVENTS: number = 500;
 
 /*
- * Dedicated read endpoints for the dashboard's AI fix-task pages.
+ * The AI fix task detail page's event trail.
  *
- * Code-fix runs are system-authored AIRuns (runType CodeFix, userId = null)
- * and are therefore hidden by the per-user privacy pin on the generic
- * AIRun / AIRunEvent CRUD. So access is gated explicitly here — the same
- * pattern as AIInvestigationAPI: first confirm the caller can read the
- * parent object (the project) under THEIR permissions, then read the runs
- * and their events as root.
+ * The LIST page does NOT come through here — it reads AIRuns through the
+ * standard /ai-run CRUD, which AIRunService opens up for code-fix runs via a
+ * forced `runType = CodeFix OR userId = <caller>` clause (see
+ * Utils/AI/AIRunPrivacyFilter).
+ *
+ * The events cannot follow. AIRunEvent has NO runType column to key that
+ * clause off, and "userId is null" does not mean "system-authored" — the
+ * investigation engine writes null-userId events too — so project-scoping
+ * AIRunEvent wholesale would expose other members' CHAT toolArguments, which
+ * carry user-typed prompt content. Events are therefore still reached only
+ * through a run this endpoint has already authorized as runType = CodeFix.
+ *
+ * Access is gated explicitly, the same pattern as AIInvestigationAPI: confirm
+ * the caller can read the parent object (the project) under THEIR permissions,
+ * then read the run and its events as root.
  */
 
 const RUN_SELECT: Select<AIRun> = {
@@ -51,8 +62,62 @@ const RUN_SELECT: Select<AIRun> = {
   triggeredByTelemetryExceptionId: true,
   totalTokens: true,
   codeFixTaskType: true,
+  taskNumber: true,
+  attemptCount: true,
+  llmCallCount: true,
+  toolCallCount: true,
+  /*
+   * Deliberately NOT selected: totalCostInUSDCents. This endpoint's gate is
+   * Project read, which admits roles beyond AIRun's own table ACL, so it must
+   * not return more than the detail page renders — and nothing there renders
+   * per-run spend.
+   */
+};
+
+/*
+ * The Logs page's event trail.
+ *
+ * toolArguments is deliberately NOT selected, even though this endpoint reads
+ * as root and could. A code-fix write_file call carries the file's full new
+ * content in its arguments, and that column's own read ACL stops at
+ * ProjectMember — narrower than this endpoint's Project-read gate, which also
+ * admits Viewers. Returning it would leak the same customer source code that
+ * contentPayload is stripped below to protect, to an even wider audience. The
+ * page never needed it: Logs.tsx renders tool arguments from
+ * contentPayload.responseToolCalls, the owner/admin-gated copy.
+ */
+const LOG_EVENT_SELECT: Select<AIRunEvent> = {
+  _id: true,
+  sequence: true,
+  eventType: true,
+  toolName: true,
+  resultSummary: true,
+  citationId: true,
+  createdAt: true,
+  contentPayload: true,
 };
 
+/*
+ * The per-LLM-call metering shown beside the transcript. Read under the
+ * CALLER's permissions (not root), so LlmLog's own table ACL decides who sees
+ * it rather than this endpoint's broader Project-read gate.
+ */
+const LLM_LOG_SELECT: Select<LlmLog> = {
+  _id: true,
+  modelName: true,
+  llmProviderName: true,
+  status: true,
+  statusMessage: true,
+  totalTokens: true,
+  completionTokens: true,
+  durationMs: true,
+  requestStartedAt: true,
+  requestCompletedAt: true,
+  createdAt: true,
+};
+
+const MAX_LLM_LOGS: number = 500;
+
 /*
  * Serialize a run with codeFixTaskType normalized: a null column means
  * FixException (rows created before task recipes existed), and clients
@@ -81,9 +146,9 @@ export default class CodeFixRunAPI {
   }
 
   private initRoutes(): void {
-    // List the project's code-fix runs, newest first.
+    // One run + its ordered glass-box event trail.
     this.router.post(
-      "/code-fix-run/list",
+      "/code-fix-run/get/:runId",
       UserMiddleware.getUserMiddleware,
       async (
         req: ExpressRequest,
@@ -94,47 +159,53 @@ export default class CodeFixRunAPI {
           const props: DatabaseCommonInteractionProps =
             await this.getAccessCheckedProps(req);
 
-          const body: JSONObject = (req.body as JSONObject) || {};
-
-          let limit: number = DEFAULT_LIMIT;
-
-          if (typeof body["limit"] === "number") {
-            limit = body["limit"];
-          }
-
-          limit = Math.min(Math.max(Math.floor(limit), 1), MAX_LIMIT);
-
-          let skip: number = 0;
+          const runIdString: string | undefined = req.params["runId"];
 
-          if (typeof body["skip"] === "number") {
-            skip = Math.max(Math.floor(body["skip"]), 0);
+          if (!runIdString) {
+            throw new BadDataException("runId is required.");
           }
 
-          const query: Query<AIRun> = {
-            projectId: props.tenantId!,
-            runType: AIRunType.CodeFix,
-          };
+          const runId: ObjectID = new ObjectID(runIdString);
 
-          // Root read after the tenant access check above.
-          const runs: Array<AIRun> = await AIRunService.findBy({
-            query: query,
+          /*
+           * Root read, but pinned to the caller's (access-checked) project —
+           * a run id from another project resolves to "not found".
+           */
+          const run: AIRun | null = await AIRunService.findOneBy({
+            query: {
+              _id: runId.toString(),
+              projectId: props.tenantId!,
+              runType: AIRunType.CodeFix,
+            },
             select: RUN_SELECT,
-            sort: { createdAt: SortOrder.Descending },
-            limit: limit,
-            skip: skip,
             props: { isRoot: true },
           });
 
-          const count: PositiveNumber = await AIRunService.countBy({
-            query: query,
+          if (!run) {
+            throw new BadDataException(
+              "Code fix run not found (or it does not belong to this project).",
+            );
+          }
+
+          const events: Array<AIRunEvent> = await AIRunEventService.findBy({
+            query: { aiRunId: run.id! },
+            select: {
+              _id: true,
+              sequence: true,
+              eventType: true,
+              toolName: true,
+              resultSummary: true,
+              createdAt: true,
+            },
+            sort: { sequence: SortOrder.Ascending },
+            limit: MAX_EVENTS,
+            skip: 0,
             props: { isRoot: true },
           });
 
           Response.sendJsonObjectResponse(req, res, {
-            runs: runs.map((run: AIRun): JSONObject => {
-              return runToJson(run);
-            }),
-            count: count.toNumber(),
+            run: runToJson(run),
+            events: BaseModel.toJSONArray(events, AIRunEvent),
           });
           return;
         } catch (err) {
@@ -144,9 +215,25 @@ export default class CodeFixRunAPI {
       },
     );
 
-    // One run + its ordered glass-box event trail.
+    /*
+     * The Logs page: the same run, its FULL event trail, and the per-call LLM
+     * metering — everything recorded about a run, for debugging one that went
+     * wrong.
+     *
+     * Two things are gated more tightly than the trail itself:
+     *
+     * - contentPayload (the verbatim prompts, model replies and tool output)
+     *   is returned only to ProjectOwner/ProjectAdmin. It embeds customer
+     *   source code, which is why the column's own read ACL is empty and why
+     *   LlmLog redacts the same content — this endpoint is the single
+     *   deliberate door to it, and it is not open to every project member.
+     *
+     * - LlmLog rows are read under the CALLER's permissions rather than as
+     *   root, so LlmLog's table ACL — not this endpoint's broader Project-read
+     *   gate — decides who sees the metering.
+     */
     this.router.post(
-      "/code-fix-run/get/:runId",
+      "/code-fix-run/logs/:runId",
       UserMiddleware.getUserMiddleware,
       async (
         req: ExpressRequest,
@@ -165,10 +252,6 @@ export default class CodeFixRunAPI {
 
           const runId: ObjectID = new ObjectID(runIdString);
 
-          /*
-           * Root read, but pinned to the caller's (access-checked) project —
-           * a run id from another project resolves to "not found".
-           */
           const run: AIRun | null = await AIRunService.findOneBy({
             query: {
               _id: runId.toString(),
@@ -185,25 +268,46 @@ export default class CodeFixRunAPI {
             );
           }
 
+          const canReadContent: boolean = this.callerCanReadRunContent(props);
+
           const events: Array<AIRunEvent> = await AIRunEventService.findBy({
             query: { aiRunId: run.id! },
-            select: {
-              _id: true,
-              sequence: true,
-              eventType: true,
-              toolName: true,
-              resultSummary: true,
-              createdAt: true,
-            },
+            select: LOG_EVENT_SELECT,
             sort: { sequence: SortOrder.Ascending },
             limit: MAX_EVENTS,
             skip: 0,
             props: { isRoot: true },
           });
 
+          const eventsJson: Array<JSONObject> = BaseModel.toJSONArray(
+            events,
+            AIRunEvent,
+          );
+
+          if (!canReadContent) {
+            for (const eventJson of eventsJson) {
+              delete eventJson["contentPayload"];
+            }
+          }
+
+          /*
+           * Under the caller's own permissions on purpose — see the note
+           * above. A caller without LlmLog read simply gets no metering rows.
+           */
+          const llmLogs: Array<LlmLog> = await LlmLogService.findBy({
+            query: { aiRunId: runId, projectId: props.tenantId! },
+            select: LLM_LOG_SELECT,
+            sort: { createdAt: SortOrder.Ascending },
+            limit: MAX_LLM_LOGS,
+            skip: 0,
+            props: props,
+          });
+
           Response.sendJsonObjectResponse(req, res, {
             run: runToJson(run),
-            events: BaseModel.toJSONArray(events, AIRunEvent),
+            events: eventsJson,
+            llmLogs: BaseModel.toJSONArray(llmLogs, LlmLog),
+            canReadContent: canReadContent,
           });
           return;
         } catch (err) {
@@ -214,6 +318,35 @@ export default class CodeFixRunAPI {
     );
   }
 
+  /*
+   * Whether the caller may see a run's verbatim LLM/tool content. Project
+   * owners and admins only: the content embeds customer source code, so the
+   * bar is higher than the Project-read gate that admits them to the page.
+   *
+   * Read through getUserPermissions(Allow) rather than off
+   * userTenantAccessPermission directly, because that array holds GRANTS AND
+   * DENIALS together, discriminated only by isBlockPermission. Mapping it raw
+   * counts a team's explicit "block ProjectAdmin" entry as a grant of
+   * ProjectAdmin — inverting the control, so the admin action that restricts a
+   * team would be what hands it the source code.
+   */
+  private callerCanReadRunContent(
+    props: DatabaseCommonInteractionProps,
+  ): boolean {
+    const permissions: Array<Permission> =
+      DatabaseCommonInteractionPropsUtil.getUserPermissions(
+        props,
+        PermissionType.Allow,
+      ).map((userPermission: UserPermission) => {
+        return userPermission.permission;
+      });
+
+    return (
+      permissions.includes(Permission.ProjectOwner) ||
+      permissions.includes(Permission.ProjectAdmin)
+    );
+  }
+
   /*
    * Requires a logged-in session and a tenant, then verifies project access
    * by reading the project under the USER's permissions (null when the user

package/Server/API/TelemetryExceptionAPI.ts

@@ -4,11 +4,11 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import TelemetryExceptionService, {
-  AIFixReadiness,
   DashboardServiceSummary,
   DashboardSummaryResult,
   Service as TelemetryExceptionServiceType,
 } from "../Services/TelemetryExceptionService";
+import { AIFixReadiness } from "../../Types/AI/AIFixReadiness";
 import AIRunService from "../Services/AIRunService";
 import UserMiddleware from "../Middleware/UserAuthorization";
 import Response from "../Utils/Response";
@@ -51,6 +51,11 @@ const CODE_FIX_STATUS_TEXT: {
     description:
       "The AI agent finished. Review the pull request it opened for the proposed fix.",
   },
+  [AIRunStatus.NoFixFound]: {
+    title: "No Fix Found",
+    description:
+      "The AI agent reviewed the code and did not find a fix to propose, so it opened no pull request.",
+  },
   [AIRunStatus.Error]: {
     title: "Error",
     description: "The AI agent could not complete the fix.",