@oneuptime/common 13.0.6 → 13.0.8

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

@@ -4,10 +4,27 @@ import {
 } from "../../../../Server/Utils/AI/Chat/ChatAgentRunner";
 import { AIChatCitation } from "../../../../Types/AI/AIChatTypes";
 import { pinQueryToRequestingUser } from "../../../../Server/Utils/AI/AIChatPrivacyFilter";
+import DatabaseCommonInteractionProps from "../../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import DatabaseCommonInteractionPropsUtil from "../../../../Types/BaseDatabase/DatabaseCommonInteractionPropsUtil";
+import Exception from "../../../../Types/Exception/Exception";
+import ExceptionCode from "../../../../Types/Exception/ExceptionCode";
+import NotAuthenticatedException from "../../../../Types/Exception/NotAuthenticatedException";
 import NotAuthorizedException from "../../../../Types/Exception/NotAuthorizedException";
 import ObjectID from "../../../../Types/ObjectID";
+import UserType from "../../../../Types/UserType";
 import { describe, expect, test } from "@jest/globals";
 
+// Runs `fn` and returns what it threw; fails the test if it returned.
+const thrownBy: (fn: () => void) => Exception = (fn: () => void): Exception => {
+  try {
+    fn();
+  } catch (error) {
+    return error as Exception;
+  }
+
+  throw new Error("Expected the call to throw, but it returned normally.");
+};
+
 const citation: (id: string) => AIChatCitation = (id: string) => {
   return {
     id,
@@ -81,9 +98,76 @@ describe("pinQueryToRequestingUser", () => {
     expect(pinned["createdByUserId"]).toBeUndefined();
   });
 
-  test("throws when there is no user in a non-root context", () => {
-    expect(() => {
-      pinQueryToRequestingUser({}, {}, "createdByUserId");
-    }).toThrow(NotAuthorizedException);
+  /*
+   * No credentials at all is a signed-in user whose access-token cookie
+   * expired, not someone reaching for another member's conversations. It has
+   * to be a 401 - the browser client refreshes the session and replays only
+   * on a 401 - so the old 422 would leave the chat panel showing an error.
+   */
+  test.each([
+    ["no props at all", {}],
+    ["a tenant but no user", { tenantId: ObjectID.generate() }],
+    ["an explicitly Public caller", { userType: UserType.Public }],
+  ])(
+    "answers an anonymous caller (%s) with 401, not 422",
+    (_label: string, props: DatabaseCommonInteractionProps) => {
+      const error: Exception = thrownBy(() => {
+        pinQueryToRequestingUser({}, props, "createdByUserId");
+      });
+
+      expect(error).toBeInstanceOf(NotAuthenticatedException);
+      expect(error).not.toBeInstanceOf(NotAuthorizedException);
+      expect(error.code).toBe(ExceptionCode.NotAuthenticatedException);
+      expect(error.code).toBe(401);
+      expect(error.message).toBe(
+        DatabaseCommonInteractionPropsUtil.AUTHENTICATION_REQUIRED_MESSAGE,
+      );
+    },
+  );
+
+  /*
+   * A project API key has credentials but no user, so it has no personal
+   * scope. That is a real "not allowed" - refreshing cannot give a key a
+   * user - and it keeps the 422 and the message it always had.
+   */
+  test("still refuses a project API key (no user) with the 422", () => {
+    const error: Exception = thrownBy(() => {
+      pinQueryToRequestingUser(
+        {},
+        { tenantId: ObjectID.generate(), userType: UserType.API },
+        "createdByUserId",
+      );
+    });
+
+    expect(error).toBeInstanceOf(NotAuthorizedException);
+    expect(error).not.toBeInstanceOf(NotAuthenticatedException);
+    expect(error.code).toBe(422);
+    expect(error.message).toBe(
+      "AI conversations are personal and can only be accessed by the user who created them.",
+    );
+  });
+
+  test("master admin bypasses the pin without a user", () => {
+    const query: Record<string, unknown> = {};
+
+    const pinned: Record<string, unknown> = pinQueryToRequestingUser(
+      query,
+      { isMasterAdmin: true },
+      "createdByUserId",
+    );
+
+    expect(pinned["createdByUserId"]).toBeUndefined();
+  });
+
+  test("a signed-in user is pinned even when userType is not set", () => {
+    const userId: ObjectID = ObjectID.generate();
+
+    const pinned: Record<string, unknown> = pinQueryToRequestingUser(
+      {},
+      { userId, userType: UserType.User },
+      "createdByUserId",
+    );
+
+    expect(pinned["createdByUserId"]).toBe(userId);
   });
 });

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

@@ -25,6 +25,10 @@ import AIChatPageContextType, {
   AIChatPageContext,
 } from "../../../../Types/AI/AIChatPageContext";
 import AIChatPermissionMode from "../../../../Types/AI/AIChatPermissionMode";
+import {
+  AIResourceSubresourceKind,
+  AIResourceType,
+} from "../../../../Types/AI/AIResourceContext";
 import AIRunStatus from "../../../../Types/AI/AIRunStatus";
 import {
   AIChatCitation,
@@ -357,7 +361,7 @@ describe("buildReplayedHistoryMessage", () => {
 const INCIDENT_ID: string = "0b6ff65a-71a1-40b0-8b9c-6c11f5f6a123";
 
 function buildRequest(data?: {
-  pageContext?: AIChatPageContext | undefined;
+  pageContext?: AIChatPageContext | null | undefined;
 }): ChatTurnRequest {
   return {
     projectId: ObjectID.generate(),
@@ -510,6 +514,138 @@ describe("ChatAgentRunner.runTurn — cooperative cancellation", () => {
 });
 
 describe("ChatAgentRunner.runTurn — page context persistence", () => {
+  test("persists a newly selected pod and reuses its full identity on the next turn", async () => {
+    const conversation: AIConversation = new AIConversation();
+    conversation.pageContext = {
+      type: AIChatPageContextType.Resource,
+      resourceType: AIResourceType.KubernetesCluster,
+      entityId: INCIDENT_ID,
+      subresource: {
+        kind: AIResourceSubresourceKind.Pod,
+        key: "checkout-old",
+        namespace: "payments",
+      },
+    };
+    const pageContext: AIChatPageContext = {
+      type: AIChatPageContextType.Resource,
+      resourceType: AIResourceType.KubernetesCluster,
+      entityId: INCIDENT_ID,
+      entityTitle: "Production / pod: checkout-current",
+      subresource: {
+        kind: AIResourceSubresourceKind.Pod,
+        key: "checkout-current",
+        namespace: "payments",
+      },
+    };
+    const spies: RunnerSpies = installRunnerSpies({
+      conversation,
+      titleCount: 5,
+    });
+    /*
+     * Keep the mocked database read consistent with writes the real runner
+     * actually makes. Without a persistence write the next turn sees the old pod.
+     */
+    spies.conversationUpdateOneById.mockImplementation(
+      async (update: { data?: JSONObject }): Promise<number> => {
+        if (update.data?.["pageContext"] !== undefined) {
+          conversation.pageContext = update.data[
+            "pageContext"
+          ] as unknown as AIChatPageContext;
+        }
+        return 1;
+      },
+    );
+
+    const request: ChatTurnRequest = buildRequest({ pageContext });
+    await ChatAgentRunner.runTurn(request);
+    await flushAsync();
+
+    expect(
+      findCallWithDataKey(spies.conversationUpdateOneById, "pageContext"),
+    ).toEqual({ pageContext });
+    const firstPrompt: string = (
+      spies.executeWithLogging.mock.calls[0]?.[0] as AILogRequest
+    ).messages[0]!.content;
+    expect(firstPrompt).toContain(JSON.stringify(pageContext.subresource));
+
+    spies.executeWithLogging.mockClear();
+    spies.conversationUpdateOneById.mockClear();
+    await ChatAgentRunner.runTurn({
+      ...request,
+      assistantMessageId: ObjectID.generate(),
+      aiRunId: ObjectID.generate(),
+      pageContext: undefined,
+    });
+    await flushAsync();
+
+    const nextPrompt: string = (
+      spies.executeWithLogging.mock.calls[0]?.[0] as AILogRequest
+    ).messages[0]!.content;
+    expect(nextPrompt).toContain('"resourceType":"KubernetesCluster"');
+    expect(nextPrompt).toContain(`"resourceId":"${INCIDENT_ID}"`);
+    expect(nextPrompt).toContain(JSON.stringify(pageContext.subresource));
+    expect(nextPrompt).not.toContain("checkout-old");
+    expect(
+      findCallWithDataKey(spies.conversationUpdateOneById, "pageContext"),
+    ).toBeUndefined();
+  });
+
+  test("explicitly detaching clears the saved subject and omits it from the prompt", async () => {
+    const conversation: AIConversation = new AIConversation();
+    conversation.pageContext = {
+      type: AIChatPageContextType.RumApplication,
+      entityId: INCIDENT_ID,
+      entityTitle: "Checkout browser",
+    };
+    const spies: RunnerSpies = installRunnerSpies({
+      conversation,
+      titleCount: 5,
+    });
+
+    await ChatAgentRunner.runTurn(buildRequest({ pageContext: null }));
+    await flushAsync();
+
+    expect(
+      findCallWithDataKey(spies.conversationUpdateOneById, "pageContext"),
+    ).toEqual({ pageContext: null });
+    const llmRequest: AILogRequest = spies.executeWithLogging.mock
+      .calls[0]?.[0] as AILogRequest;
+    expect(llmRequest.messages[0]?.content).not.toContain(
+      "## Current page context",
+    );
+    expect(llmRequest.messages[0]?.content).not.toContain(INCIDENT_ID);
+  });
+
+  test("a RUM application replaces the previous module as the conversation subject", async () => {
+    const conversation: AIConversation = new AIConversation();
+    conversation.pageContext = { type: AIChatPageContextType.MonitorsList };
+    const spies: RunnerSpies = installRunnerSpies({
+      conversation,
+      titleCount: 5,
+    });
+    const pageContext: AIChatPageContext = {
+      type: AIChatPageContextType.RumApplication,
+      entityId: INCIDENT_ID,
+      entityTitle: "Checkout browser",
+    };
+
+    await ChatAgentRunner.runTurn(buildRequest({ pageContext }));
+    await flushAsync();
+
+    expect(
+      findCallWithDataKey(spies.conversationUpdateOneById, "pageContext"),
+    ).toEqual({ pageContext });
+    const llmRequest: AILogRequest = spies.executeWithLogging.mock
+      .calls[0]?.[0] as AILogRequest;
+    expect(llmRequest.messages[0]?.content).toContain(
+      `rumApplicationId="${INCIDENT_ID}"`,
+    );
+    expect(llmRequest.messages[0]?.content).toContain("query_rum_web_vitals");
+    expect(llmRequest.messages[0]?.content).not.toContain(
+      "browsing the monitors list",
+    );
+  });
+
   test("persists a fresh page context on the conversation and folds it into the prompt", async () => {
     const pageContext: AIChatPageContext = {
       type: AIChatPageContextType.Incident,