@oneuptime/common 11.5.7 → 11.5.9

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/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/AIRunPrivacyFilter.ts

@@ -0,0 +1,106 @@
+import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import { FindWhereProperty } from "../../../Types/BaseDatabase/Query";
+import NotAuthorizedException from "../../../Types/Exception/NotAuthorizedException";
+import AIRunType from "../../../Types/AI/AIRunType";
+import Text from "../../../Types/Text";
+import { combineWithPrivacyClause } from "../PrivacyFilterUtil";
+import { Raw } from "typeorm";
+
+/*
+ * AIRun mixes two kinds of row under one table:
+ *
+ *  - Chat and investigation runs are PERSONAL. They hang off a conversation
+ *    and carry the user's own prompt trail, so only their author may read
+ *    them. This is what AIChatPrivacyFilter's flat pin protects, and that pin
+ *    stays exactly as it is for AIConversation, AIConversationMessage and
+ *    AIRunEvent.
+ *  - CodeFix runs are a SHARED TEAM ARTIFACT: they are triggered off an
+ *    exception or an incident, they produce a pull request, and their child
+ *    AIAgentTaskPullRequest rows are already project-readable through the
+ *    standard CRUD. `userId` on a CodeFix run is attribution only (who
+ *    clicked "Fix with AI Agent") and is null for automatic triggers — it
+ *    carries no conversational content.
+ *
+ * So AIRun cannot use that flat pin. It needs `runType = CodeFix OR userId =
+ * <caller>`, a CROSS-COLUMN disjunction, which a query object cannot express
+ * (query objects are conjunctions).
+ *
+ * The clause below is built ENTIRELY from server state and AND-ed onto the
+ * caller's query. It never READS query.runType to decide anything — that
+ * would be unsound, because onBeforeFind runs BEFORE QueryUtil.serializeQuery,
+ * so query.runType here is still a raw, client-controlled operator object
+ * whose .value/.toString() are identical across the safe and hostile cases:
+ * LessThan("CodeFix") stringifies to exactly "CodeFix" but compiles to
+ * `runType < 'CodeFix'`, which matches "Chat". Because the clause is forced, a
+ * caller-supplied runType filter can only ever NARROW it, and
+ * combineWithPrivacyClause fails closed on operator shapes it does not
+ * recognize.
+ *
+ * Modelled on Utils/Incident/IncidentPrivacyFilter, which solves the same
+ * "unrestricted rows for everyone, restricted rows only for their owner"
+ * shape.
+ */
+export function getAIRunPrivacyRaw(
+  props: DatabaseCommonInteractionProps,
+): FindWhereProperty<any> | undefined {
+  if (props.isRoot || props.isMasterAdmin) {
+    return undefined;
+  }
+
+  /*
+   * The same hard gate the flat pin has, and it must stay. A caller with no
+   * user — a project API key, which gets userTenantAccessPermission but never
+   * userAuthorization (see ProjectAuthorization), so props.userId is
+   * undefined — has no personal scope. Today such a caller cannot read AIRun
+   * at all. Letting CodeFix rows through here would hand every API key holding
+   * ProjectMember the project's whole fix history: access that neither
+   * /ai-run nor /code-fix-run grants today. That is a separate product
+   * decision and must not ride in as a side effect of this filter.
+   */
+  if (!props.userId) {
+    throw new NotAuthorizedException(
+      "AI runs are personal and can only be accessed by the user who created them.",
+    );
+  }
+
+  const userIdRid: string = "aiRunUid_" + Text.generateRandomText(10);
+  const runTypeRid: string = "aiRunType_" + Text.generateRandomText(10);
+
+  return Raw(
+    (alias: string): string => {
+      return `(${alias} = :${runTypeRid} OR "AIRun"."userId" = :${userIdRid})`;
+    },
+    {
+      [runTypeRid]: AIRunType.CodeFix,
+      [userIdRid]: props.userId.toString(),
+    },
+  );
+}
+
+/*
+ * Applies the clause above on AIRun.runType. Project isolation is unaffected:
+ * @TenantColumn("projectId") independently forces projectId = <tenant>, so
+ * "CodeFix runs are readable" always means "in YOUR project".
+ */
+export function applyAIRunPrivacyFilter<TQuery>(
+  query: TQuery,
+  props: DatabaseCommonInteractionProps,
+): TQuery {
+  const rawClause: FindWhereProperty<any> | undefined =
+    getAIRunPrivacyRaw(props);
+
+  if (!rawClause) {
+    return query;
+  }
+
+  if (!query) {
+    return { runType: rawClause } as unknown as TQuery;
+  }
+
+  (query as any).runType = combineWithPrivacyClause(
+    (query as any).runType,
+    rawClause,
+  );
+
+  return query;
+}

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,
         }),
       },
     ];