@oneuptime/common 11.5.4 → 11.5.5

package/Tests/Server/Services/LlmProviderProjectOwned.test.ts

@@ -0,0 +1,132 @@
+import LlmProviderService from "../../../Server/Services/LlmProviderService";
+import LlmProvider from "../../../Models/DatabaseModels/LlmProvider";
+import ObjectID from "../../../Types/ObjectID";
+import Query from "../../../Server/Types/Database/Query";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * getProjectOwnedLlmProvider is the project-preference leg of the agent
+ * provider resolution (getLlmProviderForMeteredAgentPath). The invariant
+ * these tests lock in: this resolver only ever queries providers owned by
+ * the given project — the global-provider fallback is layered on top by
+ * its caller, never here.
+ */
+
+const projectId: ObjectID = ObjectID.generate();
+
+function fakeProvider(name: string): LlmProvider {
+  return { id: ObjectID.generate(), name } as unknown as LlmProvider;
+}
+
+describe("LlmProviderService.getProjectOwnedLlmProvider", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("returns the project default when one exists", async () => {
+    const defaultProvider: LlmProvider = fakeProvider("default");
+    const spy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> = jest
+      .spyOn(LlmProviderService, "findOneBy")
+      .mockResolvedValueOnce(defaultProvider);
+
+    const result: LlmProvider | null =
+      await LlmProviderService.getProjectOwnedLlmProvider(projectId);
+
+    expect(result).toBe(defaultProvider);
+    expect(spy).toHaveBeenCalledTimes(1);
+    const query: Query<LlmProvider> = spy.mock.calls[0]![0]!.query;
+    expect(query["projectId"]).toBe(projectId);
+    expect(query["isDefault"]).toBe(true);
+  });
+
+  test("falls back to any project-owned provider, never the global one", async () => {
+    const nonDefault: LlmProvider = fakeProvider("byo");
+    const spy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> = jest
+      .spyOn(LlmProviderService, "findOneBy")
+      .mockResolvedValueOnce(null)
+      .mockResolvedValueOnce(nonDefault);
+
+    const result: LlmProvider | null =
+      await LlmProviderService.getProjectOwnedLlmProvider(projectId);
+
+    expect(result).toBe(nonDefault);
+    expect(spy).toHaveBeenCalledTimes(2);
+
+    // Every query issued must be scoped to the project — no global fallback.
+    for (const call of spy.mock.calls) {
+      const query: Query<LlmProvider> = call[0]!.query;
+      expect(query["projectId"]).toBe(projectId);
+      expect(query["isGlobalLlm"]).toBeUndefined();
+    }
+  });
+
+  test("returns null when the project owns no provider at all", async () => {
+    jest.spyOn(LlmProviderService, "findOneBy").mockResolvedValue(null);
+
+    const result: LlmProvider | null =
+      await LlmProviderService.getProjectOwnedLlmProvider(projectId);
+
+    expect(result).toBeNull();
+  });
+});
+
+/*
+ * getLlmProviderForMeteredAgentPath backs the SERVER-MEDIATED completion
+ * endpoint (B4 Tier 0), whose calls run through AIService.executeWithLogging
+ * — metered, logged, budgeted. Because metering is universal there, the
+ * global provider is a legitimate fallback ON CLOUD TOO (usage is billed as
+ * metered AI tokens). This is the only agent provider resolution — the
+ * raw-key path (get-llm-config / getLlmProviderForAgentTasks) is removed.
+ */
+describe("LlmProviderService.getLlmProviderForMeteredAgentPath", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("a project-owned provider always wins, without a global query", async () => {
+    const owned: LlmProvider = fakeProvider("owned");
+    jest
+      .spyOn(LlmProviderService, "getProjectOwnedLlmProvider")
+      .mockResolvedValue(owned);
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest.spyOn(LlmProviderService, "findOneBy");
+
+    const result: LlmProvider | null =
+      await LlmProviderService.getLlmProviderForMeteredAgentPath(projectId);
+
+    expect(result).toBe(owned);
+    expect(findSpy).not.toHaveBeenCalled();
+  });
+
+  test("falls back to the global provider when the project owns none — cloud included", async () => {
+    const globalProvider: LlmProvider = fakeProvider("global");
+    jest
+      .spyOn(LlmProviderService, "getProjectOwnedLlmProvider")
+      .mockResolvedValue(null);
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest
+        .spyOn(LlmProviderService, "findOneBy")
+        .mockResolvedValue(globalProvider);
+
+    const result: LlmProvider | null =
+      await LlmProviderService.getLlmProviderForMeteredAgentPath(projectId);
+
+    expect(result).toBe(globalProvider);
+    expect(findSpy).toHaveBeenCalledTimes(1);
+    const query: Query<LlmProvider> = findSpy.mock.calls[0]![0]!.query;
+    expect(query["isGlobalLlm"]).toBe(true);
+    // Global rows have no projectId — the query must target the null tenant.
+    expect(query["projectId"]).not.toBe(projectId);
+  });
+
+  test("returns null when neither a project-owned nor a global provider exists", async () => {
+    jest
+      .spyOn(LlmProviderService, "getProjectOwnedLlmProvider")
+      .mockResolvedValue(null);
+    jest.spyOn(LlmProviderService, "findOneBy").mockResolvedValue(null);
+
+    expect(
+      await LlmProviderService.getLlmProviderForMeteredAgentPath(projectId),
+    ).toBeNull();
+  });
+});

