@oneuptime/common 12.0.0 → 12.0.1

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

@@ -0,0 +1,293 @@
+import LlmProviderService from "../../../Server/Services/LlmProviderService";
+import LlmProvider from "../../../Models/DatabaseModels/LlmProvider";
+import ObjectID from "../../../Types/ObjectID";
+import Select from "../../../Server/Types/Database/Select";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * isProviderUsableByProject answers "may this project run against this
+ * provider id?" for callers that hold a caller-supplied id — today the
+ * runbook AI step's optional provider pin, whose id comes out of an
+ * unvalidated JSON column.
+ *
+ * The invariant: a project may use a global provider or one it owns, and
+ * nothing else. A provider carries an apiKey, so a yes here for another
+ * project's row would hand project A the use of project B's key.
+ */
+
+const projectId: ObjectID = ObjectID.generate();
+const otherProjectId: ObjectID = ObjectID.generate();
+const providerId: ObjectID = ObjectID.generate();
+
+function fakeProvider(overrides: Partial<LlmProvider> = {}): LlmProvider {
+  return {
+    id: providerId,
+    ...overrides,
+  } as unknown as LlmProvider;
+}
+
+describe("LlmProviderService.isProviderUsableByProject", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("accepts a provider the project owns", async () => {
+    jest
+      .spyOn(LlmProviderService, "findOneBy")
+      .mockResolvedValue(fakeProvider({ projectId, isGlobalLlm: false }));
+
+    await expect(
+      LlmProviderService.isProviderUsableByProject({
+        projectId,
+        llmProviderId: providerId,
+      }),
+    ).resolves.toBe(true);
+  });
+
+  test("accepts a global provider, which is shared with every project", async () => {
+    jest
+      .spyOn(LlmProviderService, "findOneBy")
+      .mockResolvedValue(fakeProvider({ isGlobalLlm: true }));
+
+    await expect(
+      LlmProviderService.isProviderUsableByProject({
+        projectId,
+        llmProviderId: providerId,
+      }),
+    ).resolves.toBe(true);
+  });
+
+  test("rejects a provider owned by a different project", async () => {
+    jest.spyOn(LlmProviderService, "findOneBy").mockResolvedValue(
+      fakeProvider({
+        projectId: otherProjectId,
+        isGlobalLlm: false,
+      }),
+    );
+
+    await expect(
+      LlmProviderService.isProviderUsableByProject({
+        projectId,
+        llmProviderId: providerId,
+      }),
+    ).resolves.toBe(false);
+  });
+
+  test("rejects a provider that no longer exists", async () => {
+    jest.spyOn(LlmProviderService, "findOneBy").mockResolvedValue(null);
+
+    await expect(
+      LlmProviderService.isProviderUsableByProject({
+        projectId,
+        llmProviderId: providerId,
+      }),
+    ).resolves.toBe(false);
+  });
+
+  test("rejects a provider with no owner and no global flag", async () => {
+    /*
+     * A row that is neither global nor owned matches nobody. Treating an
+     * absent projectId as a match would make an orphaned row usable by every
+     * project at once.
+     */
+    jest
+      .spyOn(LlmProviderService, "findOneBy")
+      .mockResolvedValue(fakeProvider({ isGlobalLlm: false }));
+
+    await expect(
+      LlmProviderService.isProviderUsableByProject({
+        projectId,
+        llmProviderId: providerId,
+      }),
+    ).resolves.toBe(false);
+  });
+
+  test("rejects a non-uuid id without ever touching the database", async () => {
+    /*
+     * _id is a uuid column: querying it with garbage is a Postgres cast
+     * error, not an empty result. The id arrives from an unvalidated JSON
+     * config, so the shape check has to happen before the query — otherwise
+     * a typo in a runbook surfaces as a driver error during an incident.
+     */
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest.spyOn(LlmProviderService, "findOneBy");
+
+    await expect(
+      LlmProviderService.isProviderUsableByProject({
+        projectId,
+        llmProviderId: new ObjectID("not-a-uuid"),
+      }),
+    ).resolves.toBe(false);
+
+    expect(findSpy).not.toHaveBeenCalled();
+  });
+
+  test("rejects an empty id without touching the database", async () => {
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest.spyOn(LlmProviderService, "findOneBy");
+
+    await expect(
+      LlmProviderService.isProviderUsableByProject({
+        projectId,
+        llmProviderId: new ObjectID(""),
+      }),
+    ).resolves.toBe(false);
+
+    expect(findSpy).not.toHaveBeenCalled();
+  });
+
+  test("never selects the apiKey — a yes/no must not load secrets", async () => {
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest
+        .spyOn(LlmProviderService, "findOneBy")
+        .mockResolvedValue(fakeProvider({ projectId }));
+
+    await LlmProviderService.isProviderUsableByProject({
+      projectId,
+      llmProviderId: providerId,
+    });
+
+    const select: Select<LlmProvider> = findSpy.mock.calls[0]![0]!
+      .select as Select<LlmProvider>;
+    expect(select["apiKey"]).toBeUndefined();
+    expect(select["projectId"]).toBe(true);
+    expect(select["isGlobalLlm"]).toBe(true);
+  });
+
+  test("looks the provider up by id alone, so a global row is reachable", async () => {
+    /*
+     * Scoping the query by projectId would silently exclude global
+     * providers (their projectId is NULL) — the tenant decision belongs in
+     * the check on the loaded row, not in the query.
+     */
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest
+        .spyOn(LlmProviderService, "findOneBy")
+        .mockResolvedValue(fakeProvider({ isGlobalLlm: true }));
+
+    await LlmProviderService.isProviderUsableByProject({
+      projectId,
+      llmProviderId: providerId,
+    });
+
+    const query: Record<string, unknown> = findSpy.mock.calls[0]![0]!
+      .query as Record<string, unknown>;
+    expect(query["_id"]).toBe(providerId.toString());
+    expect(query["projectId"]).toBeUndefined();
+  });
+});
+
+/*
+ * getProviderForChat shares the same usability predicate. Its contract is the
+ * opposite of the runbook step's on failure — a human is watching a chat, so
+ * an unusable id falls back to the default instead of erroring — and these
+ * tests pin that difference down so a future refactor of the shared predicate
+ * cannot quietly swap one behaviour for the other.
+ */
+describe("LlmProviderService.getProviderForChat", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("uses an explicitly chosen provider the project owns", async () => {
+    const chosen: LlmProvider = fakeProvider({ projectId });
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest.spyOn(LlmProviderService, "findOneBy").mockResolvedValue(chosen);
+
+    const result: LlmProvider | null =
+      await LlmProviderService.getProviderForChat({
+        projectId,
+        llmProviderId: providerId,
+      });
+
+    expect(result).toBe(chosen);
+    expect(findSpy).toHaveBeenCalledTimes(1);
+  });
+
+  test("uses an explicitly chosen global provider", async () => {
+    const chosen: LlmProvider = fakeProvider({ isGlobalLlm: true });
+    jest.spyOn(LlmProviderService, "findOneBy").mockResolvedValue(chosen);
+
+    await expect(
+      LlmProviderService.getProviderForChat({
+        projectId,
+        llmProviderId: providerId,
+      }),
+    ).resolves.toBe(chosen);
+  });
+
+  test("falls back to the project default when the chosen provider belongs to another project", async () => {
+    const foreign: LlmProvider = fakeProvider({ projectId: otherProjectId });
+    const projectDefault: LlmProvider = fakeProvider({ projectId });
+    jest
+      .spyOn(LlmProviderService, "findOneBy")
+      .mockResolvedValueOnce(foreign)
+      .mockResolvedValueOnce(projectDefault);
+
+    const result: LlmProvider | null =
+      await LlmProviderService.getProviderForChat({
+        projectId,
+        llmProviderId: providerId,
+      });
+
+    expect(result).toBe(projectDefault);
+  });
+
+  test("falls back when the chosen provider no longer exists", async () => {
+    const projectDefault: LlmProvider = fakeProvider({ projectId });
+    jest
+      .spyOn(LlmProviderService, "findOneBy")
+      .mockResolvedValueOnce(null)
+      .mockResolvedValueOnce(projectDefault);
+
+    await expect(
+      LlmProviderService.getProviderForChat({
+        projectId,
+        llmProviderId: providerId,
+      }),
+    ).resolves.toBe(projectDefault);
+  });
+
+  test("a non-uuid choice falls back instead of hitting the database with it", async () => {
+    /*
+     * Without the shape check this query is a Postgres cast error rather
+     * than a miss, so a stale or hand-edited id would break a whole
+     * conversation instead of quietly resolving to the default.
+     */
+    const projectDefault: LlmProvider = fakeProvider({ projectId });
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest
+        .spyOn(LlmProviderService, "findOneBy")
+        .mockResolvedValue(projectDefault);
+
+    const result: LlmProvider | null =
+      await LlmProviderService.getProviderForChat({
+        projectId,
+        llmProviderId: new ObjectID("not-a-uuid"),
+      });
+
+    expect(result).toBe(projectDefault);
+    // Only the default-resolution query ran — never one keyed on the garbage id.
+    for (const call of findSpy.mock.calls) {
+      expect(
+        (call[0]!.query as Record<string, unknown>)["_id"],
+      ).toBeUndefined();
+    }
+  });
+
+  test("with no choice at all it goes straight to default resolution", async () => {
+    const projectDefault: LlmProvider = fakeProvider({ projectId });
+    const findSpy: jest.SpiedFunction<typeof LlmProviderService.findOneBy> =
+      jest
+        .spyOn(LlmProviderService, "findOneBy")
+        .mockResolvedValue(projectDefault);
+
+    await expect(
+      LlmProviderService.getProviderForChat({ projectId }),
+    ).resolves.toBe(projectDefault);
+
+    const query: Record<string, unknown> = findSpy.mock.calls[0]![0]!
+      .query as Record<string, unknown>;
+    expect(query["isDefault"]).toBe(true);
+  });
+});

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

