@oneuptime/common 11.5.8 → 11.5.10

package/Tests/Server/Utils/AI/AIRunTranscript.test.ts

@@ -0,0 +1,182 @@
+import AIRunTranscript, {
+  MAX_MESSAGE_CONTENT_CHARS,
+  MAX_PAYLOAD_CHARS,
+  MAX_RESPONSE_CONTENT_CHARS,
+  MAX_TOOL_ARGUMENT_CHARS,
+  MAX_TOOL_RESULT_CHARS,
+} from "../../../../Server/Utils/AI/AIRunTranscript";
+import { AIRunEventContentPayload } from "../../../../Types/AI/AIChatTypes";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The run transcript is the ONE place a code-fix run's LLM content is stored
+ * (LlmLog redacts it — it is project-wide readable and these prompts embed
+ * customer source code). It stores content verbatim to be worth reading when
+ * a run goes wrong, which makes bounding it a storage requirement rather than
+ * a nicety: an agent may read large files and run test suites emitting
+ * megabytes, up to 40 times per run.
+ *
+ * These tests pin the two properties that make that safe: every field is
+ * capped, and the payload as a whole cannot exceed MAX_PAYLOAD_CHARS no
+ * matter WHICH field carries the bulk.
+ */
+
+type SerializedLengthFunction = (payload: AIRunEventContentPayload) => number;
+
+const serializedLength: SerializedLengthFunction = (
+  payload: AIRunEventContentPayload,
+): number => {
+  return JSON.stringify(payload).length;
+};
+
+describe("AIRunTranscript.clip", () => {
+  test("leaves a value under the cap untouched and unflagged", () => {
+    expect(AIRunTranscript.clip("short", 100)).toEqual({
+      value: "short",
+      isTruncated: false,
+    });
+  });
+
+  test("clips an oversized value and reports the truncation", () => {
+    const result: { value: string | undefined; isTruncated: boolean } =
+      AIRunTranscript.clip("x".repeat(50), 10);
+
+    expect(result.isTruncated).toBe(true);
+    expect(result.value).toContain("truncated");
+    expect(result.value!.startsWith("x".repeat(10))).toBe(true);
+  });
+
+  test("passes undefined through without inventing a value", () => {
+    expect(AIRunTranscript.clip(undefined, 10)).toEqual({
+      value: undefined,
+      isTruncated: false,
+    });
+  });
+});
+
+describe("AIRunTranscript.clipArguments", () => {
+  test("keeps arguments under the cap verbatim", () => {
+    const args: { path: string } = { path: "src/Index.ts" };
+    expect(AIRunTranscript.clipArguments(args)).toEqual({
+      value: args,
+      isTruncated: false,
+    });
+  });
+
+  /*
+   * A write_file call carries a whole file in its arguments — the single
+   * likeliest way one tool call bloats a row.
+   */
+  test("replaces oversized arguments with a marker that keeps a preview", () => {
+    const result: {
+      value: Record<string, unknown> | undefined;
+      isTruncated: boolean;
+    } = AIRunTranscript.clipArguments({
+      content: "y".repeat(MAX_TOOL_ARGUMENT_CHARS + 1000),
+    });
+
+    expect(result.isTruncated).toBe(true);
+    expect(result.value!["_note"]).toContain("exceeds");
+    expect(typeof result.value!["_preview"]).toBe("string");
+  });
+});
+
+describe("AIRunTranscript.clampPayload", () => {
+  test("caps each field independently and stamps isTruncated", () => {
+    const clamped: AIRunEventContentPayload = AIRunTranscript.clampPayload({
+      requestMessages: [
+        { role: "user", content: "a".repeat(MAX_MESSAGE_CONTENT_CHARS + 500) },
+      ],
+      responseContent: "b".repeat(MAX_RESPONSE_CONTENT_CHARS + 500),
+      toolResult: "c".repeat(MAX_TOOL_RESULT_CHARS + 500),
+    });
+
+    expect(clamped.isTruncated).toBe(true);
+    expect(clamped.requestMessages![0]!.content.length).toBeLessThanOrEqual(
+      MAX_MESSAGE_CONTENT_CHARS + 100,
+    );
+    expect(clamped.responseContent!.length).toBeLessThanOrEqual(
+      MAX_RESPONSE_CONTENT_CHARS + 100,
+    );
+    expect(clamped.toolResult!.length).toBeLessThanOrEqual(
+      MAX_TOOL_RESULT_CHARS + 100,
+    );
+  });
+
+  test("leaves a small payload entirely alone", () => {
+    const payload: AIRunEventContentPayload = {
+      requestMessages: [{ role: "user", content: "fix the null deref" }],
+      responseContent: "Reading the file.",
+      responseToolCalls: [{ name: "read_file", arguments: { path: "a.ts" } }],
+      totalTokens: 120,
+    };
+
+    const clamped: AIRunEventContentPayload =
+      AIRunTranscript.clampPayload(payload);
+
+    expect(clamped.isTruncated).toBeUndefined();
+    expect(clamped).toEqual(payload);
+  });
+
+  /*
+   * The regression this file exists for. A single-pass backstop that only
+   * dropped requestMessages "succeeded" by deleting a two-character user
+   * message while the row stayed ~1.5x over the ceiling, because the bulk was
+   * in responseToolCalls. The cap must hold regardless of which field is fat.
+   */
+  test("holds the ceiling when the bulk is in responseToolCalls, not messages", () => {
+    const clamped: AIRunEventContentPayload = AIRunTranscript.clampPayload({
+      requestMessages: [{ role: "user", content: "hi" }],
+      responseToolCalls: Array.from(
+        { length: 30 },
+        (_value: unknown, index: number) => {
+          return {
+            id: `call_${index}`,
+            name: "write_file",
+            arguments: { content: "z".repeat(MAX_TOOL_ARGUMENT_CHARS - 200) },
+          };
+        },
+      ),
+    });
+
+    expect(serializedLength(clamped)).toBeLessThanOrEqual(MAX_PAYLOAD_CHARS);
+    expect(clamped.isTruncated).toBe(true);
+  });
+
+  test("holds the ceiling when the bulk is a huge tool result", () => {
+    const clamped: AIRunEventContentPayload = AIRunTranscript.clampPayload({
+      toolResult: "q".repeat(MAX_PAYLOAD_CHARS * 3),
+    });
+
+    expect(serializedLength(clamped)).toBeLessThanOrEqual(MAX_PAYLOAD_CHARS);
+    expect(clamped.isTruncated).toBe(true);
+  });
+
+  /*
+   * Bounded ENTRIES are not a bounded ARRAY: with every argument already
+   * dropped, enough calls still blow the ceiling. The last resort collapses
+   * the array to a count.
+   */
+  test("holds the ceiling against a pathological number of tool calls", () => {
+    const clamped: AIRunEventContentPayload = AIRunTranscript.clampPayload({
+      responseToolCalls: Array.from(
+        { length: 20000 },
+        (_value: unknown, index: number) => {
+          return { id: `call_${index}`, name: "read_file" };
+        },
+      ),
+    });
+
+    expect(serializedLength(clamped)).toBeLessThanOrEqual(MAX_PAYLOAD_CHARS);
+    expect(clamped.isTruncated).toBe(true);
+  });
+
+  // A clipped prompt must never be presented as though it were whole.
+  test("never reports a clipped payload as complete", () => {
+    const clamped: AIRunEventContentPayload = AIRunTranscript.clampPayload({
+      responseContent: "r".repeat(MAX_RESPONSE_CONTENT_CHARS + 1),
+    });
+
+    expect(clamped.isTruncated).toBe(true);
+  });
+});

