@oneuptime/common 11.3.25 → 11.3.26

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

@@ -0,0 +1,79 @@
+import { ToolArgs } from "../../../../Server/Utils/AI/Toolbox/ToolTypes";
+import ObjectID from "../../../../Types/ObjectID";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * scopeServiceIds decides the `serviceIds` filter the aggregation tools hand to
+ * the raw-SQL aggregation services. The aggregation services treat a
+ * missing/empty serviceIds as "no filter" (whole project), so for a
+ * label-restricted user this helper must NEVER return undefined or []. These
+ * tests pin that invariant.
+ */
+describe("ToolArgs.scopeServiceIds", () => {
+  test("unrestricted user, no requested service → no filter", () => {
+    expect(ToolArgs.scopeServiceIds(null, undefined)).toBeUndefined();
+  });
+
+  test("unrestricted user with a requested service → just that service", () => {
+    const requested: ObjectID = ObjectID.generate();
+    const result: Array<ObjectID> | undefined = ToolArgs.scopeServiceIds(
+      null,
+      requested,
+    );
+    expect(
+      result?.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    ).toEqual([requested.toString()]);
+  });
+
+  test("restricted user, no requested service → the accessible set", () => {
+    const a: ObjectID = ObjectID.generate();
+    const b: ObjectID = ObjectID.generate();
+    const result: Array<ObjectID> | undefined = ToolArgs.scopeServiceIds(
+      [a, b],
+      undefined,
+    );
+    expect(
+      result?.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    ).toEqual([a.toString(), b.toString()]);
+  });
+
+  test("restricted user requesting an accessible service → intersection", () => {
+    const a: ObjectID = ObjectID.generate();
+    const b: ObjectID = ObjectID.generate();
+    const result: Array<ObjectID> | undefined = ToolArgs.scopeServiceIds(
+      [a, b],
+      b,
+    );
+    expect(
+      result?.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    ).toEqual([b.toString()]);
+  });
+
+  test("restricted user requesting a forbidden service → no-match sentinel, never empty", () => {
+    const accessible: ObjectID = ObjectID.generate();
+    const forbidden: ObjectID = ObjectID.generate();
+    const result: Array<ObjectID> | undefined = ToolArgs.scopeServiceIds(
+      [accessible],
+      forbidden,
+    );
+    expect(result).toBeDefined();
+    expect(result).toHaveLength(1);
+    expect(result?.[0]?.toString()).toBe(ObjectID.getZeroObjectID().toString());
+  });
+
+  test("restricted user with no accessible services → no-match sentinel, never empty", () => {
+    const result: Array<ObjectID> | undefined = ToolArgs.scopeServiceIds(
+      [],
+      undefined,
+    );
+    expect(result).toBeDefined();
+    expect(result).toHaveLength(1);
+    expect(result?.[0]?.toString()).toBe(ObjectID.getZeroObjectID().toString());
+  });
+});

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

