@oneuptime/common 11.5.8 → 11.5.10

package/Server/Services/TelemetryExceptionService.ts

@@ -13,20 +13,18 @@ import CodeFixTaskType, {
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import AIRunService from "./AIRunService";
 import FixRunBudget from "../Utils/AI/CodeFix/FixRunBudget";
-import AIAgentService from "./AIAgentService";
-import LlmProviderService from "./LlmProviderService";
-import ProjectService from "./ProjectService";
+import CodeFixReadiness from "../Utils/AI/CodeFix/CodeFixReadiness";
 import ServiceService from "./ServiceService";
 import CodeRepositoryService from "./CodeRepositoryService";
 import { RepoResolution } from "../Utils/CodeRepository/StackTraceRepoResolver";
-import AIAgent from "../../Models/DatabaseModels/AIAgent";
-import LlmProvider from "../../Models/DatabaseModels/LlmProvider";
-import Project from "../../Models/DatabaseModels/Project";
+import {
+  AIFixReadiness,
+  AIFixReadinessCheck,
+} from "../../Types/AI/AIFixReadiness";
 import TelemetryService from "../../Models/DatabaseModels/Service";
 import QueryHelper from "../Types/Database/QueryHelper";
 import ModelPermission from "../Types/Database/Permissions/Index";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
-import { IsBillingEnabled } from "../EnvironmentConfig";
 import Query from "../Types/Database/Query";
 import Includes from "../../Types/BaseDatabase/Includes";
 import logger from "../Utils/Logger";
@@ -46,24 +44,6 @@ export interface CreateCodeFixRunForExceptionParams {
   taskType?: CodeFixTaskType | undefined;
 }
 
-export type AIFixReadinessCheckId =
-  | "llmProvider"
-  | "repositoryResolved"
-  | "agentAvailable";
-
-export interface AIFixReadinessCheck {
-  id: AIFixReadinessCheckId;
-  ok: boolean;
-  title: string;
-  // Shown to the user when ok is false — says exactly what to do next.
-  detail: string;
-}
-
-export interface AIFixReadiness {
-  ready: boolean;
-  checks: Array<AIFixReadinessCheck>;
-}
-
 export interface DashboardServiceSummary {
   /*
    * Polymorphic: a real Service, a Host/DockerHost/KubernetesCluster id, or
@@ -124,55 +104,16 @@ export class Service extends DatabaseService<Model> {
     const projectId: ObjectID = telemetryException.projectId;
 
     /*
-     * 1. An LLM provider the agent may use. Agent completions are
-     * server-mediated and metered (B4 Tier 0), so the shared global
-     * provider is a valid fallback on cloud too — a project-owned provider
-     * simply wins when one exists.
-     */
-    const llmProvider: LlmProvider | null =
-      await LlmProviderService.getLlmProviderForMeteredAgentPath(projectId);
-
-    let llmOk: boolean = Boolean(llmProvider);
-    let llmDetail: string = llmOk
-      ? ""
-      : "AI fix tasks need an LLM provider. Add one in Project Settings > AI > LLM Providers. Self-hosted instances can alternatively set the GLOBAL_LLM_PROVIDER_* environment variables to register a global provider for every project.";
-
-    /*
-     * A resolved provider must also be PAYABLE, or the run passes readiness
-     * here and dies at its first completion call instead. Mirrors the
-     * billing gate in AIService.executeWithLogging: only a COSTED global
-     * provider on cloud bills the project's AI balance per call —
-     * project-owned and free-global providers consume no balance and must
-     * not require one.
+     * 1. An LLM provider the agent may use — the same gate the project-wide
+     * AI Tasks page renders, so the two surfaces can never disagree about
+     * whether this project has a usable provider.
      */
-    const billingEnabled: boolean = params.billingEnabled ?? IsBillingEnabled;
-
-    if (
-      llmProvider &&
-      billingEnabled &&
-      (llmProvider.isGlobalLlm || false) &&
-      (llmProvider.costPerMillionTokensInUSDCents || 0) > 0
-    ) {
-      const project: Project | null = await ProjectService.findOneById({
-        id: projectId,
-        select: { aiCurrentBalanceInUSDCents: true },
-        props: { isRoot: true },
+    const llmCheck: AIFixReadinessCheck =
+      await CodeFixReadiness.getLlmProviderCheck({
+        projectId,
+        billingEnabled: params.billingEnabled,
       });
 
-      if (!project || (project.aiCurrentBalanceInUSDCents || 0) <= 0) {
-        llmOk = false;
-        llmDetail =
-          "AI fix tasks would use the OneUptime-hosted LLM provider, which is billed against your AI balance — and the project's balance is empty. Recharge it in Project Settings > AI Credits, or add your own LLM provider in Project Settings > AI > LLM Providers.";
-      }
-    }
-
-    const llmCheck: AIFixReadinessCheck = {
-      id: "llmProvider",
-      ok: llmOk,
-      title: "LLM provider",
-      detail: llmDetail,
-    };
-
     /*
      * 2. A repository must RESOLVE for this exception — computed at runtime
      * from the stack trace (path matching over connected repos), falling
@@ -223,25 +164,11 @@ export class Service extends DatabaseService<Model> {
       };
     }
 
-    // 4. An agent must be alive to pick the task up.
-    const anyAgent: AIAgent | null =
-      await AIAgentService.getAIAgentForProject(projectId);
-    const connectedAgent: AIAgent | null = anyAgent
-      ? AIAgentService.isAgentAlive(anyAgent)
-        ? anyAgent
-        : null
-      : null;
-
-    const agentCheck: AIFixReadinessCheck = {
-      id: "agentAvailable",
-      ok: Boolean(connectedAgent),
-      title: "AI agent online",
-      detail: connectedAgent
-        ? ""
-        : anyAgent
-          ? `The AI agent "${anyAgent.name || "agent"}" has not reported in — check that its container is running.`
-          : "No AI agent is available for this project. Self-hosted: create an agent under Settings > AI > AI Agents and run its container. Cloud: the shared fleet appears here automatically once enabled.",
-    };
+    // 3. An agent must be alive to pick the task up.
+    const agentCheck: AIFixReadinessCheck =
+      await CodeFixReadiness.getAgentCheck({
+        projectId,
+      });
 
     const checks: Array<AIFixReadinessCheck> = [
       llmCheck,
@@ -387,8 +314,10 @@ export class Service extends DatabaseService<Model> {
           taskType === CodeFixTaskType.FixException
             ? QueryHelper.equalToOrNull(CodeFixTaskType.FixException)
             : taskType,
+        // Every terminal status — see AIRunStatusHelper.isTerminalStatus.
         status: QueryHelper.notIn([
           AIRunStatus.Completed,
+          AIRunStatus.NoFixFound,
           AIRunStatus.Error,
           AIRunStatus.Cancelled,
           AIRunStatus.Stale,

package/Server/Services/UserService.ts

@@ -4,8 +4,10 @@ import {
   NotificationSlackWebhookOnCreateUser,
 } from "../EnvironmentConfig";
 import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
 import UpdateBy from "../Types/Database/UpdateBy";
 import DeleteBy from "../Types/Database/DeleteBy";
+import Attribution from "../Utils/Attribution";
 import logger, { LogAttributes } from "../Utils/Logger";
 import DatabaseService from "./DatabaseService";
 import EmailVerificationTokenService from "./EmailVerificationTokenService";
@@ -25,12 +27,14 @@ import OneUptimeDate from "../../Types/Date";
 import Email from "../../Types/Email";
 import EmailTemplateType from "../../Types/Email/EmailTemplateType";
 import HashedString from "../../Types/HashedString";
+import { JSONObject, JSONValue } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
 import Text from "../../Types/Text";
 import EmailVerificationToken from "../../Models/DatabaseModels/EmailVerificationToken";
 import TeamMember from "../../Models/DatabaseModels/TeamMember";
 import Model from "../../Models/DatabaseModels/User";
 import SlackUtil from "../Utils/Workspace/Slack/Slack";
+import ProductAnalytics from "../Utils/ProductAnalytics";
 import UserTotpAuth from "../../Models/DatabaseModels/UserTotpAuth";
 import UserTotpAuthService from "./UserTotpAuthService";
 import UserWebAuthn from "../../Models/DatabaseModels/UserWebAuthn";
@@ -120,6 +124,38 @@ export class Service extends DatabaseService<Model> {
     );
   }
 
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    /*
+     * clickIds / firstTouchAttribution are publicly creatable jsonb columns
+     * (set during signup). Unlike the varchar(500) utm columns they have no
+     * DB-level size bound, so whitelist keys and cap value lengths here.
+     */
+    const sanitizedClickIds: JSONObject | undefined =
+      Attribution.sanitizeClickIds(createBy.data.clickIds as JSONValue);
+
+    if (sanitizedClickIds) {
+      createBy.data.clickIds = sanitizedClickIds;
+    } else {
+      delete createBy.data.clickIds;
+    }
+
+    const sanitizedFirstTouchAttribution: JSONObject | undefined =
+      Attribution.sanitizeFirstTouchAttribution(
+        createBy.data.firstTouchAttribution as JSONValue,
+      );
+
+    if (sanitizedFirstTouchAttribution) {
+      createBy.data.firstTouchAttribution = sanitizedFirstTouchAttribution;
+    } else {
+      delete createBy.data.firstTouchAttribution;
+    }
+
+    return { createBy, carryForward: null };
+  }
+
   @CaptureSpan()
   protected override async onCreateSuccess(
     _onCreate: OnCreate<Model>,
@@ -141,6 +177,29 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
+    /*
+     * Server-side signup event (ad blockers eat the client-side one). Also
+     * fires for users created via team invites — has_password separates
+     * direct signups (true) from invited users (false).
+     */
+    if (createdItem.email) {
+      ProductAnalytics.capture({
+        event: "server/user_created",
+        distinctId: createdItem.email.toString(),
+        properties: {
+          has_password: Boolean(createdItem.password),
+          utm_source: createdItem.utmSource || "",
+          utm_medium: createdItem.utmMedium || "",
+          utm_campaign: createdItem.utmCampaign || "",
+          utm_term: createdItem.utmTerm || "",
+          utm_content: createdItem.utmContent || "",
+          utm_url: createdItem.utmUrl || "",
+          click_ids: createdItem.clickIds || {},
+          first_touch: createdItem.firstTouchAttribution || {},
+        },
+      });
+    }
+
     // A place holder method used for overriding.
     return Promise.resolve(createdItem);
   }

package/Server/Types/AnalyticsDatabase/AggregateBy.ts

@@ -38,19 +38,50 @@ export class AggregateUtil {
     return interval === AggregationInterval.Total;
   }
 
+  /**
+   * The single source of truth for "which ClickHouse expression buckets
+   * a timestamp at this interval". Every aggregate SQL builder (raw
+   * table, minute MV, per-host MV, span projections) must go through
+   * this instead of lowercasing the enum value into the statement:
+   * the calendar units happen to double as SQL unit names
+   * (`date_trunc('hour', ...)`), but the sub-hour tiers
+   * (FiveMinutes/...) are not valid units and compile to
+   * `toStartOfInterval(col, INTERVAL 5 MINUTE)` instead — which
+   * ClickHouse counts in whole intervals since the epoch, so the
+   * 5/15/30-minute grids are exact on the client's epoch-ms grid too.
+   *
+   * `timestampExpression` is a model-validated identifier or a builder-
+   * owned expression, so raw interpolation here is consistent with the
+   * surrounding builders. `Total` has no bucket expression (the window
+   * collapses into `min(col)` — see buildBucketTimestampSelect).
+   */
+  public static buildBucketTimestampExpression(
+    resolvedInterval: AggregationInterval,
+    timestampExpression: string,
+  ): string {
+    switch (resolvedInterval) {
+      case AggregationInterval.FiveMinutes:
+        return `toStartOfInterval(${timestampExpression}, INTERVAL 5 MINUTE)`;
+      case AggregationInterval.FifteenMinutes:
+        return `toStartOfInterval(${timestampExpression}, INTERVAL 15 MINUTE)`;
+      case AggregationInterval.ThirtyMinutes:
+        return `toStartOfInterval(${timestampExpression}, INTERVAL 30 MINUTE)`;
+      default: {
+        const interval: string = resolvedInterval.toLowerCase();
+        return `date_trunc('${interval}', toStartOfInterval(${timestampExpression}, INTERVAL 1 ${interval}))`;
+      }
+    }
+  }
+
   /**
    * The SELECT fragment that produces the bucket timestamp column,
    * already aliased to `timestampColumn`. Shared by every aggregate SQL
    * builder so the `Total` (whole-window) shape stays identical across
    * paths:
    *
-   *   - normal interval → `date_trunc('<i>', toStartOfInterval(col, INTERVAL 1 <i>)) as col`
+   *   - normal interval → buildBucketTimestampExpression(...) `as col`
    *   - Total           → `min(col) as col` (one row per group; the
    *     earliest sample timestamp in the window is the bucket label)
-   *
-   * `timestampColumn` is a model-validated identifier (see
-   * AnalyticsDatabaseService._aggregateBy), so raw interpolation here is
-   * consistent with the surrounding builders.
    */
   public static buildBucketTimestampSelect(
     resolvedInterval: AggregationInterval,
@@ -60,7 +91,6 @@ export class AggregateUtil {
       return `min(${timestampColumn}) as ${timestampColumn}`;
     }
 
-    const interval: string = resolvedInterval.toLowerCase();
-    return `date_trunc('${interval}', toStartOfInterval(${timestampColumn}, INTERVAL 1 ${interval})) as ${timestampColumn}`;
+    return `${AggregateUtil.buildBucketTimestampExpression(resolvedInterval, timestampColumn)} as ${timestampColumn}`;
   }
 }

package/Server/Types/Markdown.ts

@@ -1,5 +1,6 @@
 import { Renderer, marked } from "marked";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import markdownSlugify from "./MarkdownSlugify";
 
 export type MarkdownRenderer = Renderer;
 
@@ -235,15 +236,14 @@ export default class Markdown {
     return renderer;
   }
 
-  private static slugify(text: string): string {
-    return text
-      .toLowerCase()
-      .replace(/<[^>]*>/g, "")
-      .replace(/&[^;]+;/g, "")
-      .replace(/[^\w\s-]/g, "")
-      .replace(/\s+/g, "-")
-      .replace(/-+/g, "-")
-      .replace(/^-|-$/g, "");
+  /*
+   * Heading text -> the `id` used for in-page anchors. The rules live in
+   * MarkdownSlugify.ts, a dependency-free module, so the docs anchor scripts
+   * (Scripts/Docs/CheckAnchors.ts, FixAnchors.ts) can share them without
+   * pulling in marked or the telemetry stack — see the comment there.
+   */
+  public static slugify(text: string): string {
+    return markdownSlugify(text);
   }
 
   private static getDocsRenderer(): Renderer {

package/Server/Types/MarkdownSlugify.ts

@@ -0,0 +1,47 @@
+/*
+ * Heading text -> the `id` used for in-page anchors.
+ *
+ * This is the single source of truth for anchor ids. The docs renderer
+ * (Common/Server/Types/Markdown.ts) exposes it as Markdown.slugify, and the
+ * docs anchor scripts (Scripts/Docs/CheckAnchors.ts, Scripts/Docs/FixAnchors.ts)
+ * import it directly; a second copy of these rules would drift and then pass a
+ * link the renderer serves as a 404.
+ *
+ * It lives in its own module with ZERO imports on purpose: Markdown.ts pulls in
+ * marked and the telemetry stack, which only resolve inside a fully installed
+ * package. The scripts run in CI with nothing but the root npm install, so they
+ * must be able to load the slugify rules without any of that.
+ *
+ * The character class keeps letters and numbers in ANY script, via \p{L} and
+ * \p{N} with the /u flag. It used to be `\w`, which is ASCII-only — so every
+ * Cyrillic, CJK and Devanagari heading was stripped to nothing and rendered
+ * as id="", breaking every anchor in those locales. Accented Latin lost the
+ * accented letter alone ("gravité" -> "gravit").
+ *
+ * \p{M} (combining marks) is required alongside \p{L}: Devanagari matras and
+ * Arabic/Thai vowel signs are marks, not letters, so without it Hindi headings
+ * come out mangled rather than merely transliterated ("लॉग" -> "लग"). It also
+ * covers decomposed (NFD) Latin, where "é" is "e" + a combining accent.
+ *
+ * Variation selectors are dropped first. They are marks too, so \p{M} would
+ * otherwise keep them — and an emoji heading like "⚠️ Important" carries an
+ * invisible U+FE0F that would survive its emoji and lead the id.
+ *
+ * `_` is listed explicitly because \p{L}/\p{N} do not cover it but the old
+ * `\w` did, and real headings depend on it — e.g. "`ceph_health_status` is 1
+ * but no incident fires". Dropping it would silently renumber existing
+ * English anchors and break inbound deep links.
+ */
+const slugify: (text: string) => string = (text: string): string => {
+  return text
+    .toLowerCase()
+    .replace(/<[^>]*>/g, "")
+    .replace(/&[^;]+;/g, "")
+    .replace(/[\uFE00-\uFE0F\u{E0100}-\u{E01EF}]/gu, "")
+    .replace(/[^\p{L}\p{N}\p{M}_\s-]/gu, "")
+    .replace(/\s+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+};
+
+export default slugify;

package/Server/Utils/AI/AIRunTranscript.ts

@@ -0,0 +1,240 @@
+import { AIRunEventContentPayload } from "../../../Types/AI/AIChatTypes";
+import { JSONObject } from "../../../Types/JSON";
+
+/*
+ * Write-time caps for AIRunEvent.contentPayload — the run transcript.
+ *
+ * The transcript exists to debug a bad run, so it stores content verbatim
+ * rather than summarized. That makes bounding it a storage requirement, not a
+ * nicety: a code-fix agent may read large files and run test suites that emit
+ * megabytes, and it does so up to 40 times per run.
+ *
+ * Only NEW messages are recorded per call (never the whole replayed history),
+ * so a run's transcript grows linearly with its turns rather than
+ * quadratically. These caps then bound each turn.
+ */
+export const MAX_MESSAGE_CONTENT_CHARS: number = 20000;
+export const MAX_RESPONSE_CONTENT_CHARS: number = 20000;
+export const MAX_TOOL_RESULT_CHARS: number = 20000;
+export const MAX_TOOL_ARGUMENT_CHARS: number = 10000;
+// Belt and braces: a hard ceiling on the serialized payload.
+export const MAX_PAYLOAD_CHARS: number = 200000;
+
+const TRUNCATION_SUFFIX: string = "\n… [truncated]";
+
+export default class AIRunTranscript {
+  /*
+   * Clip one string to a cap. Returns the value and whether it was clipped,
+   * so the payload can honestly report truncation to the reader rather than
+   * silently presenting a partial prompt as complete.
+   */
+  public static clip(
+    value: string | undefined,
+    maxChars: number,
+  ): { value: string | undefined; isTruncated: boolean } {
+    if (value === undefined || value === null) {
+      return { value: undefined, isTruncated: false };
+    }
+
+    if (value.length <= maxChars) {
+      return { value, isTruncated: false };
+    }
+
+    return {
+      value: value.substring(0, maxChars) + TRUNCATION_SUFFIX,
+      isTruncated: true,
+    };
+  }
+
+  /*
+   * Clip tool arguments by serializing them, so a single huge argument (a
+   * write_file `content`, say) cannot blow the row up. Unparseable or
+   * oversized arguments degrade to a marker object rather than being dropped
+   * — knowing a tool was called with arguments too big to store is itself a
+   * useful debugging signal.
+   */
+  public static clipArguments(args: JSONObject | undefined): {
+    value: JSONObject | undefined;
+    isTruncated: boolean;
+  } {
+    if (!args) {
+      return { value: undefined, isTruncated: false };
+    }
+
+    let serialized: string = "";
+
+    try {
+      serialized = JSON.stringify(args);
+    } catch {
+      return {
+        value: { _note: "Arguments could not be serialized." },
+        isTruncated: true,
+      };
+    }
+
+    if (serialized.length <= MAX_TOOL_ARGUMENT_CHARS) {
+      return { value: args, isTruncated: false };
+    }
+
+    return {
+      value: {
+        _note: `Arguments omitted — ${serialized.length} characters exceeds the ${MAX_TOOL_ARGUMENT_CHARS} character cap.`,
+        _preview: serialized.substring(0, 2000),
+      },
+      isTruncated: true,
+    };
+  }
+
+  /*
+   * Apply every cap to a payload and stamp isTruncated if anything was
+   * clipped. The final MAX_PAYLOAD_CHARS check is a backstop for a payload
+   * that is under the per-field caps but still large in aggregate (many
+   * messages); it drops the request messages first, since the response and
+   * tool result are the more valuable half when debugging.
+   */
+  public static clampPayload(
+    payload: AIRunEventContentPayload,
+  ): AIRunEventContentPayload {
+    let isTruncated: boolean = payload.isTruncated === true;
+
+    const clamped: AIRunEventContentPayload = { ...payload };
+
+    if (payload.requestMessages) {
+      clamped.requestMessages = payload.requestMessages.map(
+        (message: { role: string; content: string }) => {
+          const clipped: { value: string | undefined; isTruncated: boolean } =
+            this.clip(message.content, MAX_MESSAGE_CONTENT_CHARS);
+
+          if (clipped.isTruncated) {
+            isTruncated = true;
+          }
+
+          return { role: message.role, content: clipped.value || "" };
+        },
+      );
+    }
+
+    if (payload.responseContent !== undefined) {
+      const clipped: { value: string | undefined; isTruncated: boolean } =
+        this.clip(payload.responseContent, MAX_RESPONSE_CONTENT_CHARS);
+      clamped.responseContent = clipped.value;
+      isTruncated = isTruncated || clipped.isTruncated;
+    }
+
+    if (payload.toolResult !== undefined) {
+      const clipped: { value: string | undefined; isTruncated: boolean } =
+        this.clip(payload.toolResult, MAX_TOOL_RESULT_CHARS);
+      clamped.toolResult = clipped.value;
+      isTruncated = isTruncated || clipped.isTruncated;
+    }
+
+    if (payload.responseToolCalls) {
+      clamped.responseToolCalls = payload.responseToolCalls.map(
+        (toolCall: {
+          id?: string | undefined;
+          name: string;
+          arguments?: JSONObject | undefined;
+        }) => {
+          const clipped: {
+            value: JSONObject | undefined;
+            isTruncated: boolean;
+          } = this.clipArguments(toolCall.arguments);
+
+          if (clipped.isTruncated) {
+            isTruncated = true;
+          }
+
+          return {
+            ...(toolCall.id ? { id: toolCall.id } : {}),
+            name: toolCall.name,
+            ...(clipped.value ? { arguments: clipped.value } : {}),
+          };
+        },
+      );
+    }
+
+    /*
+     * Sacrifice whole fields, largest-payoff first, RE-CHECKING after each —
+     * a single pass that drops only requestMessages cannot bound a payload
+     * whose bulk is elsewhere. A model that emits 30 write_file calls puts
+     * ~10k of arguments each into responseToolCalls, blowing the ceiling while
+     * the pass "succeeds" by deleting a two-character user message.
+     *
+     * Order is by debugging value, cheapest to lose first: the replayed
+     * request messages, then the tool arguments (their paths survive in the
+     * message), then the tool output. Each step reports what it dropped rather
+     * than leaving the reader to wonder.
+     */
+    const sacrifices: Array<() => void> = [
+      () => {
+        const messageCount: number = clamped.requestMessages?.length || 0;
+        clamped.requestMessages = [
+          {
+            role: "system",
+            content: `[${messageCount} request message(s) omitted — this step's transcript exceeded the ${MAX_PAYLOAD_CHARS} character cap.]`,
+          },
+        ];
+      },
+      () => {
+        if (!clamped.responseToolCalls) {
+          return;
+        }
+
+        clamped.responseToolCalls = clamped.responseToolCalls.map(
+          (toolCall: {
+            id?: string | undefined;
+            name: string;
+            arguments?: JSONObject | undefined;
+          }) => {
+            return {
+              ...(toolCall.id ? { id: toolCall.id } : {}),
+              name: toolCall.name,
+              arguments: {
+                _note: `Arguments omitted — this step's transcript exceeded the ${MAX_PAYLOAD_CHARS} character cap.`,
+              },
+            };
+          },
+        );
+      },
+      () => {
+        clamped.toolResult = `[Tool output omitted — this step's transcript exceeded the ${MAX_PAYLOAD_CHARS} character cap.]`;
+      },
+      () => {
+        clamped.responseContent = `[Model response omitted — this step's transcript exceeded the ${MAX_PAYLOAD_CHARS} character cap.]`;
+      },
+      /*
+       * Last resort: responseToolCalls has no bounded LENGTH, only bounded
+       * entries, so a response with enough calls stays over cap even with every
+       * argument already dropped. Collapse it to a count.
+       */
+      () => {
+        const toolCallCount: number = clamped.responseToolCalls?.length || 0;
+        delete clamped.responseToolCalls;
+        clamped.responseContent = `[${toolCallCount} tool call(s) and this step's content omitted — the transcript exceeded the ${MAX_PAYLOAD_CHARS} character cap.]`;
+      },
+    ];
+
+    for (const sacrifice of sacrifices) {
+      if (this.serializedLength(clamped) <= MAX_PAYLOAD_CHARS) {
+        break;
+      }
+
+      sacrifice();
+      isTruncated = true;
+    }
+
+    if (isTruncated) {
+      clamped.isTruncated = true;
+    }
+
+    return clamped;
+  }
+
+  private static serializedLength(payload: AIRunEventContentPayload): number {
+    try {
+      return JSON.stringify(payload).length;
+    } catch {
+      return Number.MAX_SAFE_INTEGER;
+    }
+  }
+}

package/Server/Utils/AI/Chat/ChatAgentRunner.ts

@@ -7,6 +7,7 @@ import { JSONObject } from "../../../../Types/JSON";
 import ObjectID from "../../../../Types/ObjectID";
 import AIChatMessageRole from "../../../../Types/AI/AIChatMessageRole";
 import AIChatMessageStatus from "../../../../Types/AI/AIChatMessageStatus";
+import { AIChatPageContext } from "../../../../Types/AI/AIChatPageContext";
 import AIChatPermissionMode from "../../../../Types/AI/AIChatPermissionMode";
 import AIRunEventType from "../../../../Types/AI/AIRunEventType";
 import AIRunStatus from "../../../../Types/AI/AIRunStatus";
@@ -43,6 +44,13 @@ export interface ChatTurnRequest {
   llmProviderId?: ObjectID | undefined;
   // How much autonomy the agent has to run mutating tools in this conversation.
   permissionMode: AIChatPermissionMode;
+  /*
+   * What the user was looking at in the dashboard when they sent this message
+   * (already sanitized by the API). Folded into the system prompt so "this
+   * incident" resolves to the entity on screen. Per-turn: not persisted, and
+   * not needed on resume (the paused state already contains the built prompt).
+   */
+  pageContext?: AIChatPageContext | undefined;
   // The requesting user's real permission props, captured at request time.
   props: DatabaseCommonInteractionProps;
 }
@@ -891,6 +899,7 @@ export default class ChatAgentRunner {
         content: buildObservabilityChatSystemPrompt({
           currentTime: OneUptimeDate.getCurrentDate(),
           permissionMode: request.permissionMode,
+          pageContext: request.pageContext,
         }),
       },
     ];