@vellumai/assistant 0.6.0 → 0.6.2

package/src/__tests__/conversation-analysis-routes.test.ts

@@ -0,0 +1,169 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+const mockResolveConversationId = mock((id: string) => id);
+const mockGetConversation = mock(() => ({
+  id: "conv-1",
+  title: "Source",
+  conversationType: "normal",
+}));
+const mockGetMessages = mock(() => [{ id: "m-source" }]);
+const mockCreateConversation = mock(() => ({ id: "analysis-1" }));
+const mockAddMessage = mock(async () => ({ id: "msg-1" }));
+
+mock.module("../memory/conversation-key-store.js", () => ({
+  resolveConversationId: mockResolveConversationId,
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversation: mockGetConversation,
+  getMessages: mockGetMessages,
+  createConversation: mockCreateConversation,
+  addMessage: mockAddMessage,
+}));
+
+mock.module("../export/transcript-formatter.js", () => ({
+  buildAnalysisTranscript: () => "user: hi",
+}));
+
+import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import type { SendMessageDeps } from "../runtime/http-types.js";
+import { conversationAnalysisRouteDefinitions } from "../runtime/routes/conversation-analysis-routes.js";
+
+beforeEach(() => {
+  mockResolveConversationId.mockClear();
+  mockGetConversation.mockClear();
+  mockGetMessages.mockClear();
+  mockCreateConversation.mockClear();
+  mockAddMessage.mockClear();
+});
+
+function makeConversation() {
+  return {
+    setTrustContext: mock(() => {}),
+    ensureActorScopedHistory: mock(() => Promise.resolve()),
+    setSubagentAllowedTools: mock(() => {}),
+    updateClient: mock(() => {}),
+    processing: false,
+    abortController: null as AbortController | null,
+    currentRequestId: null as string | null,
+    runAgentLoop: mock(() => Promise.resolve()),
+  };
+}
+
+describe("POST /v1/conversations/:id/analyze", () => {
+  test("runs headless analysis with unknown trust and no tools when no subscriber is present", async () => {
+    const conversation = makeConversation();
+    const assistantEventHub = new AssistantEventHub();
+    const sendMessageDeps = {
+      getOrCreateConversation: mock(async () => conversation),
+      assistantEventHub,
+      resolveAttachments: () => [],
+    } as unknown as SendMessageDeps;
+
+    const routes = conversationAnalysisRouteDefinitions({
+      sendMessageDeps,
+      buildConversationDetailResponse: () => ({ id: "analysis-1" }),
+    });
+    const route = routes.find(
+      (r) => r.method === "POST" && r.endpoint === "conversations/:id/analyze",
+    );
+    if (!route) throw new Error("analyze route missing");
+
+    const req = new Request("http://localhost/v1/conversations/conv-1/analyze", {
+      method: "POST",
+    });
+
+    const res = await route.handler({
+      req,
+      url: new URL(req.url),
+      server: null as never,
+      authContext: {} as never,
+      params: { id: "conv-1" },
+    });
+
+    expect(res.status).toBe(200);
+    expect(mockAddMessage).toHaveBeenCalledWith(
+      "analysis-1",
+      "user",
+      expect.any(String),
+      { provenanceTrustClass: "unknown" },
+    );
+    expect(conversation.setTrustContext).toHaveBeenCalledWith({
+      trustClass: "unknown",
+      sourceChannel: "vellum",
+    });
+    expect(conversation.ensureActorScopedHistory).toHaveBeenCalledTimes(1);
+    expect(conversation.setSubagentAllowedTools).toHaveBeenCalledTimes(1);
+    const allowedTools = (
+      conversation.setSubagentAllowedTools.mock.calls as unknown as Array<
+        [Set<string> | undefined]
+      >
+    )[0]?.[0];
+    expect(allowedTools).toBeInstanceOf(Set);
+    expect(allowedTools?.size).toBe(0);
+    expect(conversation.updateClient).toHaveBeenCalledWith(
+      expect.any(Function),
+      true,
+    );
+    expect(conversation.runAgentLoop).toHaveBeenCalledWith(
+      expect.any(String),
+      "msg-1",
+      expect.any(Function),
+      expect.objectContaining({ isInteractive: false, isUserMessage: true }),
+    );
+  });
+
+  test("marks analysis interactive when a matching subscriber is already connected", async () => {
+    const conversation = makeConversation();
+    const assistantEventHub = new AssistantEventHub();
+    assistantEventHub.subscribe(
+      { assistantId: DAEMON_INTERNAL_ASSISTANT_ID },
+      () => {},
+    );
+    const sendMessageDeps = {
+      getOrCreateConversation: mock(async () => conversation),
+      assistantEventHub,
+      resolveAttachments: () => [],
+    } as unknown as SendMessageDeps;
+
+    const routes = conversationAnalysisRouteDefinitions({
+      sendMessageDeps,
+      buildConversationDetailResponse: () => ({ id: "analysis-1" }),
+    });
+    const route = routes.find(
+      (r) => r.method === "POST" && r.endpoint === "conversations/:id/analyze",
+    );
+    if (!route) throw new Error("analyze route missing");
+
+    const req = new Request("http://localhost/v1/conversations/conv-1/analyze", {
+      method: "POST",
+    });
+
+    await route.handler({
+      req,
+      url: new URL(req.url),
+      server: null as never,
+      authContext: {} as never,
+      params: { id: "conv-1" },
+    });
+
+    expect(conversation.updateClient).toHaveBeenCalledWith(
+      expect.any(Function),
+      false,
+    );
+    expect(conversation.runAgentLoop).toHaveBeenCalledWith(
+      expect.any(String),
+      "msg-1",
+      expect.any(Function),
+      expect.objectContaining({ isInteractive: true, isUserMessage: true }),
+    );
+  });
+});