@@ -0,0 +1,155 @@
+import ToolResultSerializer, {
+  SerializedResult,
+} from "../../../../Server/Utils/AI/Toolbox/Serializer";
+import { JSONObject } from "../../../../Types/JSON";
+import { describe, expect, test } from "@jest/globals";
+
+describe("ToolResultSerializer.redact", () => {
+  test("redacts email addresses", () => {
+    const result: { text: string; count: number } = ToolResultSerializer.redact(
+      "user john.doe@example.com logged in",
+    );
+    expect(result.text).toBe("user [redacted-email] logged in");
+    expect(result.count).toBe(1);
+  });
+
+  test("redacts JWTs", () => {
+    const jwt: string = `eyJhbGciOiJIUzI1NiJ9.${"a".repeat(20)}.${"b".repeat(10)}`;
+    const result: { text: string; count: number } = ToolResultSerializer.redact(
+      `token=${jwt} used`,
+    );
+    expect(result.text).toContain("[redacted-jwt]");
+    expect(result.text).not.toContain(jwt);
+  });
+
+  test("redacts bearer tokens", () => {
+    const result: { text: string; count: number } = ToolResultSerializer.redact(
+      "Authorization: Bearer abcdefghijklmnop1234567890",
+    );
+    expect(result.text).not.toContain("abcdefghijklmnop1234567890");
+    expect(result.text).toContain("[redacted");
+  });
+
+  test("redacts IPv4 addresses", () => {
+    const result: { text: string; count: number } = ToolResultSerializer.redact(
+      "request from 203.0.113.42 failed",
+    );
+    expect(result.text).toBe("request from [redacted-ip] failed");
+  });
+
+  test("redacts long hex strings", () => {
+    const hex: string = "deadbeef".repeat(5);
+    const result: { text: string; count: number } = ToolResultSerializer.redact(
+      `session ${hex} expired`,
+    );
+    expect(result.text).toContain("[redacted-hex]");
+  });
+
+  test("preserves 32-char OTel trace IDs and 16-char span IDs", () => {
+    /*
+     * Exactly 32 hex = W3C/OTel trace ID; exactly 16 hex = span ID. Both must
+     * survive so the model can pivot search_logs -> get_trace.
+     */
+    const traceId: string = "4bf92f3577b34da6a3ce929d0e0e4736";
+    const spanId: string = "00f067aa0ba902b7";
+    const result: { text: string; count: number } = ToolResultSerializer.redact(
+      `traceId=${traceId} spanId=${spanId}`,
+    );
+    expect(result.text).toContain(traceId);
+    expect(result.text).toContain(spanId);
+    expect(result.text).not.toContain("[redacted-hex]");
+    expect(result.count).toBe(0);
+  });
+
+  test("still redacts hex secrets longer than a trace ID (33+ chars)", () => {
+    const sha256: string = "a".repeat(64);
+    const result: { text: string; count: number } = ToolResultSerializer.redact(
+      `digest ${sha256} verified`,
+    );
+    expect(result.text).toContain("[redacted-hex]");
+    expect(result.text).not.toContain(sha256);
+  });
+
+  test("redacts key=value secrets and keeps the key via capture groups", () => {
+    const result: { text: string; count: number } = ToolResultSerializer.redact(
+      "config: password=supersecretvalue retries=3",
+    );
+    expect(result.text).toContain("password=[redacted]");
+    expect(result.text).not.toContain("supersecretvalue");
+    expect(result.text).toContain("retries=3");
+  });
+
+  test("leaves benign text untouched", () => {
+    const text: string = "p95 latency is 230ms for checkout";
+    const result: { text: string; count: number } =
+      ToolResultSerializer.redact(text);
+    expect(result.text).toBe(text);
+    expect(result.count).toBe(0);
+  });
+});
+
+describe("ToolResultSerializer.serializeRows", () => {
+  test("caps rows at 50 and marks truncation", () => {
+    const rows: Array<JSONObject> = [];
+    for (let i: number = 0; i < 80; i++) {
+      rows.push({ index: i, value: `row-${i}` });
+    }
+
+    const result: SerializedResult = ToolResultSerializer.serializeRows(rows);
+    expect(result.isTruncated).toBe(true);
+    expect(result.rowCount).toBe(80);
+    expect(result.text.split("\n").length).toBeLessThanOrEqual(51);
+  });
+
+  test("tells the model how many rows were hidden when capped", () => {
+    const rows: Array<JSONObject> = [];
+    for (let i: number = 0; i < 80; i++) {
+      rows.push({ index: i, value: `row-${i}` });
+    }
+
+    const result: SerializedResult = ToolResultSerializer.serializeRows(rows);
+    expect(result.text).toContain("first 50 of 80 rows");
+  });
+
+  test("does not add a truncation marker when rows fit", () => {
+    const rows: Array<JSONObject> = [{ index: 1 }, { index: 2 }];
+    const result: SerializedResult = ToolResultSerializer.serializeRows(rows);
+    expect(result.isTruncated).toBe(false);
+    expect(result.text).not.toContain("showing the first");
+  });
+
+  test("truncates long field values", () => {
+    const result: SerializedResult = ToolResultSerializer.serializeRows([
+      { body: "x".repeat(2000) },
+    ]);
+    expect(result.isTruncated).toBe(true);
+    expect(result.text).toContain("[truncated]");
+    expect(result.text.length).toBeLessThan(700);
+  });
+
+  test("caps total payload size", () => {
+    const rows: Array<JSONObject> = [];
+    for (let i: number = 0; i < 50; i++) {
+      rows.push({ body: "y".repeat(490) });
+    }
+    const result: SerializedResult = ToolResultSerializer.serializeRows(rows);
+    expect(Buffer.byteLength(result.text, "utf8")).toBeLessThanOrEqual(
+      17 * 1024,
+    );
+    expect(result.isTruncated).toBe(true);
+  });
+
+  test("reports zero rows honestly", () => {
+    const result: SerializedResult = ToolResultSerializer.serializeRows([]);
+    expect(result.rowCount).toBe(0);
+    expect(result.text).toBe("(no rows found)");
+  });
+
+  test("redacts inside rows", () => {
+    const result: SerializedResult = ToolResultSerializer.serializeRows([
+      { body: "contact admin@corp.com now" },
+    ]);
+    expect(result.text).toContain("[redacted-email]");
+    expect(result.redactionCount).toBe(1);
+  });
+});