@@ -0,0 +1,141 @@
+import { ToolArgs } from "../../../../Server/Utils/AI/Toolbox/ToolTypes";
+import { JSONObject } from "../../../../Types/JSON";
+import ObjectID from "../../../../Types/ObjectID";
+
+/*
+ * ToolArgs.scopeServiceIds and getTimeRange already have dedicated suites.
+ * This covers the remaining argument extractors — the coercion, trimming,
+ * clamping and defaulting rules the AI toolbox relies on to turn loosely-typed
+ * model-supplied JSON arguments into safe, typed values.
+ */
+
+describe("ToolArgs extractors", () => {
+  describe("getString", () => {
+    test("trims and returns a non-empty string", () => {
+      expect(ToolArgs.getString({ q: "  hello  " }, "q")).toBe("hello");
+    });
+
+    test("returns undefined for empty or whitespace-only strings", () => {
+      expect(ToolArgs.getString({ q: "" }, "q")).toBeUndefined();
+      expect(ToolArgs.getString({ q: "   " }, "q")).toBeUndefined();
+    });
+
+    test("returns undefined for missing keys and non-string values", () => {
+      expect(ToolArgs.getString({}, "q")).toBeUndefined();
+      expect(ToolArgs.getString({ q: 5 }, "q")).toBeUndefined();
+      expect(ToolArgs.getString({ q: null }, "q")).toBeUndefined();
+      expect(ToolArgs.getString({ q: ["a"] }, "q")).toBeUndefined();
+    });
+  });
+
+  describe("getStringArray", () => {
+    test("keeps only non-empty strings, trimming them", () => {
+      expect(
+        ToolArgs.getStringArray({ ids: ["a", " b ", "", "  ", "c"] }, "ids"),
+      ).toEqual(["a", " b ", "c"]);
+    });
+
+    test("filters out non-string members", () => {
+      expect(
+        ToolArgs.getStringArray(
+          { ids: ["a", 1, true, null, "b"] as unknown as Array<string> },
+          "ids",
+        ),
+      ).toEqual(["a", "b"]);
+    });
+
+    test("returns undefined when nothing survives filtering", () => {
+      expect(
+        ToolArgs.getStringArray({ ids: ["", "   "] }, "ids"),
+      ).toBeUndefined();
+      expect(ToolArgs.getStringArray({ ids: [] }, "ids")).toBeUndefined();
+    });
+
+    test("returns undefined for a non-array value", () => {
+      expect(ToolArgs.getStringArray({ ids: "a,b" }, "ids")).toBeUndefined();
+      expect(ToolArgs.getStringArray({}, "ids")).toBeUndefined();
+    });
+  });
+
+  describe("getNumber", () => {
+    const options: { defaultValue: number; min: number; max: number } = {
+      defaultValue: 10,
+      min: 1,
+      max: 100,
+    };
+
+    test("passes finite numbers through, flooring fractionals", () => {
+      expect(ToolArgs.getNumber({ n: 5 }, "n", options)).toBe(5);
+      expect(ToolArgs.getNumber({ n: 5.9 }, "n", options)).toBe(5);
+    });
+
+    test("parses numeric strings", () => {
+      expect(ToolArgs.getNumber({ n: "7" }, "n", options)).toBe(7);
+      expect(ToolArgs.getNumber({ n: "7.8" }, "n", options)).toBe(7);
+    });
+
+    test("clamps to the configured min and max", () => {
+      expect(ToolArgs.getNumber({ n: 1000 }, "n", options)).toBe(100);
+      expect(ToolArgs.getNumber({ n: -5 }, "n", options)).toBe(1);
+    });
+
+    test("falls back to the default for missing or invalid values", () => {
+      expect(ToolArgs.getNumber({}, "n", options)).toBe(10);
+      expect(ToolArgs.getNumber({ n: "abc" }, "n", options)).toBe(10);
+      expect(ToolArgs.getNumber({ n: NaN }, "n", options)).toBe(10);
+      expect(ToolArgs.getNumber({ n: Infinity }, "n", options)).toBe(10);
+      expect(ToolArgs.getNumber({ n: "" }, "n", options)).toBe(10);
+    });
+
+    test("still clamps the default value itself", () => {
+      // Default below min is raised to min; default above max lowered to max.
+      expect(
+        ToolArgs.getNumber({}, "n", { defaultValue: 0, min: 5, max: 100 }),
+      ).toBe(5);
+    });
+  });
+
+  describe("getBoolean", () => {
+    test("returns real booleans as-is", () => {
+      expect(ToolArgs.getBoolean({ b: true }, "b")).toBe(true);
+      expect(ToolArgs.getBoolean({ b: false }, "b")).toBe(false);
+    });
+
+    test("coerces the strings 'true' and 'false'", () => {
+      expect(ToolArgs.getBoolean({ b: "true" }, "b")).toBe(true);
+      expect(ToolArgs.getBoolean({ b: "false" }, "b")).toBe(false);
+    });
+
+    test("returns undefined for anything else", () => {
+      expect(ToolArgs.getBoolean({ b: "TRUE" }, "b")).toBeUndefined();
+      expect(ToolArgs.getBoolean({ b: 1 }, "b")).toBeUndefined();
+      expect(ToolArgs.getBoolean({ b: "yes" }, "b")).toBeUndefined();
+      expect(ToolArgs.getBoolean({}, "b")).toBeUndefined();
+    });
+  });
+
+  describe("getObjectID", () => {
+    test("wraps a non-empty string as an ObjectID", () => {
+      const id: ObjectID | undefined = ToolArgs.getObjectID(
+        { serviceId: "  abc123  " },
+        "serviceId",
+      );
+      expect(id).toBeInstanceOf(ObjectID);
+      // getString trims first, so the ObjectID carries the trimmed value.
+      expect(id?.toString()).toBe("abc123");
+    });
+
+    test("returns undefined for missing or empty values", () => {
+      expect(ToolArgs.getObjectID({}, "serviceId")).toBeUndefined();
+      expect(
+        ToolArgs.getObjectID({ serviceId: "   " }, "serviceId"),
+      ).toBeUndefined();
+      expect(
+        ToolArgs.getObjectID(
+          { serviceId: 5 as unknown as string } as JSONObject,
+          "serviceId",
+        ),
+      ).toBeUndefined();
+    });
+  });
+});

