@oneuptime/common 11.4.1 → 11.5.1

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

@@ -0,0 +1,173 @@
+import AIService, {
+  AUTONOMOUS_AI_FEATURES,
+  AutonomousBudgetStatus,
+} from "../../../Server/Services/AIService";
+import SentinelInvestigationQueue from "../../../Server/Utils/AI/Sentinel/InvestigationQueue";
+import LlmLogService from "../../../Server/Services/LlmLogService";
+import ProjectService from "../../../Server/Services/ProjectService";
+import AIRunService from "../../../Server/Services/AIRunService";
+import Project from "../../../Models/DatabaseModels/Project";
+import ObjectID from "../../../Types/ObjectID";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * G4 daily budget: Project.aiDailyAutonomousTokenLimit bounds the tokens the
+ * AUTONOMOUS_AI_FEATURES may consume per UTC day. The engine skips new
+ * investigations quietly when the budget is exhausted (no Error run created);
+ * AIService.executeWithLogging is the hard backstop mid-run. Interactive chat
+ * is never blocked — its features are not in AUTONOMOUS_AI_FEATURES.
+ *
+ * These tests mock the persistence layer and lock in:
+ *   (a) no limit configured => never exhausted, and no usage query is run;
+ *   (b) usage below the limit => not exhausted;
+ *   (c) usage at/over the limit => exhausted, with the numbers reported;
+ *   (d) the engine skips run creation when the budget is exhausted.
+ */
+
+function fakeProject(limit: number | undefined): Project {
+  return {
+    id: ObjectID.generate(),
+    aiDailyAutonomousTokenLimit: limit,
+  } as unknown as Project;
+}
+
+describe("AIService.getAutonomousDailyBudgetStatus", () => {
+  const projectId: ObjectID = ObjectID.generate();
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("no configured limit means never exhausted and no usage query", async () => {
+    jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue(fakeProject(undefined));
+    const getTokens: jest.SpyInstance = jest.spyOn(
+      LlmLogService,
+      "getTotalTokensUsedSince",
+    );
+
+    const status: AutonomousBudgetStatus =
+      await AIService.getAutonomousDailyBudgetStatus(projectId);
+
+    expect(status.exhausted).toBe(false);
+    expect(status.limitInTokens).toBeNull();
+    expect(getTokens).not.toHaveBeenCalled();
+  });
+
+  test("a limit of 0 pauses autonomous runs without querying usage", async () => {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue(fakeProject(0));
+    const getTokens: jest.SpyInstance = jest.spyOn(
+      LlmLogService,
+      "getTotalTokensUsedSince",
+    );
+
+    const status: AutonomousBudgetStatus =
+      await AIService.getAutonomousDailyBudgetStatus(projectId);
+
+    expect(status.exhausted).toBe(true);
+    expect(status.limitInTokens).toBe(0);
+    expect(getTokens).not.toHaveBeenCalled();
+  });
+
+  test("usage below the limit is not exhausted", async () => {
+    jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue(fakeProject(100_000));
+    jest
+      .spyOn(LlmLogService, "getTotalTokensUsedSince")
+      .mockResolvedValue(99_999);
+
+    const status: AutonomousBudgetStatus =
+      await AIService.getAutonomousDailyBudgetStatus(projectId);
+
+    expect(status.exhausted).toBe(false);
+    expect(status.limitInTokens).toBe(100_000);
+    expect(status.usedTokensToday).toBe(99_999);
+  });
+
+  test("usage at the limit is exhausted, scoped to autonomous features", async () => {
+    jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue(fakeProject(100_000));
+    const getTokens: jest.SpyInstance = jest
+      .spyOn(LlmLogService, "getTotalTokensUsedSince")
+      .mockResolvedValue(100_000);
+
+    const status: AutonomousBudgetStatus =
+      await AIService.getAutonomousDailyBudgetStatus(projectId);
+
+    expect(status.exhausted).toBe(true);
+    expect(getTokens).toHaveBeenCalledWith(
+      expect.objectContaining({
+        features: AUTONOMOUS_AI_FEATURES,
+      }),
+    );
+  });
+});
+
+describe("SentinelInvestigationQueue budget skip", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("does not enqueue when the daily budget is exhausted", async () => {
+    jest.spyOn(AIService, "getAutonomousDailyBudgetStatus").mockResolvedValue({
+      exhausted: true,
+      limitInTokens: 100_000,
+      usedTokensToday: 120_000,
+    });
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await SentinelInvestigationQueue.enqueue({
+      projectId: ObjectID.generate(),
+      subjectAlertId: ObjectID.generate(),
+    });
+
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("does not enqueue when the budget check itself fails", async () => {
+    jest
+      .spyOn(AIService, "getAutonomousDailyBudgetStatus")
+      .mockRejectedValue(new Error("db down"));
+    const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
+
+    await SentinelInvestigationQueue.enqueue({
+      projectId: ObjectID.generate(),
+      subjectAlertId: ObjectID.generate(),
+    });
+
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  test("leaves a queued run unclaimed when the budget is exhausted at claim time", async () => {
+    // No per-project cap override; concurrency cap passes…
+    jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue(fakeProject(undefined));
+    jest
+      .spyOn(AIRunService, "countBy")
+      .mockResolvedValue(new PositiveNumber(0));
+    // …but the budget is exhausted.
+    jest.spyOn(AIService, "getAutonomousDailyBudgetStatus").mockResolvedValue({
+      exhausted: true,
+      limitInTokens: 100_000,
+      usedTokensToday: 120_000,
+    });
+    const claim: jest.SpyInstance = jest.spyOn(
+      AIRunService,
+      "attemptStatusTransition",
+    );
+
+    await SentinelInvestigationQueue.processRun({
+      id: ObjectID.generate(),
+      projectId: ObjectID.generate(),
+      attemptCount: 0,
+      triggeredByAlertId: ObjectID.generate(),
+    });
+
+    expect(claim).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,97 @@
+import IncidentInternalNoteService from "../../../Server/Services/IncidentInternalNoteService";
+import IncidentFeedService from "../../../Server/Services/IncidentFeedService";
+import IncidentService from "../../../Server/Services/IncidentService";
+import Model from "../../../Models/DatabaseModels/IncidentInternalNote";
+import ObjectID from "../../../Types/ObjectID";
+import URL from "../../../Types/API/URL";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * IncidentInternalNoteService.onCreateSuccess announces every new note with a
+ * "posted private note" feed item + workspace ping — INCLUDING user-less
+ * system notes: the SLA note-reminder job (SendNoteReminders.ts) creates notes
+ * with no createdByUserId and relies entirely on this hook for its feed entry
+ * and Slack/Teams ping (it sets isOwnerNotified itself, so the hook is its
+ * only push channel).
+ *
+ * Callers that must NOT announce (Sentinel's RCA note, which has its own
+ * quiet-mode-gated RootCause feed item) opt out explicitly with
+ * props.ignoreHooks — see IncidentInvestigationRunner. These tests lock in
+ * that the hook announces for both user-authored and user-less notes, so the
+ * SLA flow can't be silenced again by a "system notes are quiet" shortcut.
+ */
+
+function fakeNote(userId?: ObjectID | undefined): Model {
+  return {
+    id: ObjectID.generate(),
+    incidentId: ObjectID.generate(),
+    projectId: ObjectID.generate(),
+    note: "test note",
+    createdByUserId: userId,
+    createdByUser: undefined,
+  } as unknown as Model;
+}
+
+describe("IncidentInternalNoteService.onCreateSuccess", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  function mockAnnouncementDeps(): jest.SpyInstance {
+    const createFeedItem: jest.SpyInstance = jest
+      .spyOn(IncidentFeedService, "createIncidentFeedItem")
+      .mockResolvedValue(undefined as never);
+    jest.spyOn(IncidentService, "getIncidentNumber").mockResolvedValue({
+      number: 42,
+      numberWithPrefix: "INC-42",
+    });
+    jest
+      .spyOn(IncidentService, "getIncidentLinkInDashboard")
+      .mockResolvedValue(URL.fromString("https://oneuptime.example/incident"));
+    // No attachments on these notes.
+    jest
+      .spyOn(IncidentInternalNoteService, "findOneById")
+      .mockResolvedValue(null);
+    return createFeedItem;
+  }
+
+  test("user-authored note announces with a feed item attributed to the user", async () => {
+    const createFeedItem: jest.SpyInstance = mockAnnouncementDeps();
+    const userId: ObjectID = ObjectID.generate();
+    const note: Model = fakeNote(userId);
+
+    await IncidentInternalNoteService.onCreateSuccess(
+      { createBy: { data: note, props: { isRoot: true } }, carryForward: null },
+      note,
+    );
+
+    expect(createFeedItem).toHaveBeenCalledTimes(1);
+    expect(createFeedItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        userId,
+        workspaceNotification: expect.objectContaining({
+          sendWorkspaceNotification: true,
+        }),
+      }),
+    );
+  });
+
+  test("user-less system note (e.g. SLA reminder) still announces", async () => {
+    const createFeedItem: jest.SpyInstance = mockAnnouncementDeps();
+    const note: Model = fakeNote(undefined);
+
+    await IncidentInternalNoteService.onCreateSuccess(
+      { createBy: { data: note, props: { isRoot: true } }, carryForward: null },
+      note,
+    );
+
+    expect(createFeedItem).toHaveBeenCalledTimes(1);
+    expect(createFeedItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workspaceNotification: expect.objectContaining({
+          sendWorkspaceNotification: true,
+        }),
+      }),
+    );
+  });
+});

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

@@ -278,3 +278,57 @@ describe("IoTDeviceService.bulkUpdateLatestMetrics — sanitation matches the up
     expect(params).not.toContain(10);
   });
 });