package/Tests/Types/Billing/SubscriptionStatus.test.ts

@@ -0,0 +1,127 @@
+import SubscriptionStatus, {
+  SubscriptionStatusUtil,
+} from "../../../Types/Billing/SubscriptionStatus";
+
+describe("SubscriptionStatusUtil", () => {
+  describe("isSubscriptionActive", () => {
+    test("treats a missing status as active", () => {
+      expect(SubscriptionStatusUtil.isSubscriptionActive(undefined)).toBe(true);
+    });
+
+    test.each([
+      SubscriptionStatus.Active,
+      SubscriptionStatus.Trialing,
+      SubscriptionStatus.PastDue,
+    ])("returns true for %s", (status: SubscriptionStatus) => {
+      expect(SubscriptionStatusUtil.isSubscriptionActive(status)).toBe(true);
+    });
+
+    test.each([
+      SubscriptionStatus.Incomplete,
+      SubscriptionStatus.IncompleteExpired,
+      SubscriptionStatus.Canceled,
+      SubscriptionStatus.Unpaid,
+      SubscriptionStatus.Expired,
+      SubscriptionStatus.Paused,
+    ])("returns false for %s", (status: SubscriptionStatus) => {
+      expect(SubscriptionStatusUtil.isSubscriptionActive(status)).toBe(false);
+    });
+  });
+
+  describe("isSubscriptionInactive", () => {
+    test("is the inverse of isSubscriptionActive", () => {
+      const statuses: Array<SubscriptionStatus | undefined> = [
+        undefined,
+        ...Object.values(SubscriptionStatus),
+      ];
+
+      for (const status of statuses) {
+        expect(SubscriptionStatusUtil.isSubscriptionInactive(status)).toBe(
+          !SubscriptionStatusUtil.isSubscriptionActive(status),
+        );
+      }
+    });
+
+    test("treats a missing status as active (not inactive)", () => {
+      expect(SubscriptionStatusUtil.isSubscriptionInactive(undefined)).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("isSubscriptionOverdue", () => {
+    test("returns false for a missing status", () => {
+      expect(SubscriptionStatusUtil.isSubscriptionOverdue(undefined)).toBe(
+        false,
+      );
+    });
+
+    test("returns true only for PastDue", () => {
+      expect(
+        SubscriptionStatusUtil.isSubscriptionOverdue(
+          SubscriptionStatus.PastDue,
+        ),
+      ).toBe(true);
+      expect(
+        SubscriptionStatusUtil.isSubscriptionOverdue(SubscriptionStatus.Active),
+      ).toBe(false);
+      expect(
+        SubscriptionStatusUtil.isSubscriptionOverdue(
+          SubscriptionStatus.Canceled,
+        ),
+      ).toBe(false);
+    });
+  });
+
+  describe("isSubscriptionCancelled", () => {
+    test("returns false for a missing status", () => {
+      expect(SubscriptionStatusUtil.isSubscriptionCancelled(undefined)).toBe(
+        false,
+      );
+    });
+
+    test.each([
+      SubscriptionStatus.Canceled,
+      SubscriptionStatus.Unpaid,
+      SubscriptionStatus.Expired,
+      SubscriptionStatus.IncompleteExpired,
+    ])("returns true for %s", (status: SubscriptionStatus) => {
+      expect(SubscriptionStatusUtil.isSubscriptionCancelled(status)).toBe(true);
+    });
+
+    test.each([
+      SubscriptionStatus.Active,
+      SubscriptionStatus.Trialing,
+      SubscriptionStatus.PastDue,
+      SubscriptionStatus.Incomplete,
+      SubscriptionStatus.Paused,
+    ])("returns false for %s", (status: SubscriptionStatus) => {
+      expect(SubscriptionStatusUtil.isSubscriptionCancelled(status)).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("status relationships", () => {
+    test("PastDue is both active and overdue", () => {
+      expect(
+        SubscriptionStatusUtil.isSubscriptionActive(SubscriptionStatus.PastDue),
+      ).toBe(true);
+      expect(
+        SubscriptionStatusUtil.isSubscriptionOverdue(
+          SubscriptionStatus.PastDue,
+        ),
+      ).toBe(true);
+    });
+
+    test("active and cancelled statuses never overlap", () => {
+      for (const status of Object.values(SubscriptionStatus)) {
+        const active: boolean =
+          SubscriptionStatusUtil.isSubscriptionActive(status);
+        const cancelled: boolean =
+          SubscriptionStatusUtil.isSubscriptionCancelled(status);
+        expect(active && cancelled).toBe(false);
+      }
+    });
+  });
+});

package/Tests/Types/Metrics/RecordingRuleDefinition.test.ts

@@ -0,0 +1,213 @@
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import RecordingRuleDefinition, {
+  RecordingRuleDefinitionUtil,
+  RecordingRuleSource,
+  RECORDING_RULE_MAX_SOURCES,
+  RECORDING_RULE_MAX_EXPRESSION_LENGTH,
+} from "../../../Types/Metrics/RecordingRuleDefinition";
+
+describe("RecordingRuleDefinitionUtil", () => {
+  const makeSource: (
+    overrides?: Partial<RecordingRuleSource>,
+  ) => RecordingRuleSource = (
+    overrides: Partial<RecordingRuleSource> = {},
+  ): RecordingRuleSource => {
+    return {
+      alias: "A",
+      metricName: "http.requests",
+      aggregationType: AggregationType.Sum,
+      ...overrides,
+    };
+  };
+
+  describe("getAggregationOptions", () => {
+    test("returns a value/label option for each supported aggregation", () => {
+      const options: Array<{ value: AggregationType; label: string }> =
+        RecordingRuleDefinitionUtil.getAggregationOptions();
+
+      expect(options.length).toBeGreaterThan(0);
+      for (const option of options) {
+        expect(typeof option.label).toBe("string");
+        expect(option.label.length).toBeGreaterThan(0);
+        expect(Object.values(AggregationType)).toContain(option.value);
+      }
+    });
+  });
+
+  describe("getNextAlias", () => {
+    test("returns A when there are no sources", () => {
+      expect(RecordingRuleDefinitionUtil.getNextAlias(undefined)).toBe("A");
+      expect(RecordingRuleDefinitionUtil.getNextAlias([])).toBe("A");
+    });
+
+    test("returns the first unused letter", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getNextAlias([makeSource({ alias: "A" })]),
+      ).toBe("B");
+      expect(
+        RecordingRuleDefinitionUtil.getNextAlias([
+          makeSource({ alias: "A" }),
+          makeSource({ alias: "B" }),
+        ]),
+      ).toBe("C");
+    });
+
+    test("skips gaps and returns the lowest free letter", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getNextAlias([
+          makeSource({ alias: "A" }),
+          makeSource({ alias: "C" }),
+        ]),
+      ).toBe("B");
+    });
+  });
+
+  describe("getEmptyDefinition", () => {
+    test("returns a single source aliased A with expression A", () => {
+      const def: RecordingRuleDefinition =
+        RecordingRuleDefinitionUtil.getEmptyDefinition();
+
+      expect(def.sources.length).toBe(1);
+      expect(def.sources[0]!.alias).toBe("A");
+      expect(def.expression).toBe("A");
+    });
+
+    test("is itself a valid definition once a metric name is provided", () => {
+      const def: RecordingRuleDefinition =
+        RecordingRuleDefinitionUtil.getEmptyDefinition();
+      def.sources[0]!.metricName = "http.requests";
+
+      expect(RecordingRuleDefinitionUtil.getValidationError(def)).toBeNull();
+    });
+  });
+
+  describe("getValidationError", () => {
+    const validDefinition: () => RecordingRuleDefinition =
+      (): RecordingRuleDefinition => {
+        return {
+          sources: [makeSource({ alias: "A" }), makeSource({ alias: "B" })],
+          expression: "A / B * 100",
+        };
+      };
+
+    test("accepts a valid definition", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError(validDefinition()),
+      ).toBeNull();
+    });
+
+    test("requires a definition", () => {
+      expect(RecordingRuleDefinitionUtil.getValidationError(undefined)).toBe(
+        "Definition is required.",
+      );
+    });
+
+    test("requires at least one source", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [],
+          expression: "A",
+        }),
+      ).toBe("Add at least one source metric.");
+    });
+
+    test("rejects more than the maximum number of sources", () => {
+      const sources: Array<RecordingRuleSource> = Array.from(
+        { length: RECORDING_RULE_MAX_SOURCES + 1 },
+        (_unused: unknown, i: number) => {
+          return makeSource({ alias: "ABCDE"[i] as string });
+        },
+      );
+
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources,
+          expression: "A",
+        }),
+      ).toContain(`at most ${RECORDING_RULE_MAX_SOURCES}`);
+    });
+
+    test("rejects an invalid alias", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "a" })],
+          expression: "A",
+        }),
+      ).toContain("single uppercase letter");
+    });
+
+    test("rejects duplicate aliases", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" }), makeSource({ alias: "A" })],
+          expression: "A",
+        }),
+      ).toContain("Duplicate alias");
+    });
+
+    test("requires a metric name", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A", metricName: "  " })],
+          expression: "A",
+        }),
+      ).toContain("Metric name is required");
+    });
+
+    test("requires both a filter key and value, or neither", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A", filterAttributeKey: "env" })],
+          expression: "A",
+        }),
+      ).toContain("needs both a key and a value");
+    });
+
+    test("requires an expression", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" })],
+          expression: "   ",
+        }),
+      ).toBe("Expression is required.");
+    });
+
+    test("rejects an over-length expression", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" })],
+          expression: "A".repeat(RECORDING_RULE_MAX_EXPRESSION_LENGTH + 1),
+        }),
+      ).toContain(
+        `${RECORDING_RULE_MAX_EXPRESSION_LENGTH} characters or fewer`,
+      );
+    });
+
+    test("rejects an expression referencing an undefined alias", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" })],
+          expression: "A + B",
+        }),
+      ).toContain("references alias 'B'");
+    });
+
+    test("rejects an expression that references no alias", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" })],
+          expression: "5 + 10",
+        }),
+      ).toContain("must reference at least one source alias");
+    });
+
+    test("rejects an expression with characters outside the DSL grammar", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" }), makeSource({ alias: "B" })],
+          expression: "A & B",
+        }),
+      ).toContain("may only contain");
+    });
+  });
+});

