@oneuptime/common 12.0.8 → 12.0.9

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

@@ -0,0 +1,315 @@
+import { QueryIncidentsTool } from "../../../../Server/Utils/AI/Toolbox/IncidentTools";
+import {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../Server/Utils/AI/Toolbox/ToolTypes";
+import IncidentOwnerTeamService from "../../../../Server/Services/IncidentOwnerTeamService";
+import IncidentOwnerUserService from "../../../../Server/Services/IncidentOwnerUserService";
+import IncidentService from "../../../../Server/Services/IncidentService";
+import Incident from "../../../../Models/DatabaseModels/Incident";
+import IncidentOwnerTeam from "../../../../Models/DatabaseModels/IncidentOwnerTeam";
+import IncidentOwnerUser from "../../../../Models/DatabaseModels/IncidentOwnerUser";
+import IncidentSeverity from "../../../../Models/DatabaseModels/IncidentSeverity";
+import IncidentState from "../../../../Models/DatabaseModels/IncidentState";
+import Team from "../../../../Models/DatabaseModels/Team";
+import User from "../../../../Models/DatabaseModels/User";
+import BadDataException from "../../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../../Types/JSON";
+import Name from "../../../../Types/Name";
+import ObjectID from "../../../../Types/ObjectID";
+import PositiveNumber from "../../../../Types/PositiveNumber";
+import { afterEach, describe, expect, test } from "@jest/globals";
+
+/*
+ * query_incidents grew a state filter, skip pagination and owner details.
+ * These tests lock in the load-bearing behavior: state="active" filters on
+ * the canonical isResolvedState flag WITHOUT a createdAt window (so an open
+ * incident from months ago still answers "what's active right now?"), skip
+ * pagination reports the true total, and detail mode surfaces owner teams
+ * and users scoped to the ctx tenant.
+ */
+
+const ctx: ToolContext = {
+  projectId: ObjectID.generate(),
+  props: { isRoot: true },
+};
+
+const INCIDENT_ID: ObjectID = ObjectID.generate();
+
+function buildIncident(data?: { number?: number; title?: string }): Incident {
+  const incident: Incident = new Incident();
+  incident._id = INCIDENT_ID.toString();
+  incident.incidentNumber = data?.number ?? 42;
+  incident.title = data?.title ?? "Checkout is down";
+
+  const state: IncidentState = new IncidentState();
+  state.name = "Investigating";
+  incident.currentIncidentState = state;
+
+  const severity: IncidentSeverity = new IncidentSeverity();
+  severity.name = "Critical";
+  incident.incidentSeverity = severity;
+
+  return incident;
+}
+
+function mockList(data: { incidents: Array<Incident>; total: number }): {
+  findBySpy: jest.SpyInstance;
+  countBySpy: jest.SpyInstance;
+} {
+  return {
+    countBySpy: jest
+      .spyOn(IncidentService, "countBy")
+      .mockResolvedValue(new PositiveNumber(data.total) as never),
+    findBySpy: jest
+      .spyOn(IncidentService, "findBy")
+      .mockResolvedValue(data.incidents as never),
+  };
+}
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("query_incidents — state filter", () => {
+  test("state=active filters on isResolvedState=false with NO createdAt window", async () => {
+    const spies: { findBySpy: jest.SpyInstance; countBySpy: jest.SpyInstance } =
+      mockList({ incidents: [buildIncident()], total: 1 });
+
+    const result: ToolExecutionResult = await QueryIncidentsTool.execute(
+      { state: "active" },
+      ctx,
+    );
+
+    const callArgs: JSONObject = spies.findBySpy.mock
+      .calls[0]?.[0] as JSONObject;
+    const query: JSONObject = callArgs["query"] as JSONObject;
+
+    expect(query["currentIncidentState"]).toEqual({ isResolvedState: false });
+    // An open incident created months ago must still be found.
+    expect(query["createdAt"]).toBeUndefined();
+
+    // countBy sees the same query so the reported total matches the filter.
+    const countArgs: JSONObject = spies.countBySpy.mock
+      .calls[0]?.[0] as JSONObject;
+    expect(countArgs["query"]).toEqual(query);
+
+    expect(result.citationLabel).toBe("Active incidents (1 total)");
+    expect(result.rowCount).toBe(1);
+    expect(result.widget).toBeDefined();
+  });
+
+  test("state=active honors an explicitly passed time window", async () => {
+    const spies: { findBySpy: jest.SpyInstance } = mockList({
+      incidents: [],
+      total: 0,
+    });
+
+    await QueryIncidentsTool.execute(
+      { state: "active", createdWithinHours: 24 },
+      ctx,
+    );
+
+    const callArgs: JSONObject = spies.findBySpy.mock
+      .calls[0]?.[0] as JSONObject;
+    const query: JSONObject = callArgs["query"] as JSONObject;
+
+    expect(query["currentIncidentState"]).toEqual({ isResolvedState: false });
+    expect(query["createdAt"]).toBeDefined();
+  });
+
+  test("state=resolved filters on isResolvedState=true within the window", async () => {
+    const spies: { findBySpy: jest.SpyInstance } = mockList({
+      incidents: [],
+      total: 0,
+    });
+
+    const result: ToolExecutionResult = await QueryIncidentsTool.execute(
+      { state: "resolved" },
+      ctx,
+    );
+
+    const callArgs: JSONObject = spies.findBySpy.mock
+      .calls[0]?.[0] as JSONObject;
+    const query: JSONObject = callArgs["query"] as JSONObject;
+
+    expect(query["currentIncidentState"]).toEqual({ isResolvedState: true });
+    expect(query["createdAt"]).toBeDefined();
+    expect(result.citationLabel).toBe(
+      "Resolved incidents, last 168h (0 total)",
+    );
+  });
+
+  test("default (no state) keeps the old behavior: window only, no state filter", async () => {
+    const spies: { findBySpy: jest.SpyInstance } = mockList({
+      incidents: [buildIncident()],
+      total: 1,
+    });
+
+    const result: ToolExecutionResult = await QueryIncidentsTool.execute(
+      {},
+      ctx,
+    );
+
+    const callArgs: JSONObject = spies.findBySpy.mock
+      .calls[0]?.[0] as JSONObject;
+    const query: JSONObject = callArgs["query"] as JSONObject;
+
+    expect(query["currentIncidentState"]).toBeUndefined();
+    expect(query["createdAt"]).toBeDefined();
+    expect(callArgs["props"]).toBe(ctx.props);
+    expect(callArgs["limit"]).toBe(10);
+    expect(callArgs["skip"]).toBe(0);
+    expect(result.citationLabel).toBe("Incidents, last 168h (1 total)");
+  });
+
+  test("an invalid state value is rejected", async () => {
+    await expect(
+      QueryIncidentsTool.execute({ state: "open" }, ctx),
+    ).rejects.toThrow(BadDataException);
+  });
+});
+
+describe("query_incidents — skip pagination", () => {
+  test("reports the slice and total when more rows exist", async () => {
+    const incidents: Array<Incident> = [
+      buildIncident({ number: 11 }),
+      buildIncident({ number: 12 }),
+    ];
+    const spies: { findBySpy: jest.SpyInstance } = mockList({
+      incidents: incidents,
+      total: 40,
+    });
+
+    const result: ToolExecutionResult = await QueryIncidentsTool.execute(
+      { skip: 10 },
+      ctx,
+    );
+
+    const callArgs: JSONObject = spies.findBySpy.mock
+      .calls[0]?.[0] as JSONObject;
+    expect(callArgs["skip"]).toBe(10);
+
+    expect(result.dataForLlm).toContain(
+      "Showing rows 11–12 of 40 total. Pass skip to page further.",
+    );
+    expect(result.citationLabel).toBe("Incidents, last 168h (40 total)");
+    // rowCount reflects the returned slice, not the total.
+    expect(result.rowCount).toBe(2);
+  });
+
+  test("no paging banner when everything fits in one page", async () => {
+    mockList({ incidents: [buildIncident()], total: 1 });
+
+    const result: ToolExecutionResult = await QueryIncidentsTool.execute(
+      {},
+      ctx,
+    );
+
+    expect(result.dataForLlm).not.toContain("Pass skip to page further");
+  });
+
+  test("paging past the end stays oriented instead of a bare empty", async () => {
+    mockList({ incidents: [], total: 40 });
+
+    const result: ToolExecutionResult = await QueryIncidentsTool.execute(
+      { skip: 100 },
+      ctx,
+    );
+
+    expect(result.rowCount).toBe(0);
+    expect(result.dataForLlm).toContain(
+      "No rows at skip=100; there are 40 total.",
+    );
+    expect(result.widget).toBeUndefined();
+  });
+
+  test("clamps skip and limit", async () => {
+    const spies: { findBySpy: jest.SpyInstance } = mockList({
+      incidents: [],
+      total: 0,
+    });
+
+    await QueryIncidentsTool.execute({ skip: 99999, limit: 9999 }, ctx);
+
+    const callArgs: JSONObject = spies.findBySpy.mock
+      .calls[0]?.[0] as JSONObject;
+    expect(callArgs["skip"]).toBe(500);
+    expect(callArgs["limit"]).toBe(25);
+  });
+});
+
+describe("query_incidents — detail mode owners", () => {
+  function buildDetailIncident(): Incident {
+    const incident: Incident = buildIncident();
+    incident.monitors = [];
+    incident.labels = [];
+    return incident;
+  }
+
+  test("surfaces owner teams and owner users, scoped to the ctx tenant", async () => {
+    jest
+      .spyOn(IncidentService, "findOneById")
+      .mockResolvedValue(buildDetailIncident() as never);
+
+    const ownerTeam: IncidentOwnerTeam = new IncidentOwnerTeam();
+    const team: Team = new Team();
+    team.name = "SRE";
+    ownerTeam.team = team;
+
+    const ownerUser: IncidentOwnerUser = new IncidentOwnerUser();
+    const user: User = new User();
+    user.name = new Name("Alice Doe");
+    ownerUser.user = user;
+
+    const teamSpy: jest.SpyInstance = jest
+      .spyOn(IncidentOwnerTeamService, "findBy")
+      .mockResolvedValue([ownerTeam] as never);
+    const userSpy: jest.SpyInstance = jest
+      .spyOn(IncidentOwnerUserService, "findBy")
+      .mockResolvedValue([ownerUser] as never);
+
+    const result: ToolExecutionResult = await QueryIncidentsTool.execute(
+      { incidentId: INCIDENT_ID.toString() },
+      ctx,
+    );
+
+    expect(result.rowCount).toBe(1);
+    expect(result.dataForLlm).toContain("SRE");
+    expect(result.dataForLlm).toContain("Alice Doe");
+
+    // Owner lookups are pinned to the tenant: incidentId is an untrusted arg.
+    for (const spy of [teamSpy, userSpy]) {
+      const callArgs: JSONObject = spy.mock.calls[0]?.[0] as JSONObject;
+      const query: JSONObject = callArgs["query"] as JSONObject;
+      expect((query["incidentId"] as ObjectID).toString()).toBe(
+        INCIDENT_ID.toString(),
+      );
+      expect(query["projectId"]).toBe(ctx.projectId);
+      expect(callArgs["props"]).toBe(ctx.props);
+    }
+  });
+
+  test("a missing incident skips owner lookups and stays honest", async () => {
+    jest.spyOn(IncidentService, "findOneById").mockResolvedValue(null as never);
+
+    const teamSpy: jest.SpyInstance = jest.spyOn(
+      IncidentOwnerTeamService,
+      "findBy",
+    );
+    const userSpy: jest.SpyInstance = jest.spyOn(
+      IncidentOwnerUserService,
+      "findBy",
+    );
+
+    const result: ToolExecutionResult = await QueryIncidentsTool.execute(
+      { incidentId: INCIDENT_ID.toString() },
+      ctx,
+    );
+
+    expect(result.rowCount).toBe(0);
+    expect(result.widget).toBeUndefined();
+    expect(teamSpy).not.toHaveBeenCalled();
+    expect(userSpy).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,314 @@
+import API from "../../../../Utils/API";
+import HTTPResponse from "../../../../Types/API/HTTPResponse";
+import { JSONObject } from "../../../../Types/JSON";
+import LlmType from "../../../../Types/LLM/LlmType";
+import LLMService, {
+  LLMCompletionResponse,
+  LLMProviderConfig,
+} from "../../../../Server/Utils/LLM/LLMService";
+import stubLLMEgressGuard from "./StubLLMEgressGuard";
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+
+/*
+ * Output-length truncation must surface as stopReason "length" — mapping it to
+ * "stop" makes callers present cut-off answers as complete. These tests pin
+ * the wire mapping for every provider branch, mocked at the HTTP boundary the
+ * same way the other LLMService suites are.
+ */
+
+type PostSpy = ReturnType<typeof jest.spyOn>;
+
+function mockPost(response: JSONObject): PostSpy {
+  return jest.spyOn(API, "post").mockResolvedValue({
+    jsonData: response,
+  } as unknown as HTTPResponse<JSONObject>) as PostSpy;
+}
+
+const openAIConfig: LLMProviderConfig = {
+  llmType: LlmType.OpenAI,
+  apiKey: "test-key",
+  modelName: "gpt-test",
+};
+
+const azureConfig: LLMProviderConfig = {
+  llmType: LlmType.AzureOpenAI,
+  apiKey: "test-key",
+  baseUrl:
+    "https://example.openai.azure.com/openai/deployments/test-deployment",
+  modelName: "gpt-test",
+};
+
+const anthropicConfig: LLMProviderConfig = {
+  llmType: LlmType.Anthropic,
+  apiKey: "test-key",
+  modelName: "claude-test",
+};
+
+const ollamaConfig: LLMProviderConfig = {
+  llmType: LlmType.Ollama,
+  baseUrl: "http://localhost:11434",
+  modelName: "llama-test",
+};
+
+function openAIStyleResponse(data: {
+  finishReason: string;
+  withToolCalls?: boolean;
+}): JSONObject {
+  const message: JSONObject = {
+    role: "assistant",
+    content: data.withToolCalls ? null : "partial or complete answer",
+  };
+
+  if (data.withToolCalls) {
+    message["tool_calls"] = [
+      {
+        id: "call_1",
+        type: "function",
+        function: { name: "get_monitor", arguments: '{"monitorId":"m1"}' },
+      },
+    ];
+  }
+
+  return {
+    choices: [{ message: message, finish_reason: data.finishReason }],
+    usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+  };
+}
+
+async function getStopReason(
+  config: LLMProviderConfig,
+  response: JSONObject,
+): Promise<LLMCompletionResponse> {
+  mockPost(response);
+
+  return LLMService.getCompletion({
+    llmProviderConfig: config,
+    messages: [{ role: "user", content: "hello" }],
+  });
+}
+
+beforeEach(() => {
+  stubLLMEgressGuard();
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+  LLMService.clearRequestAdaptationCache();
+});
+
+describe("OpenAI-compatible finish_reason mapping", () => {
+  test('maps finish_reason "length" to stopReason "length"', async () => {
+    const result: LLMCompletionResponse = await getStopReason(
+      openAIConfig,
+      openAIStyleResponse({ finishReason: "length" }),
+    );
+
+    expect(result.stopReason).toBe("length");
+  });
+
+  test('maps finish_reason "stop" to stopReason "stop"', async () => {
+    const result: LLMCompletionResponse = await getStopReason(
+      openAIConfig,
+      openAIStyleResponse({ finishReason: "stop" }),
+    );
+
+    expect(result.stopReason).toBe("stop");
+  });
+
+  test('maps finish_reason "tool_calls" with tool calls to "tool_use"', async () => {
+    const result: LLMCompletionResponse = await getStopReason(
+      openAIConfig,
+      openAIStyleResponse({ finishReason: "tool_calls", withToolCalls: true }),
+    );
+
+    expect(result.stopReason).toBe("tool_use");
+    expect(result.toolCalls).toHaveLength(1);
+  });
+
+  test('keeps "tool_use" for compatible servers that report finish_reason "stop" alongside tool calls', async () => {
+    const result: LLMCompletionResponse = await getStopReason(
+      openAIConfig,
+      openAIStyleResponse({ finishReason: "stop", withToolCalls: true }),
+    );
+
+    expect(result.stopReason).toBe("tool_use");
+  });
+
+  test('truncation wins over tool calls: finish_reason "length" with tool calls maps to "length"', async () => {
+    /*
+     * A response cut off mid-tool-call still carries the partial tool_calls
+     * array. Executing a truncated call would be wrong, so the wire truth
+     * ("length") must win over the tool-call heuristic.
+     */
+    const result: LLMCompletionResponse = await getStopReason(
+      openAIConfig,
+      openAIStyleResponse({ finishReason: "length", withToolCalls: true }),
+    );
+
+    expect(result.stopReason).toBe("length");
+  });
+
+  test("missing finish_reason still maps to a defined stopReason", async () => {
+    const response: JSONObject = openAIStyleResponse({ finishReason: "stop" });
+    delete ((response["choices"] as Array<JSONObject>)[0] as JSONObject)[
+      "finish_reason"
+    ];
+
+    const result: LLMCompletionResponse = await getStopReason(
+      openAIConfig,
+      response,
+    );
+
+    expect(result.stopReason).toBe("stop");
+  });
+});
+
+describe("Azure OpenAI finish_reason mapping", () => {
+  test('maps finish_reason "length" to stopReason "length"', async () => {
+    const result: LLMCompletionResponse = await getStopReason(
+      azureConfig,
+      openAIStyleResponse({ finishReason: "length" }),
+    );
+
+    expect(result.stopReason).toBe("length");
+  });
+
+  test('maps finish_reason "stop" to stopReason "stop"', async () => {
+    const result: LLMCompletionResponse = await getStopReason(
+      azureConfig,
+      openAIStyleResponse({ finishReason: "stop" }),
+    );
+
+    expect(result.stopReason).toBe("stop");
+  });
+});
+
+describe("Anthropic stop_reason mapping", () => {
+  function anthropicResponse(data: {
+    stopReason: string;
+    withToolUse?: boolean;
+  }): JSONObject {
+    const content: Array<JSONObject> = [
+      { type: "text", text: "partial or complete answer" },
+    ];
+
+    if (data.withToolUse) {
+      content.push({
+        type: "tool_use",
+        id: "toolu_1",
+        name: "get_monitor",
+        input: { monitorId: "m1" },
+      });
+    }
+
+    return {
+      content: content,
+      stop_reason: data.stopReason,
+      usage: { input_tokens: 1, output_tokens: 1 },
+    };
+  }
+
+  test('maps stop_reason "max_tokens" to stopReason "length"', async () => {
+    const result: LLMCompletionResponse = await getStopReason(
+      anthropicConfig,
+      anthropicResponse({ stopReason: "max_tokens" }),
+    );
+
+    expect(result.stopReason).toBe("length");
+  });
+
+  test('maps stop_reason "end_turn" to stopReason "stop"', async () => {
+    const result: LLMCompletionResponse = await getStopReason(
+      anthropicConfig,
+      anthropicResponse({ stopReason: "end_turn" }),
+    );
+
+    expect(result.stopReason).toBe("stop");
+  });
+
+  test('maps stop_reason "tool_use" to stopReason "tool_use"', async () => {
+    const result: LLMCompletionResponse = await getStopReason(
+      anthropicConfig,
+      anthropicResponse({ stopReason: "tool_use", withToolUse: true }),
+    );
+
+    expect(result.stopReason).toBe("tool_use");
+    expect(result.toolCalls).toHaveLength(1);
+  });
+});
+
+describe("Ollama done_reason mapping", () => {
+  function ollamaResponse(data: {
+    doneReason?: string;
+    withToolCalls?: boolean;
+  }): JSONObject {
+    const message: JSONObject = {
+      role: "assistant",
+      content: "partial or complete answer",
+    };
+
+    if (data.withToolCalls) {
+      message["tool_calls"] = [
+        { function: { name: "get_monitor", arguments: { monitorId: "m1" } } },
+      ];
+    }
+
+    const response: JSONObject = {
+      message: message,
+      prompt_eval_count: 1,
+      eval_count: 1,
+    };
+
+    if (data.doneReason !== undefined) {
+      response["done_reason"] = data.doneReason;
+    }
+
+    return response;
+  }
+
+  test('maps done_reason "length" to stopReason "length"', async () => {
+    const result: LLMCompletionResponse = await getStopReason(
+      ollamaConfig,
+      ollamaResponse({ doneReason: "length" }),
+    );
+
+    expect(result.stopReason).toBe("length");
+  });
+
+  test('maps done_reason "limit" to stopReason "length"', async () => {
+    const result: LLMCompletionResponse = await getStopReason(
+      ollamaConfig,
+      ollamaResponse({ doneReason: "limit" }),
+    );
+
+    expect(result.stopReason).toBe("length");
+  });
+
+  test('maps done_reason "stop" with tool calls to "tool_use"', async () => {
+    const result: LLMCompletionResponse = await getStopReason(
+      ollamaConfig,
+      ollamaResponse({ doneReason: "stop", withToolCalls: true }),
+    );
+
+    expect(result.stopReason).toBe("tool_use");
+    expect(result.toolCalls).toHaveLength(1);
+  });
+
+  test('maps done_reason "stop" without tool calls to "stop"', async () => {
+    const result: LLMCompletionResponse = await getStopReason(
+      ollamaConfig,
+      ollamaResponse({ doneReason: "stop" }),
+    );
+
+    expect(result.stopReason).toBe("stop");
+  });
+
+  test('missing done_reason maps to "stop" for a plain text answer', async () => {
+    const result: LLMCompletionResponse = await getStopReason(
+      ollamaConfig,
+      ollamaResponse({}),
+    );
+
+    expect(result.stopReason).toBe("stop");
+  });
+});

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

@@ -56,7 +56,16 @@ describe("LLMService tool calling — OpenAI-compatible", () => {
     });
 
     const response: LLMCompletionResponse = await LLMService.getCompletion({
-      llmProviderConfig: { llmType: LlmType.OpenAI, apiKey: "test-key" },
+      llmProviderConfig: {
+        llmType: LlmType.OpenAI,
+        apiKey: "test-key",
+        /*
+         * Pinned to a legacy (non-reasoning) model: the blank-model default is
+         * now a reasoning model that sends max_completion_tokens, and this
+         * test asserts the legacy max_tokens request shape.
+         */
+        modelName: "gpt-4o",
+      },
       messages: [{ role: "user", content: "find logs" }],
       tools: [
         {
@@ -405,7 +414,16 @@ describe("LLMService — additionalParams (per-provider overrides)", () => {
     });
 
     await LLMService.getCompletion({
-      llmProviderConfig: { llmType: LlmType.OpenAI, apiKey: "test-key" },
+      llmProviderConfig: {
+        llmType: LlmType.OpenAI,
+        apiKey: "test-key",
+        /*
+         * Pinned to a legacy (non-reasoning) model: the blank-model default is
+         * now a reasoning model that sends max_completion_tokens, and this
+         * test asserts the legacy max_tokens path specifically.
+         */
+        modelName: "gpt-4o",
+      },
       messages: [{ role: "user", content: "hi" }],
       maxTokens: 1024,
       additionalParams: { temperature: 0.2, top_p: 0.9 },
@@ -427,7 +445,12 @@ describe("LLMService — additionalParams (per-provider overrides)", () => {
     });
 
     await LLMService.getCompletion({
-      llmProviderConfig: { llmType: LlmType.OpenAI, apiKey: "test-key" },
+      llmProviderConfig: {
+        llmType: LlmType.OpenAI,
+        apiKey: "test-key",
+        // Legacy model, so max_tokens would be sent unless the override wins.
+        modelName: "gpt-4o",
+      },
       messages: [{ role: "user", content: "hi" }],
       maxTokens: 1024,
       // gpt-5 / o1 / o3 reject max_tokens and require max_completion_tokens.