@oneuptime/common 11.3.26 → 11.3.28

package/Server/Utils/LLM/LLMService.ts

@@ -49,6 +49,13 @@ export interface LLMUsage {
   promptTokens: number;
   completionTokens: number;
   totalTokens: number;
+  /*
+   * Prompt-caching breakdown, when the provider reports it. cachedInputTokens
+   * are input tokens served from cache (billed at a large discount);
+   * cacheCreationTokens are input tokens written to the cache on this call.
+   */
+  cachedInputTokens?: number | undefined;
+  cacheCreationTokens?: number | undefined;
 }
 
 export interface LLMCompletionResponse {
@@ -237,6 +244,17 @@ export default class LLMService {
     const toolCalls: Array<LLMToolCall> | undefined =
       this.parseOpenAIToolCalls(message);
 
+    /*
+     * OpenAI (and Azure OpenAI) automatically cache a stable prompt prefix
+     * once it is long enough and report the cache hit under
+     * prompt_tokens_details.cached_tokens — surface it for cost visibility.
+     */
+    const cachedTokens: number | undefined = usage
+      ? ((usage["prompt_tokens_details"] as JSONObject | undefined)?.[
+          "cached_tokens"
+        ] as number | undefined)
+      : undefined;
+
     return {
       content: (message["content"] as string) || "",
       toolCalls: toolCalls,
@@ -246,6 +264,7 @@ export default class LLMService {
             promptTokens: usage["prompt_tokens"] as number,
             completionTokens: usage["completion_tokens"] as number,
             totalTokens: usage["total_tokens"] as number,
+            cachedInputTokens: cachedTokens || undefined,
           }
         : undefined,
     };
@@ -565,6 +584,32 @@ export default class LLMService {
         continue;
       }
 
+      /*
+       * Anthropic requires strictly alternating user/assistant turns and
+       * returns a 400 on two consecutive same-role messages. The agent loop
+       * can legitimately emit back-to-back user turns (e.g. a tool_result
+       * user message immediately followed by the "budget exhausted, answer
+       * now" nudge), so coalesce a run of same-role messages into one instead
+       * of failing the whole request.
+       */
+      const previousMessage: JSONObject | undefined =
+        anthropicMessages[anthropicMessages.length - 1];
+
+      if (previousMessage && previousMessage["role"] === msg.role) {
+        if (typeof previousMessage["content"] === "string") {
+          previousMessage["content"] =
+            `${previousMessage["content"] as string}\n\n${msg.content}`;
+          continue;
+        }
+        if (Array.isArray(previousMessage["content"])) {
+          (previousMessage["content"] as Array<JSONObject>).push({
+            type: "text",
+            text: msg.content,
+          });
+          continue;
+        }
+      }
+
       anthropicMessages.push({
         role: msg.role,
         content: msg.content,
@@ -602,18 +647,43 @@ export default class LLMService {
       max_tokens: request.maxTokens || LLMService.ANTHROPIC_DEFAULT_MAX_TOKENS,
     };
 
+    /*
+     * Prompt caching. The system prompt and tool definitions are the large,
+     * stable prefix re-sent on every turn of the agent loop, so caching them is
+     * the biggest single cost + latency lever (cached input is billed at ~10%).
+     * An ephemeral cache_control breakpoint on the system block and on the LAST
+     * tool caches the whole system + tools prefix. cache_control is GA under
+     * anthropic-version 2023-06-01, so no beta header is required.
+     */
     if (systemMessage) {
-      requestData["system"] = systemMessage;
+      requestData["system"] = [
+        {
+          type: "text",
+          text: systemMessage,
+          cache_control: { type: "ephemeral" },
+        },
+      ];
     }
 
     if (request.tools && request.tools.length > 0) {
-      requestData["tools"] = request.tools.map((tool: LLMToolDefinition) => {
-        return {
-          name: tool.name,
-          description: tool.description,
-          input_schema: tool.inputSchema,
-        };
-      });
+      const anthropicTools: Array<JSONObject> = request.tools.map(
+        (tool: LLMToolDefinition) => {
+          return {
+            name: tool.name,
+            description: tool.description,
+            input_schema: tool.inputSchema,
+          };
+        },
+      );
+
+      // A breakpoint on the last tool caches the entire tools block before it.
+      const lastTool: JSONObject | undefined =
+        anthropicTools[anthropicTools.length - 1];
+      if (lastTool) {
+        lastTool["cache_control"] = { type: "ephemeral" };
+      }
+
+      requestData["tools"] = anthropicTools;
     }
 
     const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
@@ -685,10 +755,21 @@ export default class LLMService {
       stopReason: jsonData["stop_reason"] === "tool_use" ? "tool_use" : "stop",
       usage: usage
         ? {
-            promptTokens: usage["input_tokens"] as number,
-            completionTokens: usage["output_tokens"] as number,
+            promptTokens: (usage["input_tokens"] as number) || 0,
+            completionTokens: (usage["output_tokens"] as number) || 0,
+            /*
+             * Anthropic reports cache-read and cache-creation input tokens
+             * separately from input_tokens. Surface them and fold them into
+             * totalTokens so the logged total reflects the full billable input.
+             */
+            cachedInputTokens:
+              (usage["cache_read_input_tokens"] as number) || undefined,
+            cacheCreationTokens:
+              (usage["cache_creation_input_tokens"] as number) || undefined,
             totalTokens:
               ((usage["input_tokens"] as number) || 0) +
+              ((usage["cache_read_input_tokens"] as number) || 0) +
+              ((usage["cache_creation_input_tokens"] as number) || 0) +
               ((usage["output_tokens"] as number) || 0),
           }
         : undefined,
@@ -812,11 +893,29 @@ export default class LLMService {
       });
     }
 
+    /*
+     * Ollama reports token counts on the final /api/chat response as
+     * prompt_eval_count (input) and eval_count (output). Populate usage from
+     * them so LlmLog, the AI dashboards and (costed self-hosted Ollama)
+     * billing are not silently blind to token spend.
+     */
+    const ollamaPromptTokens: number =
+      (jsonData["prompt_eval_count"] as number) || 0;
+    const ollamaCompletionTokens: number =
+      (jsonData["eval_count"] as number) || 0;
+
     return {
       content: (message["content"] as string) || "",
       toolCalls: toolCalls,
       stopReason: toolCalls && toolCalls.length > 0 ? "tool_use" : "stop",
-      usage: undefined, // Ollama doesn't provide token usage in the same way
+      usage:
+        ollamaPromptTokens || ollamaCompletionTokens
+          ? {
+              promptTokens: ollamaPromptTokens,
+              completionTokens: ollamaCompletionTokens,
+              totalTokens: ollamaPromptTokens + ollamaCompletionTokens,
+            }
+          : undefined,
     };
   }
 }

package/Server/Utils/Telemetry/IoTSnapshotScan.ts

@@ -141,31 +141,34 @@ function parseUnixNanoToDate(
   value: string | number | undefined,
   context: string,
 ): Date {
-  let numericValue: number = OneUptimeDate.getCurrentDateAsUnixNano();
-
   if (value !== undefined && value !== null) {
     try {
       if (typeof value === "string") {
-        const parsed: number = Number.parseFloat(value);
-        if (isNaN(parsed)) {
+        const trimmed: string = value.trim();
+        if (trimmed === "" || isNaN(Number(trimmed))) {
           throw new Error(`Invalid timestamp string: ${value}`);
         }
-        numericValue = parsed;
-      } else if (typeof value === "number") {
+        /*
+         * Hand the raw nanosecond string to fromUnixNano so it can divide
+         * with BigInt — nanosecond epochs exceed Number.MAX_SAFE_INTEGER, so
+         * parsing to a float here would drop up to a full millisecond.
+         */
+        return OneUptimeDate.fromUnixNano(trimmed);
+      }
+      if (typeof value === "number") {
         if (!Number.isFinite(value)) {
           throw new Error(`Invalid timestamp number: ${value}`);
         }
-        numericValue = value;
+        return OneUptimeDate.fromUnixNano(value);
       }
     } catch (error) {
       logger.warn(
         `Error processing ${context}: ${error instanceof Error ? error.message : String(error)}, using current time`,
       );
-      numericValue = OneUptimeDate.getCurrentDateAsUnixNano();
     }
   }
 
-  return OneUptimeDate.fromUnixNano(numericValue);
+  return OneUptimeDate.getCurrentDate();
 }
 
 // Same trim-or-null read contract as OtelIngestBaseService.getStringAttribute.

package/Server/Utils/Telemetry/ProxmoxCephSnapshotScan.ts

@@ -242,31 +242,34 @@ function parseUnixNanoToDate(
   value: string | number | undefined,
   context: string,
 ): Date {
-  let numericValue: number = OneUptimeDate.getCurrentDateAsUnixNano();
-
   if (value !== undefined && value !== null) {
     try {
       if (typeof value === "string") {
-        const parsed: number = Number.parseFloat(value);
-        if (isNaN(parsed)) {
+        const trimmed: string = value.trim();
+        if (trimmed === "" || isNaN(Number(trimmed))) {
           throw new Error(`Invalid timestamp string: ${value}`);
         }
-        numericValue = parsed;
-      } else if (typeof value === "number") {
+        /*
+         * Hand the raw nanosecond string to fromUnixNano so it can divide
+         * with BigInt — nanosecond epochs exceed Number.MAX_SAFE_INTEGER, so
+         * parsing to a float here would drop up to a full millisecond.
+         */
+        return OneUptimeDate.fromUnixNano(trimmed);
+      }
+      if (typeof value === "number") {
         if (!Number.isFinite(value)) {
           throw new Error(`Invalid timestamp number: ${value}`);
         }
-        numericValue = value;
+        return OneUptimeDate.fromUnixNano(value);
       }
     } catch (error) {
       logger.warn(
         `Error processing ${context}: ${error instanceof Error ? error.message : String(error)}, using current time`,
       );
-      numericValue = OneUptimeDate.getCurrentDateAsUnixNano();
     }
   }
 
-  return OneUptimeDate.fromUnixNano(numericValue);
+  return OneUptimeDate.getCurrentDate();
 }
 
 // Same trim-or-null read contract as OtelIngestBaseService.getStringAttribute.

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

@@ -234,14 +234,6 @@ describe("AnalyticsDatabaseService", () => {
       jest.spyOn(logger, "error").mockImplementation(() => {
         return undefined!;
       });
-
-      /*
-       * The base getException method is async and throws without await in the
-       * catch block, creating unhandled rejections. Override to throw synchronously.
-       */
-      (service as any).getException = (error: Error): never => {
-        throw error;
-      };
     });
 
     afterEach(() => {

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

@@ -0,0 +1,233 @@
+import OnCallDutyPolicyScheduleLayerUserService from "../../../Server/Services/OnCallDutyPolicyScheduleLayerUserService";
+import Model from "../../../Models/DatabaseModels/OnCallDutyPolicyScheduleLayerUser";
+import ObjectID from "../../../Types/ObjectID";
+import logger from "../../../Server/Utils/Logger";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * OnCallDutyPolicyScheduleLayerUserService.onBeforeUpdate re-sequences the
+ * `order` of the other rows in a schedule layer when a user is dragged to a new
+ * position. Audit finding L3: the "moving down" branch (newOrder > currentOrder)
+ * decremented EVERY row with `order <= newOrder`, including rows ABOVE the moved
+ * user. Dragging a user downward therefore drove the top row's order to 0 (and
+ * negative after repeated down-drags) and opened a gap at 1, breaking the
+ * 1-based contiguous invariant that create-default (count+1) and delete
+ * re-sequencing depend on.
+ *
+ * The fix adds the missing lower bound `resource.order > currentOrder`, so only
+ * rows strictly between the old and new position shift — mirroring the
+ * double-bounded "moving up" branch (`order >= newOrder && order < currentOrder`).
+ *
+ * These tests stub the three persistence helpers onBeforeUpdate calls
+ * (findOneBy -> moved row's current order + layer id; findBy -> every row in the
+ * layer; updateOneBy -> the per-row shift) and CAPTURE each updateOneBy so we can
+ * assert exactly which rows moved and to what order. No Postgres involved.
+ */
+
+const service: any = OnCallDutyPolicyScheduleLayerUserService as any;
+
+// A schedule layer id shared by every row in these single-layer scenarios.
+const LAYER_ID: ObjectID = new ObjectID("layer1");
+
+const USER_A: ObjectID = new ObjectID("A");
+const USER_B: ObjectID = new ObjectID("B");
+const USER_C: ObjectID = new ObjectID("C");
+
+// A captured updateOneBy shift: which row and what order it was set to.
+interface CapturedShift {
+  id: string;
+  order: number;
+}
+
+// Build a fake persisted row for the layer.
+function row(id: ObjectID, order: number): Model {
+  return {
+    _id: id,
+    order,
+    onCallDutyPolicyScheduleLayerId: LAYER_ID,
+  } as unknown as Model;
+}
+
+// Build the UpdateBy passed to onBeforeUpdate for moving `movedId` to `newOrder`.
+function updateBy(movedId: ObjectID, newOrder: number): any {
+  return {
+    data: { order: newOrder },
+    query: { _id: movedId },
+    props: {},
+  } as any;
+}
+
+/*
+ * Stub findOneBy (moved row lookup), findBy (all rows in the layer) and
+ * updateOneBy (record the shift). Returns the array captured shifts are pushed
+ * into so each test can inspect exactly what moved.
+ */
+function stubService(
+  movedRow: Model,
+  layerRows: Array<Model>,
+): Array<CapturedShift> {
+  const captured: Array<CapturedShift> = [];
+
+  jest.spyOn(service, "findOneBy").mockResolvedValue(movedRow as never);
+
+  jest.spyOn(service, "findBy").mockResolvedValue(layerRows as never);
+
+  jest
+    .spyOn(service, "updateOneBy")
+    .mockImplementation((...args: Array<unknown>): Promise<void> => {
+      const updateArg: {
+        query: { _id: ObjectID };
+        data: { order: number };
+      } = args[0] as {
+        query: { _id: ObjectID };
+        data: { order: number };
+      };
+      captured.push({
+        id: updateArg.query._id.toString(),
+        order: updateArg.data.order,
+      });
+      return Promise.resolve();
+    });
+
+  return captured;
+}
+
+describe("OnCallDutyPolicyScheduleLayerUserService.onBeforeUpdate reorder", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  /*
+   * ----------------------------------------------------------------------- *
+   * 1. MOVE DOWN B: order 2 -> 3. Only C (3 -> 2) shifts; A is untouched.
+   * -----------------------------------------------------------------------
+   */
+  test("moving B down (2 -> 3) decrements ONLY C and never touches A", async () => {
+    const captured: Array<CapturedShift> = stubService(row(USER_B, 2), [
+      row(USER_A, 1),
+      row(USER_B, 2),
+      row(USER_C, 3),
+    ]);
+
+    await service.onBeforeUpdate(updateBy(USER_B, 3));
+
+    // Exactly one row shifted, and it was C going from 3 down to 2.
+    expect(captured).toHaveLength(1);
+    expect(captured[0]).toEqual({ id: USER_C.toString(), order: 2 });
+
+    // A (the top row) must never be decremented — the regression.
+    const aShifts: Array<CapturedShift> = captured.filter(
+      (c: CapturedShift): boolean => {
+        return c.id === USER_A.toString();
+      },
+    );
+    expect(aShifts).toHaveLength(0);
+
+    /*
+     * After the shift, with the outer update setting B = 3, the resulting layer
+     * is contiguous {A:1, C:2, B:3}.
+     */
+    const finalOrders: Record<string, number> = {
+      [USER_A.toString()]: 1, // untouched
+      [USER_C.toString()]: 2, // shifted
+      [USER_B.toString()]: 3, // set by the outer update
+    };
+    expect(finalOrders[USER_A.toString()]).toBe(1);
+    expect(finalOrders[USER_C.toString()]).toBe(2);
+    expect(finalOrders[USER_B.toString()]).toBe(3);
+  });
+
+  /*
+   * ----------------------------------------------------------------------- *
+   * 2. MOVE UP C: order 3 -> 1. A (1 -> 2) and B (2 -> 3) increment; C untouched.
+   * -----------------------------------------------------------------------
+   */
+  test("moving C up (3 -> 1) increments ONLY A and B", async () => {
+    const captured: Array<CapturedShift> = stubService(row(USER_C, 3), [
+      row(USER_A, 1),
+      row(USER_B, 2),
+      row(USER_C, 3),
+    ]);
+
+    await service.onBeforeUpdate(updateBy(USER_C, 1));
+
+    expect(captured).toHaveLength(2);
+
+    const byId: Record<string, number> = {};
+    for (const shift of captured) {
+      byId[shift.id] = shift.order;
+    }
+
+    expect(byId[USER_A.toString()]).toBe(2);
+    expect(byId[USER_B.toString()]).toBe(3);
+    // C itself is not part of the shift loop; the outer update sets it to 1.
+    expect(byId[USER_C.toString()]).toBeUndefined();
+
+    // Contiguous {C:1, A:2, B:3}.
+    const finalOrders: Record<string, number> = {
+      [USER_C.toString()]: 1,
+      [USER_A.toString()]: 2,
+      [USER_B.toString()]: 3,
+    };
+    expect(Object.values(finalOrders).sort()).toEqual([1, 2, 3]);
+  });
+
+  /*
+   * ----------------------------------------------------------------------- *
+   * 3. MOVE DOWN A: order 1 -> 3 (dragging the TOP row all the way down).
+   *    Only B (2 -> 1) and C (3 -> 2) decrement; A is not touched by the loop.
+   * -----------------------------------------------------------------------
+   */
+  test("moving the top row A down (1 -> 3) decrements ONLY B and C, no row hits 0", async () => {
+    const captured: Array<CapturedShift> = stubService(row(USER_A, 1), [
+      row(USER_A, 1),
+      row(USER_B, 2),
+      row(USER_C, 3),
+    ]);
+
+    await service.onBeforeUpdate(updateBy(USER_A, 3));
+
+    expect(captured).toHaveLength(2);
+
+    const byId: Record<string, number> = {};
+    for (const shift of captured) {
+      byId[shift.id] = shift.order;
+    }
+
+    expect(byId[USER_B.toString()]).toBe(1);
+    expect(byId[USER_C.toString()]).toBe(2);
+    // A is the moved row itself — the shift loop must not decrement it.
+    expect(byId[USER_A.toString()]).toBeUndefined();
+
+    // Nothing collapsed to 0 or negative.
+    for (const shift of captured) {
+      expect(shift.order).toBeGreaterThan(0);
+    }
+  });
+
+  /*
+   * ----------------------------------------------------------------------- *
+   * 4. Regression: in a move-down, NO captured shift may set an order <= 0.
+   *    Before the fix, dragging B down drove A's order to 0. This asserts the
+   *    invariant across the whole move-down code path.
+   * -----------------------------------------------------------------------
+   */
+  test("regression: no move-down shift ever sets order <= 0", async () => {
+    const captured: Array<CapturedShift> = stubService(row(USER_B, 2), [
+      row(USER_A, 1),
+      row(USER_B, 2),
+      row(USER_C, 3),
+    ]);
+
+    await service.onBeforeUpdate(updateBy(USER_B, 3));
+
+    for (const shift of captured) {
+      expect(shift.order).toBeGreaterThan(0);
+    }
+  });
+});
+
+// Keep any incidental logger.error noise out of the test output.
+jest.spyOn(logger, "error").mockImplementation((): void => {
+  return undefined;
+});