@oneuptime/common 11.5.8 → 11.5.9

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,21 +8,27 @@ 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 BadDataException from "../../Types/Exception/BadDataException";
 import NotAuthorizedException from "../../Types/Exception/NotAuthorizedException";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 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 MAX_EVENTS: number = 500;
 
@@ -56,6 +62,7 @@ const RUN_SELECT: Select<AIRun> = {
   triggeredByTelemetryExceptionId: true,
   totalTokens: true,
   codeFixTaskType: true,
+  taskNumber: true,
   attemptCount: true,
   llmCallCount: true,
   toolCallCount: true,
@@ -67,6 +74,50 @@ const RUN_SELECT: Select<AIRun> = {
    */
 };
 
+/*
+ * 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
@@ -163,6 +214,137 @@ export default class CodeFixRunAPI {
         }
       },
     );
+
+    /*
+     * 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/logs/:runId",
+      UserMiddleware.getUserMiddleware,
+      async (
+        req: ExpressRequest,
+        res: ExpressResponse,
+        next: NextFunction,
+      ): Promise<void> => {
+        try {
+          const props: DatabaseCommonInteractionProps =
+            await this.getAccessCheckedProps(req);
+
+          const runIdString: string | undefined = req.params["runId"];
+
+          if (!runIdString) {
+            throw new BadDataException("runId is required.");
+          }
+
+          const runId: ObjectID = new ObjectID(runIdString);
+
+          const run: AIRun | null = await AIRunService.findOneBy({
+            query: {
+              _id: runId.toString(),
+              projectId: props.tenantId!,
+              runType: AIRunType.CodeFix,
+            },
+            select: RUN_SELECT,
+            props: { isRoot: true },
+          });
+
+          if (!run) {
+            throw new BadDataException(
+              "Code fix run not found (or it does not belong to this project).",
+            );
+          }
+
+          const canReadContent: boolean = this.callerCanReadRunContent(props);
+
+          const events: Array<AIRunEvent> = await AIRunEventService.findBy({
+            query: { aiRunId: run.id! },
+            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: eventsJson,
+            llmLogs: BaseModel.toJSONArray(llmLogs, LlmLog),
+            canReadContent: canReadContent,
+          });
+          return;
+        } catch (err) {
+          next(err);
+          return;
+        }
+      },
+    );
+  }
+
+  /*
+   * 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)
+    );
   }
 
   /*

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.",

package/Server/Infrastructure/Postgres/SchemaMigrations/1784124919694-AddAITaskNumberAndRunTranscript.ts

@@ -0,0 +1,95 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Two additions, both in service of debugging a code-fix run that went wrong.
+ *
+ * 1. AIRun.taskNumber + Project.aiRunCounter — the per-project "#42" handle,
+ *    allocated exactly like Incident.incidentNumber (ProjectService holds the
+ *    counter behind a Redis semaphore; see incrementAndGetAIRunCounter).
+ * 2. AIRunEvent.contentPayload — the verbatim prompt/response/tool transcript.
+ *
+ * The DDL here was produced by `npm run generate-postgres-migration`. Two
+ * unrelated OnCallDutyPolicyScheduleLayer default changes the generator also
+ * emitted (pre-existing whitespace drift between the entity defaults and the
+ * local schema) were dropped: they are not part of this change.
+ *
+ * The backfill rides along in the same migration rather than a follow-up so
+ * there is no window in which existing tasks are on-screen with a blank
+ * number.
+ */
+export class AddAITaskNumberAndRunTranscript1784124919694
+  implements MigrationInterface
+{
+  public name: string = "AddAITaskNumberAndRunTranscript1784124919694";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Project" ADD "aiRunCounter" integer NOT NULL DEFAULT '0'`,
+    );
+    await queryRunner.query(`ALTER TABLE "AIRun" ADD "taskNumber" integer`);
+    await queryRunner.query(
+      `ALTER TABLE "AIRunEvent" ADD "contentPayload" jsonb`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_ede30aa8b14a167586bd555fa9" ON "AIRun" ("taskNumber") `,
+    );
+
+    /*
+     * Number the tasks that already exist, oldest first, per project — so the
+     * list does not read "#1, -, -, #2" the day this ships. Scoped to
+     * runType = 'CodeFix' because only code-fix runs are tasks; chat and
+     * investigation runs share this table and must stay null.
+     *
+     * Soft-deleted rows are numbered too. Not to prevent reuse (a skipped row
+     * would hold no number to reuse) but to keep the sequence a stable
+     * function of creation order: a run that is soft-deleted later must not
+     * renumber the runs after it, and an undeleted row must not collide with
+     * a number already handed out. The cost is gaps in what the list shows,
+     * which is the same thing incidents do.
+     */
+    await queryRunner.query(`
+      WITH numbered AS (
+        SELECT
+          "_id",
+          ROW_NUMBER() OVER (
+            PARTITION BY "projectId"
+            ORDER BY "createdAt" ASC, "_id" ASC
+          ) AS "rowNumber"
+        FROM "AIRun"
+        WHERE "runType" = 'CodeFix'
+      )
+      UPDATE "AIRun"
+      SET "taskNumber" = numbered."rowNumber"
+      FROM numbered
+      WHERE "AIRun"."_id" = numbered."_id"
+    `);
+
+    /*
+     * Advance each project's counter past what the backfill just handed out,
+     * so the next allocation continues the sequence instead of restarting at
+     * #1 and colliding. Projects with no code-fix runs keep the 0 default.
+     */
+    await queryRunner.query(`
+      UPDATE "Project"
+      SET "aiRunCounter" = "maxPerProject"."maxTaskNumber"
+      FROM (
+        SELECT "projectId", MAX("taskNumber") AS "maxTaskNumber"
+        FROM "AIRun"
+        WHERE "runType" = 'CodeFix' AND "taskNumber" IS NOT NULL
+        GROUP BY "projectId"
+      ) AS "maxPerProject"
+      WHERE "Project"."_id" = "maxPerProject"."projectId"
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_ede30aa8b14a167586bd555fa9"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIRunEvent" DROP COLUMN "contentPayload"`,
+    );
+    await queryRunner.query(`ALTER TABLE "AIRun" DROP COLUMN "taskNumber"`);
+    await queryRunner.query(`ALTER TABLE "Project" DROP COLUMN "aiRunCounter"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1784135099754-AllowNullAiAgentOnPullRequest.ts

@@ -0,0 +1,52 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * A pull request can now be proposed from an AI chat conversation, which has
+ * no AIAgent behind it (the AIAgent record belongs to the autonomous fix
+ * worker). aiAgentId becomes nullable so chat-authored PRs can be recorded at
+ * all — and recording them is what makes them count against the per-repository
+ * open-PR cap, which reads AIAgentTaskPullRequest rows.
+ *
+ * A null aiAgentId therefore means "proposed from chat". Existing rows all
+ * have an agent, so dropping NOT NULL needs no backfill and the down migration
+ * is safe until the first chat-authored PR exists.
+ */
+export class AllowNullAiAgentOnPullRequest1784135099754
+  implements MigrationInterface
+{
+  public name = "AllowNullAiAgentOnPullRequest1784135099754";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    /*
+     * The FK is dropped and re-added because Postgres will not alter a column's
+     * nullability while a foreign key references it. ON DELETE CASCADE is
+     * preserved exactly as it was.
+     */
+    await queryRunner.query(
+      `ALTER TABLE "AIAgentTaskPullRequest" DROP CONSTRAINT "FK_b1e01ecfe9eecfb555428471073"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIAgentTaskPullRequest" ALTER COLUMN "aiAgentId" DROP NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIAgentTaskPullRequest" ADD CONSTRAINT "FK_b1e01ecfe9eecfb555428471073" FOREIGN KEY ("aiAgentId") REFERENCES "AIAgent"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    /*
+     * Restoring NOT NULL fails if any chat-authored (null-agent) rows exist.
+     * That is deliberate: silently deleting or reassigning a customer's pull
+     * request records to satisfy a rollback would be worse than a loud failure.
+     */
+    await queryRunner.query(
+      `ALTER TABLE "AIAgentTaskPullRequest" DROP CONSTRAINT "FK_b1e01ecfe9eecfb555428471073"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIAgentTaskPullRequest" ALTER COLUMN "aiAgentId" SET NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIAgentTaskPullRequest" ADD CONSTRAINT "FK_b1e01ecfe9eecfb555428471073" FOREIGN KEY ("aiAgentId") REFERENCES "AIAgent"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1784137457184-AddEnableMcpServerToStatusPage.ts

@@ -0,0 +1,30 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Status page owners can now stop AI agents from reading their status page over
+ * the public OneUptime MCP server. MCP access stays on unless it is turned off,
+ * so the column defaults to true.
+ *
+ * ADD COLUMN ... NOT NULL DEFAULT true populates every existing row with true in
+ * the same statement, so no backfill is needed and existing status pages keep
+ * working exactly as they do today. That is what makes the
+ * `enableMcpServer: true` predicate in StatusPageService.isMcpServerEnabled
+ * safe — there are no NULL rows for it to silently drop.
+ */
+export class AddEnableMcpServerToStatusPage1784137457184
+  implements MigrationInterface
+{
+  public name = "AddEnableMcpServerToStatusPage1784137457184";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" ADD "enableMcpServer" boolean NOT NULL DEFAULT true`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" DROP COLUMN "enableMcpServer"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1784200000000-AddSnmpV3ColumnsToNetworkDeviceDiscoveryScan.ts

@@ -0,0 +1,49 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddSnmpV3ColumnsToNetworkDeviceDiscoveryScan1784200000000
+  implements MigrationInterface
+{
+  public name = "AddSnmpV3ColumnsToNetworkDeviceDiscoveryScan1784200000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "snmpV3SecurityLevel" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "snmpV3Username" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "snmpV3AuthProtocol" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "snmpV3AuthKey" text`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "snmpV3PrivProtocol" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "snmpV3PrivKey" text`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "snmpV3PrivKey"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "snmpV3PrivProtocol"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "snmpV3AuthKey"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "snmpV3AuthProtocol"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "snmpV3Username"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "snmpV3SecurityLevel"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -451,6 +451,10 @@ import { RenameSentinelToAI1784030612266 } from "./1784030612266-RenameSentinelT
 import { MigrationName1784033837629 } from "./1784033837629-MigrationName";
 import { AddCreatedByUserToUser1784048917994 } from "./1784048917994-AddCreatedByUserToUser";
 import { BackfillCodeFixTaskType1784105912819 } from "./1784105912819-BackfillCodeFixTaskType";
+import { AddAITaskNumberAndRunTranscript1784124919694 } from "./1784124919694-AddAITaskNumberAndRunTranscript";
+import { AllowNullAiAgentOnPullRequest1784135099754 } from "./1784135099754-AllowNullAiAgentOnPullRequest";
+import { AddEnableMcpServerToStatusPage1784137457184 } from "./1784137457184-AddEnableMcpServerToStatusPage";
+import { AddSnmpV3ColumnsToNetworkDeviceDiscoveryScan1784200000000 } from "./1784200000000-AddSnmpV3ColumnsToNetworkDeviceDiscoveryScan";
 
 export default [
   InitialMigration,
@@ -906,4 +910,8 @@ export default [
   MigrationName1784033837629,
   AddCreatedByUserToUser1784048917994,
   BackfillCodeFixTaskType1784105912819,
+  AddAITaskNumberAndRunTranscript1784124919694,
+  AllowNullAiAgentOnPullRequest1784135099754,
+  AddEnableMcpServerToStatusPage1784137457184,
+  AddSnmpV3ColumnsToNetworkDeviceDiscoveryScan1784200000000,
 ];

package/Server/Services/AIRunEventService.ts

@@ -2,13 +2,17 @@ import PositiveNumber from "../../Types/PositiveNumber";
 import ObjectID from "../../Types/ObjectID";
 import { JSONObject } from "../../Types/JSON";
 import AIRunEventType from "../../Types/AI/AIRunEventType";
-import { AIRunEventResultSummary } from "../../Types/AI/AIChatTypes";
+import {
+  AIRunEventContentPayload,
+  AIRunEventResultSummary,
+} from "../../Types/AI/AIChatTypes";
 import CountBy from "../Types/Database/CountBy";
 import FindBy from "../Types/Database/FindBy";
 import { OnFind } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/AIRunEvent";
 import { pinQueryToRequestingUser } from "../Utils/AI/AIChatPrivacyFilter";
+import AIRunTranscript from "../Utils/AI/AIRunTranscript";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger from "../Utils/Logger";
 
@@ -36,6 +40,7 @@ export class Service extends DatabaseService<Model> {
     toolArguments?: JSONObject | undefined;
     resultSummary?: AIRunEventResultSummary | undefined;
     citationId?: string | undefined;
+    contentPayload?: AIRunEventContentPayload | undefined;
   }): Promise<void> {
     try {
       const sequence: number = (
@@ -63,6 +68,15 @@ export class Service extends DatabaseService<Model> {
       if (data.citationId) {
         event.citationId = data.citationId;
       }
+      /*
+       * Capped here rather than at the call sites, so no caller can write an
+       * unbounded transcript row by forgetting to clamp.
+       */
+      if (data.contentPayload) {
+        event.contentPayload = AIRunTranscript.clampPayload(
+          data.contentPayload,
+        );
+      }
 
       await this.create({
         data: event,