@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/__tests__/conversation-enabledplugins-route.test.ts

@@ -0,0 +1,184 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+const config = {
+  llm: {
+    profiles: {},
+  },
+};
+
+mock.module("../config/loader.js", () => ({
+  loadConfig: () => config,
+  getConfig: () => config,
+}));
+
+import {
+  createConversation,
+  getConversation,
+  setConversationEnabledPlugins,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { ROUTES } from "../runtime/routes/conversation-management-routes.js";
+import { BadRequestError, NotFoundError } from "../runtime/routes/errors.js";
+import { buildConversationDetailResponse } from "../runtime/services/conversation-serializer.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
+
+await initializeDb();
+
+const pluginsRoute = ROUTES.find(
+  (r) => r.operationId === "conversations_by_id_enabledplugins_put",
+)!;
+
+function clearTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM conversation_assistant_attention_state");
+  db.run("DELETE FROM external_conversation_bindings");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+describe("PUT /v1/conversations/:id/enabledplugins", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  afterAll(() => {
+    resetDbForTesting();
+    mock.restore();
+  });
+
+  test("persists a string[] scope and reflects it on the conversation", async () => {
+    const conversation = createConversation("enabledplugins-route");
+
+    const result = await pluginsRoute.handler({
+      pathParams: { id: conversation.id },
+      body: { enabledPlugins: ["plugin-a", "plugin-b"] },
+      headers: {},
+    });
+
+    expect(result).toMatchObject({
+      conversationId: conversation.id,
+      enabledPlugins: ["plugin-a", "plugin-b"],
+    });
+    expect(getConversation(conversation.id)?.enabledPlugins).toEqual([
+      "plugin-a",
+      "plugin-b",
+    ]);
+
+    // The HTTP conversation-detail response (what the web `conversationsByIdGet`
+    // reads) must also carry the scope, not just the internal DB getter.
+    const detail = buildConversationDetailResponse(conversation.id);
+    expect(detail?.conversation.enabledPlugins).toEqual([
+      "plugin-a",
+      "plugin-b",
+    ]);
+  });
+
+  test("detail response omits enabledPlugins by default and preserves an explicit []", async () => {
+    const conversation = createConversation("enabledplugins-detail-shape");
+
+    // Default (no per-chat restriction): the field is omitted from the wire.
+    expect(
+      "enabledPlugins" in buildConversationDetailResponse(conversation.id)!
+        .conversation,
+    ).toBe(false);
+
+    // Explicit empty scope (user cleared all optional plugins): preserved as [].
+    await pluginsRoute.handler({
+      pathParams: { id: conversation.id },
+      body: { enabledPlugins: [] },
+      headers: {},
+    });
+    expect(
+      buildConversationDetailResponse(conversation.id)?.conversation
+        .enabledPlugins,
+    ).toEqual([]);
+  });
+
+  test("clears the scope to default when enabledPlugins is null", async () => {
+    const conversation = createConversation("enabledplugins-clear");
+
+    await pluginsRoute.handler({
+      pathParams: { id: conversation.id },
+      body: { enabledPlugins: ["plugin-x"] },
+      headers: {},
+    });
+    expect(getConversation(conversation.id)?.enabledPlugins).toEqual([
+      "plugin-x",
+    ]);
+
+    const result = await pluginsRoute.handler({
+      pathParams: { id: conversation.id },
+      body: { enabledPlugins: null },
+      headers: {},
+    });
+
+    expect(result).toMatchObject({
+      conversationId: conversation.id,
+      enabledPlugins: null,
+    });
+    expect(getConversation(conversation.id)?.enabledPlugins).toBeNull();
+  });
+
+  test("rejects a non-array, non-null body with BadRequestError", async () => {
+    const conversation = createConversation("enabledplugins-bad");
+
+    await expect(
+      pluginsRoute.handler({
+        pathParams: { id: conversation.id },
+        body: { enabledPlugins: "not-an-array" },
+        headers: {},
+      }),
+    ).rejects.toThrow(BadRequestError);
+    expect(getConversation(conversation.id)?.enabledPlugins).toBeNull();
+  });
+
+  test("rejects an array containing a non-string with BadRequestError", async () => {
+    const conversation = createConversation("enabledplugins-bad-element");
+
+    await expect(
+      pluginsRoute.handler({
+        pathParams: { id: conversation.id },
+        body: { enabledPlugins: ["ok", 123] },
+        headers: {},
+      }),
+    ).rejects.toThrow(BadRequestError);
+    expect(getConversation(conversation.id)?.enabledPlugins).toBeNull();
+  });
+
+  test("rejects a missing enabledPlugins field without clearing the scope", async () => {
+    const conversation = createConversation("enabledplugins-missing");
+    // Seed an explicit scope, then send a body with no `enabledPlugins`.
+    setConversationEnabledPlugins(conversation.id, ["plugin-a"]);
+
+    await expect(
+      pluginsRoute.handler({
+        pathParams: { id: conversation.id },
+        body: {},
+        headers: {},
+      }),
+    ).rejects.toThrow(BadRequestError);
+    // The existing scope must survive a malformed request (null is the only
+    // explicit clear signal).
+    expect(getConversation(conversation.id)?.enabledPlugins).toEqual([
+      "plugin-a",
+    ]);
+  });
+
+  test("throws NotFoundError when the conversation does not exist", async () => {
+    await expect(
+      pluginsRoute.handler({
+        pathParams: { id: "missing" },
+        body: { enabledPlugins: [] },
+        headers: {},
+      }),
+    ).rejects.toThrow(NotFoundError);
+  });
+});