package/Types/AI/AIChatMessageRole.ts

@@ -0,0 +1,6 @@
+enum AIChatMessageRole {
+  User = "User",
+  Assistant = "Assistant",
+}
+
+export default AIChatMessageRole;

package/Types/AI/AIChatMessageStatus.ts

@@ -0,0 +1,32 @@
+enum AIChatMessageStatus {
+  Pending = "Pending",
+  InProgress = "InProgress",
+  /*
+   * The turn paused because the agent wants to run one or more mutating tools
+   * and the conversation is in "Ask for approval" mode. The message carries the
+   * pending tool actions; the user approves or denies them to resume the turn.
+   */
+  WaitingForApproval = "WaitingForApproval",
+  Completed = "Completed",
+  Error = "Error",
+}
+
+export default AIChatMessageStatus;
+
+export class AIChatMessageStatusHelper {
+  public static isTerminalStatus(status: AIChatMessageStatus): boolean {
+    return (
+      status === AIChatMessageStatus.Completed ||
+      status === AIChatMessageStatus.Error
+    );
+  }
+
+  // Statuses in which a run is still in flight (spinner or approval card shown).
+  public static isActiveStatus(status: AIChatMessageStatus): boolean {
+    return (
+      status === AIChatMessageStatus.Pending ||
+      status === AIChatMessageStatus.InProgress ||
+      status === AIChatMessageStatus.WaitingForApproval
+    );
+  }
+}