package/Tests/Server/Utils/AI/Toolbox/WidgetBuilder.test.ts

@@ -0,0 +1,205 @@
+import WidgetBuilder from "../../../../../Server/Utils/AI/Toolbox/WidgetBuilder";
+import { JSONObject } from "../../../../../Types/JSON";
+import {
+  AIChatCitationTarget,
+  AIChatWidget,
+  AIChatWidgetColumn,
+  AIChatWidgetSeries,
+  AIChatWidgetSpan,
+  AIChatWidgetStat,
+  AIChatWidgetType,
+} from "../../../../../Types/AI/AIChatTypes";
+
+/*
+ * WidgetBuilder is the factory the AI toolbox uses to attach inline widgets to
+ * a tool result. The shapes it produces are a contract with the frontend
+ * renderer, so this pins down the widget type, the data envelope, the defaults
+ * (bars.stacked / bars.xIsTime), and the invariant that id/citationId are left
+ * blank for ChatAgentRunner to mint.
+ */
+
+const link: AIChatCitationTarget = {
+  // A minimal citation target; only its presence is asserted below.
+} as AIChatCitationTarget;
+
+describe("WidgetBuilder", () => {
+  test("table() builds a Table widget carrying columns and rows", () => {
+    const columns: Array<AIChatWidgetColumn> = [
+      { key: "name", title: "Name" } as AIChatWidgetColumn,
+    ];
+    const rows: Array<JSONObject> = [{ name: "api" }, { name: "worker" }];
+
+    const widget: AIChatWidget = WidgetBuilder.table({
+      title: "Services",
+      description: "All services",
+      columns,
+      rows,
+      link,
+    });
+
+    expect(widget.type).toBe(AIChatWidgetType.Table);
+    expect(widget.title).toBe("Services");
+    expect(widget.description).toBe("All services");
+    expect(widget.id).toBe("");
+    expect((widget.data as JSONObject)["columns"]).toBe(columns);
+    expect((widget.data as JSONObject)["rows"]).toBe(rows);
+    expect((widget.data as JSONObject)["link"]).toBe(link);
+  });
+
+  test("timeSeries() hardcodes xIsTime to true", () => {
+    const series: Array<AIChatWidgetSeries> = [
+      { name: "cpu", points: [] } as unknown as AIChatWidgetSeries,
+    ];
+
+    const widget: AIChatWidget = WidgetBuilder.timeSeries({
+      title: "CPU over time",
+      series,
+      unit: "%",
+      valueLabel: "CPU",
+    });
+
+    expect(widget.type).toBe(AIChatWidgetType.TimeSeriesChart);
+    const data: JSONObject = widget.data as JSONObject;
+    expect(data["xIsTime"]).toBe(true);
+    expect(data["unit"]).toBe("%");
+    expect(data["valueLabel"]).toBe("CPU");
+    expect(data["series"]).toBe(series);
+  });
+
+  test("bars() defaults stacked and xIsTime to false", () => {
+    const series: Array<AIChatWidgetSeries> = [
+      { name: "logs", points: [] } as unknown as AIChatWidgetSeries,
+    ];
+
+    const widget: AIChatWidget = WidgetBuilder.bars({
+      title: "Log volume",
+      series,
+    });
+
+    expect(widget.type).toBe(AIChatWidgetType.BarChart);
+    const data: JSONObject = widget.data as JSONObject;
+    expect(data["stacked"]).toBe(false);
+    expect(data["xIsTime"]).toBe(false);
+  });
+
+  test("bars() honors explicit stacked and xIsTime flags", () => {
+    const widget: AIChatWidget = WidgetBuilder.bars({
+      title: "Log volume by severity",
+      series: [],
+      stacked: true,
+      xIsTime: true,
+    });
+
+    const data: JSONObject = widget.data as JSONObject;
+    expect(data["stacked"]).toBe(true);
+    expect(data["xIsTime"]).toBe(true);
+  });
+
+  test("bars() keeps a `false` flag rather than replacing it with the default", () => {
+    /*
+     * Regression guard for the `?? false` nullish coalescing: an explicit
+     * false must survive, and is indistinguishable from the default here —
+     * the point is that passing false does not throw or flip to true.
+     */
+    const widget: AIChatWidget = WidgetBuilder.bars({
+      title: "x",
+      series: [],
+      stacked: false,
+      xIsTime: false,
+    });
+    const data: JSONObject = widget.data as JSONObject;
+    expect(data["stacked"]).toBe(false);
+    expect(data["xIsTime"]).toBe(false);
+  });
+
+  test("traceWaterfall() carries spans and total duration", () => {
+    const spans: Array<AIChatWidgetSpan> = [
+      { name: "GET /", durationMs: 12 } as unknown as AIChatWidgetSpan,
+    ];
+
+    const widget: AIChatWidget = WidgetBuilder.traceWaterfall({
+      title: "Trace",
+      spans,
+      totalDurationMs: 120,
+    });
+
+    expect(widget.type).toBe(AIChatWidgetType.TraceWaterfall);
+    const data: JSONObject = widget.data as JSONObject;
+    expect(data["spans"]).toBe(spans);
+    expect(data["totalDurationMs"]).toBe(120);
+  });
+
+  test("incidentList / alertList / exceptionList wrap items under the right type", () => {
+    const items: Array<JSONObject> = [{ id: "1" }];
+
+    const incident: AIChatWidget = WidgetBuilder.incidentList({
+      title: "Open incidents",
+      items,
+    });
+    expect(incident.type).toBe(AIChatWidgetType.IncidentList);
+    expect((incident.data as JSONObject)["items"]).toBe(items);
+
+    const alert: AIChatWidget = WidgetBuilder.alertList({
+      title: "Open alerts",
+      items,
+    });
+    expect(alert.type).toBe(AIChatWidgetType.AlertList);
+    expect((alert.data as JSONObject)["items"]).toBe(items);
+
+    const exception: AIChatWidget = WidgetBuilder.exceptionList({
+      title: "Exceptions",
+      items,
+    });
+    expect(exception.type).toBe(AIChatWidgetType.ExceptionList);
+    expect((exception.data as JSONObject)["items"]).toBe(items);
+  });
+
+  test("resourceCard() maps its heading/subheading/fields", () => {
+    const fields: Array<{ label: string; value: string }> = [
+      { label: "State", value: "Investigating" },
+    ];
+
+    const widget: AIChatWidget = WidgetBuilder.resourceCard({
+      title: "Incident",
+      resourceType: "Incident",
+      heading: "API is down",
+      subheading: "SEV1",
+      fields,
+    });
+
+    expect(widget.type).toBe(AIChatWidgetType.ResourceCard);
+    const data: JSONObject = widget.data as JSONObject;
+    expect(data["resourceType"]).toBe("Incident");
+    expect(data["heading"]).toBe("API is down");
+    expect(data["subheading"]).toBe("SEV1");
+    expect(data["fields"]).toBe(fields);
+  });
+
+  test("stats() builds StatCards", () => {
+    const stats: Array<AIChatWidgetStat> = [
+      { label: "Errors", value: "42" } as unknown as AIChatWidgetStat,
+    ];
+
+    const widget: AIChatWidget = WidgetBuilder.stats({
+      title: "KPIs",
+      stats,
+    });
+
+    expect(widget.type).toBe(AIChatWidgetType.StatCards);
+    expect((widget.data as JSONObject)["stats"]).toBe(stats);
+  });
+
+  test("every builder leaves id blank for the runner to mint", () => {
+    const widgets: Array<AIChatWidget> = [
+      WidgetBuilder.table({ title: "t", columns: [], rows: [] }),
+      WidgetBuilder.timeSeries({ title: "t", series: [] }),
+      WidgetBuilder.bars({ title: "t", series: [] }),
+      WidgetBuilder.incidentList({ title: "t", items: [] }),
+      WidgetBuilder.stats({ title: "t", stats: [] }),
+    ];
+
+    for (const widget of widgets) {
+      expect(widget.id).toBe("");
+    }
+  });
+});