package/src/__tests__/conversation-error.test.ts

@@ -520,24 +520,6 @@ describe("classifyConversationError", () => {
     });
   });
 
-  describe("regenerate phase", () => {
-    it("returns REGENERATE_FAILED with nested classification info", () => {
-      const ctx: ErrorContext = { phase: "regenerate" };
-      const result = classifyConversationError(new Error("ECONNREFUSED"), ctx);
-      expect(result.code).toBe("REGENERATE_FAILED");
-      expect(result.retryable).toBe(true);
-      expect(result.userMessage).toContain("regenerate");
-      expect(result.errorCategory).toContain("regenerate:");
-    });
-
-    it("returns REGENERATE_FAILED for generic errors", () => {
-      const ctx: ErrorContext = { phase: "regenerate" };
-      const result = classifyConversationError(new Error("unknown issue"), ctx);
-      expect(result.code).toBe("REGENERATE_FAILED");
-      expect(result.retryable).toBe(true);
-    });
-  });
-
   describe("generic errors", () => {
     it("classifies unknown errors as CONVERSATION_PROCESSING_FAILED with error summary", () => {
       const result = classifyConversationError(

package/src/__tests__/conversation-fork-crud.test.ts

@@ -1316,6 +1316,7 @@ describe("forkConversation", () => {
       skipIndexing: true,
     });
     rawRun(
+      "test:setGroupId",
       "UPDATE conversations SET group_id = ? WHERE id = ?",
       "system:pinned",
       source.id,
@@ -1328,6 +1329,7 @@ describe("forkConversation", () => {
       .where(eq(conversations.id, fork.id))
       .get();
     const groupIdRow = rawGet<{ group_id: string | null }>(
+      "test:fetchForkGroupId",
       "SELECT group_id FROM conversations WHERE id = ?",
       fork.id,
     );
@@ -1354,6 +1356,7 @@ describe("forkConversation", () => {
       .where(eq(conversations.id, fork.id))
       .get();
     const groupIdRow = rawGet<{ group_id: string | null }>(
+      "test:fetchForkGroupId",
       "SELECT group_id FROM conversations WHERE id = ?",
       fork.id,
     );
@@ -1388,6 +1391,70 @@ describe("forkConversation", () => {
     const childState = await hydrateActivationState(db, fork.id);
     expect(childState?.currentTurn).toBe(1);
   });
+
+  test("batch-copies every message with a complete id map and last-assistant pointer", async () => {
+    // Multi-message transcript whose final row is a user message (after the
+    // last assistant). The batched insert must map every source row to a
+    // distinct forked row and track the latest *assistant* message — not the
+    // trailing user row — for the attention pointer.
+    const source = createConversation("Batch fork thread");
+    await addMessage(source.id, "user", "Question 1", { skipIndexing: true });
+    await addMessage(source.id, "assistant", "Answer 1", {
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "user", "Question 2", { skipIndexing: true });
+    const lastAssistant = await addMessage(source.id, "assistant", "Answer 2", {
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "user", "Trailing user message", {
+      skipIndexing: true,
+    });
+
+    const sourceMessages = getMessages(source.id);
+    const fork = forkConversation({ conversationId: source.id });
+    const forkMessages = getMessages(fork.id);
+
+    // Same count, roles, content, and ordering as the source.
+    expect(forkMessages).toHaveLength(sourceMessages.length);
+    expect(forkMessages.map((m) => m.role)).toEqual(
+      sourceMessages.map((m) => m.role),
+    );
+    expect(forkMessages.map((m) => m.content)).toEqual(
+      sourceMessages.map((m) => m.content),
+    );
+
+    // Every source message maps to exactly one distinct forked message via the
+    // forkSourceMessageId stamped into each copy's metadata.
+    const sourceToFork = new Map<string, string>();
+    for (const forked of forkMessages) {
+      const md = parseMetadata(forked.metadata) as {
+        forkSourceMessageId?: string;
+      } | null;
+      expect(md?.forkSourceMessageId).toBeDefined();
+      sourceToFork.set(md!.forkSourceMessageId!, forked.id);
+    }
+    expect(sourceToFork.size).toBe(sourceMessages.length);
+    for (const sourceMessage of sourceMessages) {
+      expect(sourceToFork.has(sourceMessage.id)).toBe(true);
+    }
+    // Forked ids are all fresh — no source id is reused.
+    expect(new Set(forkMessages.map((m) => m.id)).size).toBe(
+      forkMessages.length,
+    );
+    expect(
+      forkMessages.every((m, index) => m.id !== sourceMessages[index]?.id),
+    ).toBe(true);
+
+    // The attention pointer (driven by latestForkedAssistant) targets the
+    // forked copy of the last assistant row, not the trailing user message.
+    const forkState = getAttentionStateByConversationIds([fork.id]).get(
+      fork.id,
+    );
+    expect(forkState?.lastSeenAssistantMessageId).toBe(
+      sourceToFork.get(lastAssistant.id),
+    );
+    expect(forkState?.lastSeenAssistantMessageAt).toBe(lastAssistant.createdAt);
+  });
 });
 
 describe("forkConversation + memory_retrospective_state", () => {

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

@@ -82,8 +82,6 @@ mock.module("../persistence/embeddings/qdrant-client.js", () => ({
 import {
   consolidateAssistantMessages,
   findLastUndoableUserMessageIndex,
-  type HistoryConversationContext,
-  regenerate,
 } from "../daemon/conversation-history.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 
@@ -347,141 +345,6 @@ describe("isUndoableUserMessage with web_search_tool_result", () => {
   });
 });
 
-// ── Test 4: regenerate handles conversations with web_search_tool_result ─
-
-describe("regenerate with web_search_tool_result", () => {
-  beforeEach(() => {
-    dbMessages = [];
-    deletedMessageIds = [];
-    updatedMessages = [];
-  });
-
-  test("regenerate skips web_search_tool_result-only user messages when finding last real user message", async () => {
-    const conversationId = "conv-ws-regen";
-
-    // DB messages: user → assistant(server_tool_use) → user(web_search_tool_result) → assistant(text)
-    dbMessages = [
-      makeDbMessage(
-        "msg-u1",
-        conversationId,
-        "user",
-        [{ type: "text", text: "search for X" }],
-        1000,
-      ),
-      makeDbMessage(
-        "msg-a1",
-        conversationId,
-        "assistant",
-        [
-          {
-            type: "server_tool_use",
-            id: "srvtoolu_regen",
-            name: "web_search",
-            input: { query: "X" },
-          },
-        ],
-        2000,
-      ),
-      makeDbMessage(
-        "msg-ws",
-        conversationId,
-        "user",
-        [
-          {
-            type: "web_search_tool_result",
-            tool_use_id: "srvtoolu_regen",
-            content: [],
-          },
-        ],
-        3000,
-      ),
-      makeDbMessage(
-        "msg-a2",
-        conversationId,
-        "assistant",
-        [{ type: "text", text: "Results here." }],
-        4000,
-      ),
-    ];
-
-    // In-memory messages matching DB
-    const inMemoryMessages: Message[] = [
-      {
-        role: "user",
-        content: [{ type: "text", text: "search for X" }],
-      },
-      {
-        role: "assistant",
-        content: [
-          {
-            type: "server_tool_use",
-            id: "srvtoolu_regen",
-            name: "web_search",
-            input: { query: "X" },
-          },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          {
-            type: "web_search_tool_result",
-            tool_use_id: "srvtoolu_regen",
-            content: [],
-          },
-        ],
-      },
-      {
-        role: "assistant",
-        content: [{ type: "text", text: "Results here." }],
-      },
-    ];
-
-    let agentLoopCalled = false;
-    let agentLoopContent = "";
-    let agentLoopUserMessageId = "";
-
-    const events: Array<{ type: string; message?: string }> = [];
-
-    let processing = false;
-    const session: HistoryConversationContext = {
-      conversationId,
-      traceEmitter: {
-        emit: () => {},
-      } as unknown as HistoryConversationContext["traceEmitter"],
-      sendToClient: (msg) => events.push(msg),
-      messages: [...inMemoryMessages],
-      isProcessing: () => processing,
-      setProcessing: (value: boolean) => {
-        processing = value;
-      },
-      abortController: null,
-      async runAgentLoop(content, userMessageId) {
-        agentLoopCalled = true;
-        agentLoopContent = content;
-        agentLoopUserMessageId = userMessageId;
-      },
-    };
-
-    await regenerate(session);
-
-    // regenerate should find the real user message (msg-u1) and skip the
-    // web_search_tool_result-only message (msg-ws).
-    // BUG: Currently, regenerate only checks for tool_result in the
-    // `parsed.every(b => b.type === "tool_result")` check, so msg-ws
-    // is treated as a real user message, and regenerate gets confused.
-
-    expect(agentLoopCalled).toBe(true);
-    expect(agentLoopUserMessageId).toBe("msg-u1");
-    expect(agentLoopContent).toBe("search for X");
-
-    // Messages after the user message should be deleted
-    expect(deletedMessageIds).toContain("msg-a1");
-    expect(deletedMessageIds).toContain("msg-ws");
-    expect(deletedMessageIds).toContain("msg-a2");
-  });
-});
-
 // ── Test 5: ensureToolPairing preserves server_tool_use / web_search_tool_result pairs ─
 
 describe("ensureToolPairing with server_tool_use / web_search_tool_result", () => {
@@ -759,6 +622,13 @@ describe("web_search_tool_result structural guard", () => {
     "context/post-turn-tool-result-truncation.ts",
     "context/tool-result-spool.ts",
 
+    // Outbound sanitize bundle: the media-strip and AX-tree transforms
+    // operate on locally-executed tool results (media contentBlocks and
+    // <ax-tree> text), which web_search_tool_result blocks never carry.
+    // Web-search blocks are handled by the bundle's own third transform
+    // (stripHistoricalWebSearchResults), so nothing is silently dropped.
+    "context/outbound-sanitize.ts",
+
     // Anthropic provider type guards define API-specific discriminants.
     // It has a separate isWebSearchToolResultBlock for the other type.
     "providers/anthropic/client.ts",

package/src/__tests__/conversation-initial-prompt.test.ts

@@ -0,0 +1,110 @@
+/**
+ * Tests for construction-time system-prompt resolution.
+ *
+ * A conversation's system prompt is built once at construction and frozen for
+ * every turn (the agent loop never re-resolves it), so the persona slot must
+ * resolve correctly here. With no construction-time identity the default-build
+ * path must warm the gateway guardian binding BEFORE building (else a cold cache
+ * pins `users/default.md`); a channel-routed conversation that already carries
+ * the requester's trust context must build with it so the requester's profile
+ * resolves instead of the guardian/default one.
+ *
+ * Dependency seams are injected so this exercises the sequencing without mocking
+ * the widely-imported guardian-delivery / system-prompt modules (those global
+ * module mocks leak across files in the shared-process test runner).
+ */
+import { describe, expect, test } from "bun:test";
+
+import {
+  resolveInitialSystemPrompt,
+  warmGuardianBindings,
+} from "../daemon/conversation-initial-prompt.js";
+import type { ConversationCreateOptions } from "../daemon/handlers/shared.js";
+import type { TrustContext } from "../daemon/trust-context.js";
+
+function spyDeps() {
+  const calls: string[] = [];
+  const builtWith: Array<TrustContext | undefined> = [];
+  return {
+    calls,
+    builtWith,
+    deps: {
+      warm: async () => {
+        calls.push("warm");
+      },
+      build: (trustContext: TrustContext | undefined) => {
+        calls.push("build");
+        builtWith.push(trustContext);
+        return "BUILD";
+      },
+    },
+  };
+}
+
+const REQUESTER_TRUST = {
+  sourceChannel: "slack",
+  trustClass: "trusted_contact",
+  requesterExternalUserId: "user-123",
+} as unknown as TrustContext;
+
+describe("warmGuardianBindings", () => {
+  test("warms both the vellum-channel key and the unfiltered fallback key", async () => {
+    const keys: string[] = [];
+    await warmGuardianBindings(async (input) => {
+      keys.push(input?.channelTypes?.join(",") ?? "ALL");
+      return null;
+    });
+    // Both keys the persona resolver reads — peekGuardianForChannel("vellum")
+    // and its peekAnyGuardian() fallback — must be warmed.
+    expect(keys.sort()).toEqual(["ALL", "vellum"]);
+  });
+});
+
+describe("resolveInitialSystemPrompt", () => {
+  test("no construction-time identity: warms the guardian binding, then builds with no trust context", async () => {
+    const { calls, builtWith, deps } = spyDeps();
+    const result = await resolveInitialSystemPrompt(undefined, deps);
+
+    expect(result).toBe("BUILD");
+    // The warm MUST precede the build so the persona slot resolves the
+    // guardian's users/<slug>.md instead of users/default.md on a cold cache.
+    expect(calls).toEqual(["warm", "build"]);
+    expect(builtWith).toEqual([undefined]);
+  });
+
+  test("channel-routed: threads the requester trust context and skips the guardian warm", async () => {
+    const { calls, builtWith, deps } = spyDeps();
+    const result = await resolveInitialSystemPrompt(
+      { trustContext: REQUESTER_TRUST } as ConversationCreateOptions,
+      deps,
+    );
+
+    expect(result).toBe("BUILD");
+    // The requester's identity resolves the persona via a DB lookup, so no
+    // guardian-cache warm is needed and the trust context must reach the build.
+    expect(calls).toEqual(["build"]);
+    expect(builtWith).toEqual([REQUESTER_TRUST]);
+  });
+
+  test("an explicit override is used verbatim and skips the warm and build", async () => {
+    const { calls, deps } = spyDeps();
+    const result = await resolveInitialSystemPrompt(
+      { systemPromptOverride: "CUSTOM PROMPT" } as ConversationCreateOptions,
+      deps,
+    );
+
+    expect(result).toBe("CUSTOM PROMPT");
+    expect(calls).toEqual([]);
+  });
+
+  test("an explicit empty-string override is honored verbatim (not treated as absent)", async () => {
+    const { calls, deps } = spyDeps();
+    const result = await resolveInitialSystemPrompt(
+      { systemPromptOverride: "" } as ConversationCreateOptions,
+      deps,
+    );
+
+    expect(result).toBe("");
+    expect(calls).toEqual([]);
+  });
+});