package/Tests/Server/Services/TelemetryExceptionAIFixReadiness.test.ts

@@ -0,0 +1,405 @@
+import TelemetryExceptionService, {
+  AIFixReadiness,
+  AIFixReadinessCheck,
+} from "../../../Server/Services/TelemetryExceptionService";
+import FixRunBudget from "../../../Server/Utils/AI/CodeFix/FixRunBudget";
+import LlmProviderService from "../../../Server/Services/LlmProviderService";
+import ProjectService from "../../../Server/Services/ProjectService";
+import ServiceService from "../../../Server/Services/ServiceService";
+import CodeRepositoryService from "../../../Server/Services/CodeRepositoryService";
+import AIAgentService from "../../../Server/Services/AIAgentService";
+import { RepoResolution } from "../../../Server/Utils/CodeRepository/StackTraceRepoResolver";
+import TelemetryException from "../../../Models/DatabaseModels/TelemetryException";
+import TelemetryService from "../../../Models/DatabaseModels/Service";
+import LlmProvider from "../../../Models/DatabaseModels/LlmProvider";
+import Project from "../../../Models/DatabaseModels/Project";
+import AIAgent, {
+  AIAgentConnectionStatus,
+} from "../../../Models/DatabaseModels/AIAgent";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+import OneUptimeDate from "../../../Types/Date";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * "Fix with AI Agent" readiness: every prerequisite is checked BEFORE a task
+ * is created. Since the runtime-resolution change there are exactly three
+ * checks — LLM provider (project-owned preferred, metered global fallback —
+ * agent completions are server-mediated), repository RESOLVED (stack-trace
+ * matching with fallbacks, no Service Catalog prerequisite), agent online.
+ * These tests mock the persistence layer and lock in each check's fail
+ * condition and the fail-early behaviour of task creation.
+ */
+
+const projectId: ObjectID = ObjectID.generate();
+const exceptionId: ObjectID = ObjectID.generate();
+const serviceId: ObjectID = ObjectID.generate();
+
+function fakeException(): TelemetryException {
+  return {
+    id: exceptionId,
+    projectId: projectId,
+    primaryEntityId: serviceId,
+    stackTrace: "at charge (/app/src/billing/charge.ts:12:5)",
+  } as unknown as TelemetryException;
+}
+
+function fakeResolution(): RepoResolution {
+  return {
+    codeRepositoryId: ObjectID.generate().toString(),
+    organizationName: "acme",
+    repositoryName: "checkout",
+    servicePathInRepository: null,
+    method: "stack-trace",
+    evidence: "Matched src/billing/charge.ts in acme/checkout",
+  };
+}
+
+function fakeAgent(data: {
+  connectionStatus?: AIAgentConnectionStatus;
+  lastAlive?: Date;
+}): AIAgent {
+  return {
+    id: ObjectID.generate(),
+    name: "agent",
+    connectionStatus: data.connectionStatus,
+    lastAlive: data.lastAlive,
+  } as unknown as AIAgent;
+}
+
+interface ReadinessMocks {
+  provider?: LlmProvider | null;
+  resolution?: RepoResolution | null;
+  resolutionThrows?: Error;
+  agent?: AIAgent | null;
+}
+
+function mockReadiness(data: ReadinessMocks): void {
+  jest
+    .spyOn(TelemetryExceptionService, "findOneById")
+    .mockResolvedValue(fakeException());
+  jest
+    .spyOn(LlmProviderService, "getLlmProviderForMeteredAgentPath")
+    .mockResolvedValue(
+      data.provider === undefined
+        ? ({ id: ObjectID.generate(), name: "BYO" } as unknown as LlmProvider)
+        : data.provider,
+    );
+  jest.spyOn(ServiceService, "findOneById").mockResolvedValue({
+    id: serviceId,
+    name: "checkout",
+  } as unknown as TelemetryService);
+
+  const resolutionSpy: jest.SpiedFunction<
+    typeof CodeRepositoryService.resolveRepositoryForException
+  > = jest.spyOn(CodeRepositoryService, "resolveRepositoryForException");
+
+  if (data.resolutionThrows) {
+    resolutionSpy.mockRejectedValue(data.resolutionThrows);
+  } else {
+    resolutionSpy.mockResolvedValue(
+      data.resolution === undefined ? fakeResolution() : data.resolution,
+    );
+  }
+
+  jest
+    .spyOn(AIAgentService, "getAIAgentForProject")
+    .mockResolvedValue(
+      data.agent === undefined
+        ? fakeAgent({ connectionStatus: AIAgentConnectionStatus.Connected })
+        : data.agent,
+    );
+}
+
+function getCheck(readiness: AIFixReadiness, id: string): AIFixReadinessCheck {
+  const check: AIFixReadinessCheck | undefined = readiness.checks.find(
+    (item: AIFixReadinessCheck) => {
+      return item.id === id;
+    },
+  );
+  expect(check).toBeDefined();
+  return check!;
+}
+
+describe("TelemetryExceptionService.getAIFixReadiness", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("is ready with provider, resolved repository, and alive agent — exactly three checks", async () => {
+    mockReadiness({});
+
+    const readiness: AIFixReadiness =
+      await TelemetryExceptionService.getAIFixReadiness({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+      });
+
+    expect(readiness.ready).toBe(true);
+    expect(readiness.checks).toHaveLength(3);
+    for (const check of readiness.checks) {
+      expect(check.ok).toBe(true);
+    }
+  });
+
+  test("resolved repository is named in the check title as evidence", async () => {
+    mockReadiness({});
+
+    const readiness: AIFixReadiness =
+      await TelemetryExceptionService.getAIFixReadiness({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+      });
+
+    expect(getCheck(readiness, "repositoryResolved").title).toContain(
+      "acme/checkout",
+    );
+  });
+
+  test("fails llmProvider check when no provider is available", async () => {
+    mockReadiness({ provider: null });
+
+    const readiness: AIFixReadiness =
+      await TelemetryExceptionService.getAIFixReadiness({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+      });
+
+    expect(readiness.ready).toBe(false);
+    const check: AIFixReadinessCheck = getCheck(readiness, "llmProvider");
+    expect(check.ok).toBe(false);
+    expect(check.detail).toContain("LLM Providers");
+  });
+
+  test("fails repositoryResolved check when nothing resolves", async () => {
+    mockReadiness({ resolution: null });
+
+    const readiness: AIFixReadiness =
+      await TelemetryExceptionService.getAIFixReadiness({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+      });
+
+    expect(readiness.ready).toBe(false);
+    const check: AIFixReadinessCheck = getCheck(
+      readiness,
+      "repositoryResolved",
+    );
+    expect(check.ok).toBe(false);
+    expect(check.detail).toContain("GitHub App");
+  });
+
+  test("resolver failure fails the check with the error surfaced, not a crash", async () => {
+    mockReadiness({ resolutionThrows: new Error("GitHub API rate limited") });
+
+    const readiness: AIFixReadiness =
+      await TelemetryExceptionService.getAIFixReadiness({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+      });
+
+    expect(readiness.ready).toBe(false);
+    const check: AIFixReadinessCheck = getCheck(
+      readiness,
+      "repositoryResolved",
+    );
+    expect(check.ok).toBe(false);
+    expect(check.detail).toContain("GitHub API rate limited");
+  });
+
+  test("fails agent check when the only agent has a stale heartbeat", async () => {
+    mockReadiness({
+      agent: fakeAgent({
+        connectionStatus: AIAgentConnectionStatus.Disconnected,
+        lastAlive: OneUptimeDate.getSomeMinutesAgo(10),
+      }),
+    });
+
+    const readiness: AIFixReadiness =
+      await TelemetryExceptionService.getAIFixReadiness({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+      });
+
+    expect(readiness.ready).toBe(false);
+    const check: AIFixReadinessCheck = getCheck(readiness, "agentAvailable");
+    expect(check.ok).toBe(false);
+    expect(check.detail).toContain("has not reported in");
+  });
+});
+
+/*
+ * The llmProvider check must model PAYABILITY, not just existence: on cloud
+ * a COSTED global provider bills the project's AI balance per completion
+ * (AIService.executeWithLogging), so a zero balance would pass a
+ * presence-only readiness check and then fail the run at its first LLM
+ * call — the exact fail-late mode readiness exists to prevent. Project-owned
+ * and free-global providers consume no balance and must never require one.
+ */
+describe("TelemetryExceptionService.getAIFixReadiness — AI balance gate", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  function costedGlobalProvider(): LlmProvider {
+    return {
+      id: ObjectID.generate(),
+      name: "OneUptime Hosted",
+      isGlobalLlm: true,
+      costPerMillionTokensInUSDCents: 300,
+    } as unknown as LlmProvider;
+  }
+
+  function mockProjectBalance(balanceInUSDCents: number): void {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue({
+      aiCurrentBalanceInUSDCents: balanceInUSDCents,
+    } as unknown as Project);
+  }
+
+  test("cloud + costed global provider + zero balance: fails with recharge guidance", async () => {
+    mockReadiness({ provider: costedGlobalProvider() });
+    mockProjectBalance(0);
+
+    const readiness: AIFixReadiness =
+      await TelemetryExceptionService.getAIFixReadiness({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+        billingEnabled: true,
+      });
+
+    expect(readiness.ready).toBe(false);
+    const check: AIFixReadinessCheck = getCheck(readiness, "llmProvider");
+    expect(check.ok).toBe(false);
+    expect(check.detail).toContain("AI Credits");
+  });
+
+  test("cloud + costed global provider + positive balance: ready", async () => {
+    mockReadiness({ provider: costedGlobalProvider() });
+    mockProjectBalance(500);
+
+    const readiness: AIFixReadiness =
+      await TelemetryExceptionService.getAIFixReadiness({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+        billingEnabled: true,
+      });
+
+    expect(getCheck(readiness, "llmProvider").ok).toBe(true);
+    expect(readiness.ready).toBe(true);
+  });
+
+  test("a FREE global provider needs no balance — the project is never queried", async () => {
+    mockReadiness({
+      provider: {
+        id: ObjectID.generate(),
+        name: "Hosted free",
+        isGlobalLlm: true,
+        costPerMillionTokensInUSDCents: 0,
+      } as unknown as LlmProvider,
+    });
+    const projectSpy: jest.SpiedFunction<typeof ProjectService.findOneById> =
+      jest.spyOn(ProjectService, "findOneById");
+
+    const readiness: AIFixReadiness =
+      await TelemetryExceptionService.getAIFixReadiness({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+        billingEnabled: true,
+      });
+
+    expect(getCheck(readiness, "llmProvider").ok).toBe(true);
+    expect(projectSpy).not.toHaveBeenCalled();
+  });
+
+  test("self-host (billing disabled): a costed global provider needs no balance", async () => {
+    mockReadiness({ provider: costedGlobalProvider() });
+    const projectSpy: jest.SpiedFunction<typeof ProjectService.findOneById> =
+      jest.spyOn(ProjectService, "findOneById");
+
+    const readiness: AIFixReadiness =
+      await TelemetryExceptionService.getAIFixReadiness({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+        billingEnabled: false,
+      });
+
+    expect(getCheck(readiness, "llmProvider").ok).toBe(true);
+    expect(projectSpy).not.toHaveBeenCalled();
+  });
+
+  test("project-owned provider on cloud: no balance requirement", async () => {
+    // The default mockReadiness fixture is a BYO (project-owned) provider.
+    mockReadiness({});
+    const projectSpy: jest.SpiedFunction<typeof ProjectService.findOneById> =
+      jest.spyOn(ProjectService, "findOneById");
+
+    const readiness: AIFixReadiness =
+      await TelemetryExceptionService.getAIFixReadiness({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+        billingEnabled: true,
+      });
+
+    expect(getCheck(readiness, "llmProvider").ok).toBe(true);
+    expect(projectSpy).not.toHaveBeenCalled();
+  });
+});
+
+describe("TelemetryExceptionService.createCodeFixRunForException fail-early", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("rejects with every missing prerequisite named, before any run is created", async () => {
+    mockReadiness({ provider: null, agent: null });
+
+    // The daily fix-run budget has its own suite (FixRunBudget.test.ts).
+    jest.spyOn(FixRunBudget, "assertWithinBudget").mockResolvedValue();
+
+    await expect(
+      TelemetryExceptionService.createCodeFixRunForException({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+      }),
+    ).rejects.toThrow(BadDataException);
+
+    await expect(
+      TelemetryExceptionService.createCodeFixRunForException({
+        telemetryExceptionId: exceptionId,
+        props: { isRoot: true },
+      }),
+    ).rejects.toThrow(
+      /LLM provider.*AI agent online|AI agent online.*LLM provider/,
+    );
+  });
+});
+
+describe("AIAgentService.isAgentAlive", () => {
+  test("alive on Connected status regardless of lastAlive", () => {
+    expect(
+      AIAgentService.isAgentAlive(
+        fakeAgent({ connectionStatus: AIAgentConnectionStatus.Connected }),
+      ),
+    ).toBe(true);
+  });
+
+  test("alive on a heartbeat within five minutes", () => {
+    expect(
+      AIAgentService.isAgentAlive(
+        fakeAgent({ lastAlive: OneUptimeDate.getCurrentDate() }),
+      ),
+    ).toBe(true);
+  });
+
+  test("dead with a stale heartbeat and no Connected status", () => {
+    expect(
+      AIAgentService.isAgentAlive(
+        fakeAgent({ lastAlive: OneUptimeDate.getSomeMinutesAgo(10) }),
+      ),
+    ).toBe(false);
+  });
+
+  test("dead with no heartbeat at all", () => {
+    expect(AIAgentService.isAgentAlive(fakeAgent({}))).toBe(false);
+  });
+});