+
+describe("IoTDeviceService.deleteStaleForFleet — registered devices survive", () => {
+  const CUTOFF: Date = new Date("2026-06-13T00:00:00.000Z");
+
+  test("marks registered devices offline and deletes only unregistered ones", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    query
+      .mockResolvedValueOnce([[], 2]) // UPDATE (registered -> isUp=false)
+      .mockResolvedValueOnce([[], 5]); // DELETE (unregistered)
+
+    const result: { deleted: number; markedOffline: number } =
+      await IoTDeviceService.deleteStaleForFleet({
+        iotFleetId: FLEET_ID,
+        olderThan: CUTOFF,
+      });
+
+    expect(query).toHaveBeenCalledTimes(2);
+
+    const [updateSql, updateParams] = query.mock.calls[0] as QueryCall;
+    expect(updateSql).toContain('UPDATE "IoTDevice" SET "isUp" = false');
+    // Registered = credential on the same project + fleet + externalId.
+    expect(updateSql).toContain('EXISTS (SELECT 1 FROM "IoTDeviceCredential"');
+    expect(updateSql).toContain('c."externalId" = "IoTDevice"."externalId"');
+    expect(updateSql).toContain('c."projectId" = "IoTDevice"."projectId"');
+    // The credential correlation itself is kind-agnostic.
+    expect(updateSql).not.toContain('c."kind"');
+    // Reconnect recovery depends on lastSeenAt staying untouched.
+    expect(updateSql).not.toContain('"lastSeenAt" =');
+    // Idempotent across cron ticks: already-down rows are not rewritten.
+    expect(updateSql).toContain('"isUp" IS DISTINCT FROM false');
+    // Stale duplicate-kind rows self-heal instead of being pinned offline.
+    expect(updateSql).toContain("NOT EXISTS");
+    expect(updateParams).toEqual([FLEET_ID.toString(), CUTOFF]);
+
+    const [deleteSql, deleteParams] = query.mock.calls[1] as QueryCall;
+    expect(deleteSql).toContain('DELETE FROM "IoTDevice"');
+    expect(deleteSql).toContain("NOT EXISTS");
+    expect(deleteParams).toEqual([FLEET_ID.toString(), CUTOFF]);
+
+    expect(result).toEqual({ deleted: 5, markedOffline: 2 });
+  });
+
+  test("normalizes a driver result without an affected count to zero", async () => {
+    mockQueryRunner([]);
+
+    const result: { deleted: number; markedOffline: number } =
+      await IoTDeviceService.deleteStaleForFleet({
+        iotFleetId: FLEET_ID,
+        olderThan: CUTOFF,
+      });
+
+    expect(result).toEqual({ deleted: 0, markedOffline: 0 });
+  });
+});

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