package/Tests/Server/Utils/AI/CodeFixReadiness.test.ts

@@ -0,0 +1,411 @@
+import CodeFixReadiness from "../../../../Server/Utils/AI/CodeFix/CodeFixReadiness";
+import SubjectCodeFixRun from "../../../../Server/Utils/AI/SRE/SubjectCodeFixRun";
+import AIAgentService from "../../../../Server/Services/AIAgentService";
+import AIService from "../../../../Server/Services/AIService";
+import LlmProviderService from "../../../../Server/Services/LlmProviderService";
+import ProjectService from "../../../../Server/Services/ProjectService";
+import AIAgent from "../../../../Models/DatabaseModels/AIAgent";
+import LlmProvider from "../../../../Models/DatabaseModels/LlmProvider";
+import Project from "../../../../Models/DatabaseModels/Project";
+import ObjectID from "../../../../Types/ObjectID";
+import {
+  AIFixReadiness,
+  AIFixReadinessCheck,
+} from "../../../../Types/AI/AIFixReadiness";
+import { describe, expect, test, afterEach, beforeEach } from "@jest/globals";
+
+/*
+ * The gates the AI Tasks page renders. The invariant worth protecting: a
+ * project LLM provider is NOT a prerequisite — the shared global provider is
+ * a legitimate resolution for the agent path, so a project running on it must
+ * read as ready. The banner these checks replaced claimed otherwise.
+ */
+
+const projectId: ObjectID = ObjectID.generate();
+
+function fakeProvider(params: {
+  name: string;
+  isGlobalLlm?: boolean;
+  costPerMillionTokensInUSDCents?: number;
+}): LlmProvider {
+  return {
+    id: ObjectID.generate(),
+    name: params.name,
+    isGlobalLlm: params.isGlobalLlm ?? false,
+    costPerMillionTokensInUSDCents: params.costPerMillionTokensInUSDCents ?? 0,
+  } as unknown as LlmProvider;
+}
+
+// No daily-budget limit configured: the common case, and never a blocker.
+function mockBudgetNotExhausted(): void {
+  jest.spyOn(AIService, "getAutonomousDailyBudgetStatus").mockResolvedValue({
+    exhausted: false,
+    limitInTokens: null,
+    usedTokensToday: 0,
+  });
+}
+
+describe("CodeFixReadiness.getLlmProviderCheck", () => {
+  beforeEach(() => {
+    mockBudgetNotExhausted();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("no provider resolves at all: not ready, and says where to add one", async () => {
+    jest
+      .spyOn(LlmProviderService, "getLlmProviderForMeteredAgentPath")
+      .mockResolvedValue(null);
+
+    const check: AIFixReadinessCheck =
+      await CodeFixReadiness.getLlmProviderCheck({ projectId });
+
+    expect(check.id).toBe("llmProvider");
+    expect(check.ok).toBe(false);
+    expect(check.detail).toContain("LLM Providers");
+  });
+
+  test("a project-owned provider is ready and is named as the project's own", async () => {
+    jest
+      .spyOn(LlmProviderService, "getLlmProviderForMeteredAgentPath")
+      .mockResolvedValue(fakeProvider({ name: "My OpenAI" }));
+
+    const check: AIFixReadinessCheck =
+      await CodeFixReadiness.getLlmProviderCheck({
+        projectId,
+        billingEnabled: true,
+      });
+
+    expect(check.ok).toBe(true);
+    expect(check.title).toContain("My OpenAI");
+    expect(check.detail).toContain("this project's own provider");
+  });
+
+  /*
+   * The headline case the old banner got wrong: no project provider, a free
+   * global one, and the project is nonetheless ready.
+   */
+  test("a FREE global provider is ready with no project provider and no balance", async () => {
+    jest
+      .spyOn(LlmProviderService, "getLlmProviderForMeteredAgentPath")
+      .mockResolvedValue(
+        fakeProvider({
+          name: "Global LLM Provider",
+          isGlobalLlm: true,
+          costPerMillionTokensInUSDCents: 0,
+        }),
+      );
+    const projectSpy: jest.SpiedFunction<typeof ProjectService.findOneById> =
+      jest.spyOn(ProjectService, "findOneById");
+
+    const check: AIFixReadinessCheck =
+      await CodeFixReadiness.getLlmProviderCheck({
+        projectId,
+        billingEnabled: true,
+      });
+
+    expect(check.ok).toBe(true);
+    expect(check.detail).toContain("shared provider");
+    // A free provider bills nothing, so the balance must never be consulted.
+    expect(projectSpy).not.toHaveBeenCalled();
+  });
+
+  test("a costed global provider with billing OFF is ready and skips the balance check", async () => {
+    jest
+      .spyOn(LlmProviderService, "getLlmProviderForMeteredAgentPath")
+      .mockResolvedValue(
+        fakeProvider({
+          name: "OneUptime AI",
+          isGlobalLlm: true,
+          costPerMillionTokensInUSDCents: 500,
+        }),
+      );
+    const projectSpy: jest.SpiedFunction<typeof ProjectService.findOneById> =
+      jest.spyOn(ProjectService, "findOneById");
+
+    const check: AIFixReadinessCheck =
+      await CodeFixReadiness.getLlmProviderCheck({
+        projectId,
+        billingEnabled: false,
+      });
+
+    expect(check.ok).toBe(true);
+    expect(projectSpy).not.toHaveBeenCalled();
+  });
+
+  test("a costed global provider with billing ON and a funded balance is ready and says it is metered", async () => {
+    jest
+      .spyOn(LlmProviderService, "getLlmProviderForMeteredAgentPath")
+      .mockResolvedValue(
+        fakeProvider({
+          name: "OneUptime AI",
+          isGlobalLlm: true,
+          costPerMillionTokensInUSDCents: 500,
+        }),
+      );
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue({
+      aiCurrentBalanceInUSDCents: 2000,
+    } as unknown as Project);
+
+    const check: AIFixReadinessCheck =
+      await CodeFixReadiness.getLlmProviderCheck({
+        projectId,
+        billingEnabled: true,
+      });
+
+    expect(check.ok).toBe(true);
+    expect(check.detail).toContain("AI balance");
+  });
+
+  test("a costed global provider with billing ON and an empty balance is NOT ready", async () => {
+    jest
+      .spyOn(LlmProviderService, "getLlmProviderForMeteredAgentPath")
+      .mockResolvedValue(
+        fakeProvider({
+          name: "OneUptime AI",
+          isGlobalLlm: true,
+          costPerMillionTokensInUSDCents: 500,
+        }),
+      );
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue({
+      aiCurrentBalanceInUSDCents: 0,
+    } as unknown as Project);
+
+    const check: AIFixReadinessCheck =
+      await CodeFixReadiness.getLlmProviderCheck({
+        projectId,
+        billingEnabled: true,
+      });
+
+    expect(check.ok).toBe(false);
+    expect(check.detail).toContain("AI Credits");
+  });
+});
+
+/*
+ * AI_CODE_FIX_FEATURE is one of AUTONOMOUS_AI_FEATURES, so executeWithLogging
+ * runs every fix completion through the daily token budget. Readiness that
+ * ignored it would report ready and then die at the run's first completion
+ * call — the exact fail-late hole the balance gate exists to close.
+ */
+describe("CodeFixReadiness.getLlmProviderCheck — daily autonomous token budget", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("a zeroed daily limit (the kill switch) is NOT ready, even with a healthy project-owned provider", async () => {
+    jest
+      .spyOn(LlmProviderService, "getLlmProviderForMeteredAgentPath")
+      .mockResolvedValue(fakeProvider({ name: "My OpenAI" }));
+    jest.spyOn(AIService, "getAutonomousDailyBudgetStatus").mockResolvedValue({
+      exhausted: true,
+      limitInTokens: 0,
+      usedTokensToday: 0,
+    });
+
+    const check: AIFixReadinessCheck =
+      await CodeFixReadiness.getLlmProviderCheck({
+        projectId,
+        billingEnabled: false,
+      });
+
+    expect(check.ok).toBe(false);
+    expect(check.detail).toContain("paused");
+  });
+
+  test("an exhausted daily budget is NOT ready and reports the usage", async () => {
+    jest
+      .spyOn(LlmProviderService, "getLlmProviderForMeteredAgentPath")
+      .mockResolvedValue(fakeProvider({ name: "My OpenAI" }));
+    jest.spyOn(AIService, "getAutonomousDailyBudgetStatus").mockResolvedValue({
+      exhausted: true,
+      limitInTokens: 1000,
+      usedTokensToday: 1000,
+    });
+
+    const check: AIFixReadinessCheck =
+      await CodeFixReadiness.getLlmProviderCheck({
+        projectId,
+        billingEnabled: false,
+      });
+
+    expect(check.ok).toBe(false);
+    expect(check.detail).toContain("exhausted");
+    expect(check.detail).toContain("1,000");
+  });
+
+  test("an unset daily limit never blocks", async () => {
+    jest
+      .spyOn(LlmProviderService, "getLlmProviderForMeteredAgentPath")
+      .mockResolvedValue(fakeProvider({ name: "My OpenAI" }));
+    mockBudgetNotExhausted();
+
+    const check: AIFixReadinessCheck =
+      await CodeFixReadiness.getLlmProviderCheck({
+        projectId,
+        billingEnabled: false,
+      });
+
+    expect(check.ok).toBe(true);
+  });
+});
+
+describe("CodeFixReadiness.getAgentCheck", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("no agent for the project: not ready", async () => {
+    jest.spyOn(AIAgentService, "getAIAgentForProject").mockResolvedValue(null);
+
+    const check: AIFixReadinessCheck = await CodeFixReadiness.getAgentCheck({
+      projectId,
+    });
+
+    expect(check.id).toBe("agentAvailable");
+    expect(check.ok).toBe(false);
+    expect(check.detail).toContain("No AI agent is available");
+  });
+
+  test("an agent that exists but is not alive: not ready, and names it", async () => {
+    jest
+      .spyOn(AIAgentService, "getAIAgentForProject")
+      .mockResolvedValue({ name: "fix-worker" } as unknown as AIAgent);
+    jest.spyOn(AIAgentService, "isAgentAlive").mockReturnValue(false);
+
+    const check: AIFixReadinessCheck = await CodeFixReadiness.getAgentCheck({
+      projectId,
+    });
+
+    expect(check.ok).toBe(false);
+    expect(check.detail).toContain("fix-worker");
+  });
+
+  test("a live agent is ready and is named", async () => {
+    jest
+      .spyOn(AIAgentService, "getAIAgentForProject")
+      .mockResolvedValue({ name: "fix-worker" } as unknown as AIAgent);
+    jest.spyOn(AIAgentService, "isAgentAlive").mockReturnValue(true);
+
+    const check: AIFixReadinessCheck = await CodeFixReadiness.getAgentCheck({
+      projectId,
+    });
+
+    expect(check.ok).toBe(true);
+    expect(check.title).toContain("fix-worker");
+  });
+});
+
+describe("CodeFixReadiness.getRepositoryConnectedCheck", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  /*
+   * The page-level gate asserts the WEAKER any-repo claim, so its id must
+   * stay distinct from the per-exception repositoryResolved — a UI that saw
+   * the same id would imply a specific exception will resolve.
+   */
+  test("a connected repository is ready under the repositoryConnected id", async () => {
+    jest
+      .spyOn(SubjectCodeFixRun, "hasGitHubAppConnectedRepository")
+      .mockResolvedValue(true);
+
+    const check: AIFixReadinessCheck =
+      await CodeFixReadiness.getRepositoryConnectedCheck({ projectId });
+
+    expect(check.id).toBe("repositoryConnected");
+    expect(check.ok).toBe(true);
+  });
+
+  test("no connected repository: not ready, and points at the GitHub App", async () => {
+    jest
+      .spyOn(SubjectCodeFixRun, "hasGitHubAppConnectedRepository")
+      .mockResolvedValue(false);
+
+    const check: AIFixReadinessCheck =
+      await CodeFixReadiness.getRepositoryConnectedCheck({ projectId });
+
+    expect(check.ok).toBe(false);
+    expect(check.detail).toContain("GitHub App");
+  });
+});
+
+describe("CodeFixReadiness.getProjectReadiness", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  type MockAllParams = {
+    hasRepo: boolean;
+    hasProvider: boolean;
+    agentAlive: boolean;
+  };
+
+  function mockAll(params: MockAllParams): void {
+    mockBudgetNotExhausted();
+    jest
+      .spyOn(SubjectCodeFixRun, "hasGitHubAppConnectedRepository")
+      .mockResolvedValue(params.hasRepo);
+    jest
+      .spyOn(LlmProviderService, "getLlmProviderForMeteredAgentPath")
+      .mockResolvedValue(
+        params.hasProvider ? fakeProvider({ name: "provider" }) : null,
+      );
+    jest
+      .spyOn(AIAgentService, "getAIAgentForProject")
+      .mockResolvedValue({ name: "agent" } as unknown as AIAgent);
+    jest
+      .spyOn(AIAgentService, "isAgentAlive")
+      .mockReturnValue(params.agentAlive);
+  }
+
+  test("all three gates satisfied: ready", async () => {
+    mockAll({ hasRepo: true, hasProvider: true, agentAlive: true });
+
+    const readiness: AIFixReadiness =
+      await CodeFixReadiness.getProjectReadiness({ projectId });
+
+    expect(readiness.ready).toBe(true);
+    expect(readiness.checks).toHaveLength(3);
+  });
+
+  test("the checks are ordered the way the user sets them up", async () => {
+    mockAll({ hasRepo: true, hasProvider: true, agentAlive: true });
+
+    const readiness: AIFixReadiness =
+      await CodeFixReadiness.getProjectReadiness({ projectId });
+
+    expect(
+      readiness.checks.map((check: AIFixReadinessCheck) => {
+        return check.id;
+      }),
+    ).toEqual(["repositoryConnected", "llmProvider", "agentAvailable"]);
+  });
+
+  test("any single failing gate makes the whole project not ready", async () => {
+    const cases: Array<MockAllParams> = [
+      { hasRepo: false, hasProvider: true, agentAlive: true },
+      { hasRepo: true, hasProvider: false, agentAlive: true },
+      { hasRepo: true, hasProvider: true, agentAlive: false },
+    ];
+
+    for (const params of cases) {
+      jest.restoreAllMocks();
+      mockAll(params);
+
+      const readiness: AIFixReadiness =
+        await CodeFixReadiness.getProjectReadiness({ projectId });
+
+      expect(readiness.ready).toBe(false);
+      // The failing gate must still be reported, not swallowed.
+      expect(
+        readiness.checks.some((check: AIFixReadinessCheck) => {
+          return !check.ok;
+        }),
+      ).toBe(true);
+    }
+  });
+});