package/Types/AI/AIChatPermissionMode.ts

@@ -0,0 +1,69 @@
+/*
+ * How the AI chat agent is allowed to run tools that MUTATE project data
+ * (create/acknowledge/resolve incidents and alerts, etc). Read-only tools are
+ * never gated by this — they always run. This is stored per-conversation on
+ * AIConversation.permissionMode and enforced in ChatAgentRunner.
+ */
+enum AIChatPermissionMode {
+  /*
+   * The agent pauses before every mutating tool and asks the user to approve
+   * it. This is the safe default.
+   */
+  AskForApproval = "AskForApproval",
+  /*
+   * The agent runs mutating tools immediately (still gated by the user's RBAC
+   * permissions). "Bypass permissions" / YOLO mode.
+   */
+  AutoRun = "AutoRun",
+  // Mutating tools are not even offered to the model. The agent can only read.
+  ReadOnly = "ReadOnly",
+}
+
+export default AIChatPermissionMode;
+
+export interface AIChatPermissionModeOption {
+  value: AIChatPermissionMode;
+  title: string;
+  description: string;
+}
+
+export class AIChatPermissionModeHelper {
+  public static getDefault(): AIChatPermissionMode {
+    return AIChatPermissionMode.AskForApproval;
+  }
+
+  public static isValid(
+    value: string | undefined,
+  ): value is AIChatPermissionMode {
+    return Object.values(AIChatPermissionMode).includes(
+      value as AIChatPermissionMode,
+    );
+  }
+
+  public static parse(value: string | undefined): AIChatPermissionMode {
+    return this.isValid(value) ? value : this.getDefault();
+  }
+
+  public static getOptions(): Array<AIChatPermissionModeOption> {
+    return [
+      {
+        value: AIChatPermissionMode.AskForApproval,
+        title: "Ask for approval",
+        description:
+          "The copilot pauses and asks before it changes anything (creating incidents, acknowledging alerts, etc).",
+      },
+      {
+        value: AIChatPermissionMode.AutoRun,
+        title: "Auto-run (bypass approvals)",
+        description:
+          "The copilot performs actions immediately, still limited to what your role can do.",
+      },
+      {
+        value: AIChatPermissionMode.ReadOnly,
+        title: "Read-only",
+        description:
+          "The copilot can investigate and answer questions but can never change anything.",
+      },
+    ];
+  }
+}