@@ -0,0 +1,253 @@
+import { BaselineAnomalyTool } from "../../../../Server/Utils/AI/Toolbox/MetricTools";
+import { ToolContext } from "../../../../Server/Utils/AI/Toolbox/ToolTypes";
+import MetricBaselineService from "../../../../Server/Services/MetricBaselineService";
+import MetricService from "../../../../Server/Services/MetricService";
+import ModelPermission from "../../../../Server/Types/AnalyticsDatabase/ModelPermission";
+import ObjectID from "../../../../Types/ObjectID";
+import AggregatedResult from "../../../../Types/BaseDatabase/AggregatedResult";
+import { describe, expect, test, afterEach, beforeEach } from "@jest/globals";
+
+/*
+ * baseline_anomaly judges a metric's recent average against its learned
+ * hour-of-week baseline band (mean ± sigma·stddev — the same math the anomaly
+ * monitors use via sigmaForSensitivity). These tests mock the baseline and
+ * metric services (no ClickHouse) to lock in:
+ *   (a) missing/unreliable baselines report "insufficient baseline data" and
+ *       never render a normal/anomalous verdict (a missing baseline must not
+ *       read as "not anomalous");
+ *   (b) above-band / below-band / within-band classification at Medium (3σ);
+ *   (c) a metric with no recent data points is flagged as possibly having
+ *       stopped reporting, not judged normal;
+ *   (d) a zero-stddev baseline still classifies (band collapses to the mean).
+ */
+
+const ctx: ToolContext = {
+  projectId: ObjectID.generate(),
+  props: { isRoot: true },
+};
+
+function mockBaseline(data: {
+  mean: number;
+  stddev: number;
+  sampleCount?: number;
+  isReliable?: boolean;
+}): void {
+  jest.spyOn(MetricBaselineService, "getBaseline").mockResolvedValue({
+    sampleCount: data.sampleCount ?? 50,
+    mean: data.mean,
+    stddev: data.stddev,
+    median: data.mean,
+    p95: data.mean + 2 * data.stddev,
+    minObserved: data.mean - 3 * data.stddev,
+    maxObserved: data.mean + 3 * data.stddev,
+    isReliable: data.isReliable ?? true,
+    windowDays: 14,
+    hourOfWeek: 10,
+  });
+}
+
+function mockCurrentValues(values: Array<number>): void {
+  jest.spyOn(MetricService, "aggregateBy").mockResolvedValue({
+    data: values.map((value: number) => {
+      return { timestamp: new Date(), value };
+    }),
+  } as unknown as AggregatedResult);
+}
+
+function mockEmptyBand(): void {
+  jest.spyOn(MetricBaselineService, "getBandSeries").mockResolvedValue([]);
+}
+
+describe("BaselineAnomalyTool", () => {
+  beforeEach(() => {
+    // Default: project-wide telemetry access (null = unrestricted).
+    jest
+      .spyOn(ModelPermission, "getAccessibleServiceIdsForAnalyticsModel")
+      .mockResolvedValue(null);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("requires metricName", async () => {
+    await expect(BaselineAnomalyTool.execute({}, ctx)).rejects.toThrow(
+      "metricName is required",
+    );
+  });
+
+  test("rejects an unparseable atTime", async () => {
+    await expect(
+      BaselineAnomalyTool.execute(
+        { metricName: "cpu.usage", atTime: "yesterday-ish" },
+        ctx,
+      ),
+    ).rejects.toThrow("not a valid ISO 8601 timestamp");
+  });
+
+  test("no baseline reports insufficient data and never queries the metric", async () => {
+    jest.spyOn(MetricBaselineService, "getBaseline").mockResolvedValue(null);
+    jest.spyOn(MetricBaselineService, "getCoverage").mockResolvedValue({
+      totalSamples: 3,
+      oldestDay: new Date(),
+    });
+    const aggregateBy: jest.SpyInstance = jest.spyOn(
+      MetricService,
+      "aggregateBy",
+    );
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("insufficient baseline data");
+    expect(result.dataForLlm).not.toContain("ANOMALOUS");
+    expect(aggregateBy).not.toHaveBeenCalled();
+  });
+
+  test("unreliable baseline (too few samples) also reports insufficient data", async () => {
+    mockBaseline({ mean: 100, stddev: 10, sampleCount: 2, isReliable: false });
+    jest.spyOn(MetricBaselineService, "getCoverage").mockResolvedValue({
+      totalSamples: 2,
+      oldestDay: null,
+    });
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("insufficient baseline data");
+    expect(result.dataForLlm).toContain("only 2 sample(s)");
+  });
+
+  test("value above the 3-sigma band is anomalous (above)", async () => {
+    mockBaseline({ mean: 100, stddev: 10 });
+    mockCurrentValues([150]);
+    mockEmptyBand();
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("ANOMALOUS — above");
+  });
+
+  test("value below the 3-sigma band is anomalous (below)", async () => {
+    mockBaseline({ mean: 100, stddev: 10 });
+    mockCurrentValues([30]);
+    mockEmptyBand();
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("ANOMALOUS — below");
+  });
+
+  test("value inside the band is normal", async () => {
+    mockBaseline({ mean: 100, stddev: 10 });
+    mockCurrentValues([120]);
+    mockEmptyBand();
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("normal — within the expected range");
+  });
+
+  test("High sensitivity (2 sigma) flags what Medium would call normal", async () => {
+    mockBaseline({ mean: 100, stddev: 10 });
+    mockCurrentValues([125]); // z = 2.5: inside 3σ, outside 2σ
+    mockEmptyBand();
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage", sensitivity: "High" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("ANOMALOUS — above");
+  });
+
+  test("no recent data points is flagged as possibly stopped reporting", async () => {
+    mockBaseline({ mean: 100, stddev: 10 });
+    mockCurrentValues([]);
+    mockEmptyBand();
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("STOPPED reporting");
+    expect(result.dataForLlm).not.toContain("normal — within");
+  });
+
+  test("zero-stddev baseline refuses to classify, matching the anomaly monitors", async () => {
+    mockBaseline({ mean: 100, stddev: 0 });
+    mockCurrentValues([101]);
+    mockEmptyBand();
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("cannot judge");
+    expect(result.dataForLlm).toContain("zero variance");
+    expect(result.dataForLlm).not.toContain("ANOMALOUS");
+  });
+
+  test("a label-scoped user without entityId is refused (baseline SQL skips the owned-scope filter)", async () => {
+    jest
+      .spyOn(ModelPermission, "getAccessibleServiceIdsForAnalyticsModel")
+      .mockResolvedValue([ObjectID.generate()]);
+    const getBaseline: jest.SpyInstance = jest.spyOn(
+      MetricBaselineService,
+      "getBaseline",
+    );
+
+    await expect(
+      BaselineAnomalyTool.execute({ metricName: "cpu.usage" }, ctx),
+    ).rejects.toThrow("scoped to specific services");
+    expect(getBaseline).not.toHaveBeenCalled();
+  });
+
+  test("a label-scoped user asking about another service's entity is refused", async () => {
+    jest
+      .spyOn(ModelPermission, "getAccessibleServiceIdsForAnalyticsModel")
+      .mockResolvedValue([ObjectID.generate()]);
+
+    await expect(
+      BaselineAnomalyTool.execute(
+        {
+          metricName: "cpu.usage",
+          entityId: ObjectID.generate().toString(),
+        },
+        ctx,
+      ),
+    ).rejects.toThrow("scoped to specific services");
+  });
+
+  test("a label-scoped user pinned to their own service proceeds", async () => {
+    const ownServiceId: ObjectID = ObjectID.generate();
+    jest
+      .spyOn(ModelPermission, "getAccessibleServiceIdsForAnalyticsModel")
+      .mockResolvedValue([ownServiceId]);
+    mockBaseline({ mean: 100, stddev: 10 });
+    mockCurrentValues([120]);
+    mockEmptyBand();
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage", entityId: ownServiceId.toString() },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("normal — within the expected range");
+  });
+});

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

@@ -384,3 +384,47 @@ describe("LLMService — prompt caching", () => {
     expect(response.usage!.totalTokens).toBe(55);
   });
 });