package/src/__tests__/conversation-directories-parse.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  getConversationDirName,
+  parseConversationDirName,
+} from "../memory/conversation-directories.js";
+
+describe("parseConversationDirName", () => {
+  describe("round-trip with getConversationDirName", () => {
+    test("round-trips a UUID-shaped id", () => {
+      const id = "4ae7ea90-86e4-446a-8673-7bba94ecfea1";
+      const createdAtMs = Date.parse("2026-04-07T10:47:23.075Z");
+      const name = getConversationDirName(id, createdAtMs);
+      const parsed = parseConversationDirName(name);
+      expect(parsed).toEqual({ conversationId: id, createdAtMs });
+    });
+
+    test("round-trips an id with embedded hyphens", () => {
+      const id = "conv-with-hyphens-123";
+      const createdAtMs = Date.parse("2024-01-15T00:00:00.000Z");
+      const name = getConversationDirName(id, createdAtMs);
+      const parsed = parseConversationDirName(name);
+      expect(parsed).toEqual({ conversationId: id, createdAtMs });
+    });
+
+    test("round-trips an id with embedded underscores", () => {
+      const id = "foo_bar_baz";
+      const createdAtMs = Date.parse("2025-12-31T23:59:59.999Z");
+      const name = getConversationDirName(id, createdAtMs);
+      const parsed = parseConversationDirName(name);
+      expect(parsed).toEqual({ conversationId: id, createdAtMs });
+    });
+  });
+
+  describe("exact parsing against literal example", () => {
+    test("parses the canonical example from the spec", () => {
+      const name =
+        "2026-04-07T10-47-23.075Z_4ae7ea90-86e4-446a-8673-7bba94ecfea1";
+      const parsed = parseConversationDirName(name);
+      expect(parsed).not.toBeNull();
+      expect(parsed?.conversationId).toBe(
+        "4ae7ea90-86e4-446a-8673-7bba94ecfea1",
+      );
+      expect(parsed?.createdAtMs).toBe(Date.parse("2026-04-07T10:47:23.075Z"));
+    });
+  });
+
+  describe("returns null for malformed input", () => {
+    test("returns null for empty string", () => {
+      expect(parseConversationDirName("")).toBeNull();
+    });
+
+    test("returns null for missing underscore", () => {
+      expect(parseConversationDirName("2026-04-07T10-47-23.075Z")).toBeNull();
+    });
+
+    test("returns null for legacy format (id first, timestamp second)", () => {
+      expect(
+        parseConversationDirName(
+          "4ae7ea90-86e4-446a-8673-7bba94ecfea1_2026-04-07T10-47-23.075Z",
+        ),
+      ).toBeNull();
+    });
+
+    test("returns null for non-ISO prefix", () => {
+      expect(parseConversationDirName("hello_world")).toBeNull();
+    });
+
+    test("returns null for random garbage", () => {
+      expect(parseConversationDirName("drafts/foo")).toBeNull();
+    });
+
+    test("returns null when the conversation id is '.'", () => {
+      expect(parseConversationDirName("2025-01-15T00-00-00.000Z_.")).toBeNull();
+    });
+
+    test("returns null when the conversation id is '..'", () => {
+      expect(
+        parseConversationDirName("2025-01-15T00-00-00.000Z_.."),
+      ).toBeNull();
+    });
+
+    test("returns null when the conversation id contains a forward slash", () => {
+      expect(
+        parseConversationDirName("2025-01-15T00-00-00.000Z_foo/bar"),
+      ).toBeNull();
+    });
+
+    test("returns null when the conversation id contains a backslash", () => {
+      expect(
+        parseConversationDirName("2025-01-15T00-00-00.000Z_foo\\bar"),
+      ).toBeNull();
+    });
+  });
+
+  describe("ids containing underscores", () => {
+    test("captures everything after the timestamp as the conversationId", () => {
+      const name = "2026-04-07T10-47-23.075Z_my_test_id";
+      const parsed = parseConversationDirName(name);
+      expect(parsed).not.toBeNull();
+      expect(parsed?.conversationId).toBe("my_test_id");
+      expect(parsed?.createdAtMs).toBe(Date.parse("2026-04-07T10:47:23.075Z"));
+    });
+  });
+});

package/src/__tests__/conversation-history-web-search.test.ts

@@ -41,7 +41,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   deleteMessageById: (messageId: string) => {
     deletedMessageIds.push(messageId);
     dbMessages = dbMessages.filter((m) => m.id !== messageId);
-    return { segmentIds: [], orphanedItemIds: [] };
+    return { segmentIds: [], deletedSummaryIds: [] };
   },
   updateMessageContent: (messageId: string, content: string) => {
     updatedMessages.push({ id: messageId, content });