+
+describe("LLMService — additionalParams (per-provider overrides)", () => {
+  test("merges provider additionalParams into the request body", async () => {
+    const spy: PostSpy = mockPostResponse({
+      choices: [{ message: { content: "OK" } }],
+    });
+
+    await LLMService.getCompletion({
+      llmProviderConfig: { llmType: LlmType.OpenAI, apiKey: "test-key" },
+      messages: [{ role: "user", content: "hi" }],
+      maxTokens: 1024,
+      additionalParams: { temperature: 0.2, top_p: 0.9 },
+    });
+
+    const requestBody: JSONObject = (
+      spy.mock.calls[0]![0] as { data: JSONObject }
+    ).data;
+    // additionalParams override defaults and are added to the body...
+    expect(requestBody["temperature"]).toBe(0.2);
+    expect(requestBody["top_p"]).toBe(0.9);
+    // ...while leaving the default max_tokens intact for legacy providers.
+    expect(requestBody["max_tokens"]).toBe(1024);
+  });
+
+  test("max_completion_tokens in additionalParams drops the legacy max_tokens", async () => {
+    const spy: PostSpy = mockPostResponse({
+      choices: [{ message: { content: "OK" } }],
+    });
+
+    await LLMService.getCompletion({
+      llmProviderConfig: { llmType: LlmType.OpenAI, apiKey: "test-key" },
+      messages: [{ role: "user", content: "hi" }],
+      maxTokens: 1024,
+      // gpt-5 / o1 / o3 reject max_tokens and require max_completion_tokens.
+      additionalParams: { max_completion_tokens: 2048 },
+    });
+
+    const requestBody: JSONObject = (
+      spy.mock.calls[0]![0] as { data: JSONObject }
+    ).data;
+    expect(requestBody["max_completion_tokens"]).toBe(2048);
+    expect(requestBody["max_tokens"]).toBeUndefined();
+  });
+});