@vellumai/assistant 0.8.0 → 0.8.2

package/src/runtime/routes/__tests__/conversation-query-routes.test.ts

@@ -14,6 +14,12 @@ import {
 
 let rawConfigFixture: Record<string, unknown> = {};
 let savedRawConfig: Record<string, unknown> | null = null;
+// Counters / spies so tests can assert that `commitConfigWrite` ran its
+// post-write side effects. Each `replaceProfileRoute.handler` call that
+// hits `commitConfigWrite` should bump these once.
+let invalidateConfigCacheCalls = 0;
+let initializeProvidersCalls = 0;
+let clearEmbeddingBackendCacheCalls = 0;
 
 mock.module("../../../config/loader.js", () => ({
   loadRawConfig: () => structuredClone(rawConfigFixture),
@@ -26,6 +32,28 @@ mock.module("../../../config/loader.js", () => ({
   ) => {
     Object.assign(target, overrides);
   },
+  // `commitConfigWrite` (used by `handleReplaceInferenceProfile`) pulls
+  // in `getConfig` for the provider reinit's config arg and
+  // `invalidateConfigCache` so the next caller sees the fresh write.
+  // Stub both: getConfig returns whatever was last saved (or the fixture
+  // if nothing has been saved yet) and the cache-invalidation function
+  // is a counter so we can assert it fired.
+  getConfig: () => structuredClone(savedRawConfig ?? rawConfigFixture),
+  invalidateConfigCache: () => {
+    invalidateConfigCacheCalls += 1;
+  },
+}));
+
+mock.module("../../../providers/registry.js", () => ({
+  initializeProviders: async () => {
+    initializeProvidersCalls += 1;
+  },
+}));
+
+mock.module("../../../memory/embedding-backend.js", () => ({
+  clearEmbeddingBackendCache: () => {
+    clearEmbeddingBackendCacheCalls += 1;
+  },
 }));
 
 import type { ConversationCreateType } from "../../../memory/conversation-crud.js";
@@ -78,6 +106,7 @@ function seedConversationAndMessage(args: {
   messageId: string;
   source: string;
   conversationType: ConversationCreateType;
+  totalEstimatedCost?: number;
 }): void {
   const now = Date.now();
   getDb()
@@ -90,6 +119,9 @@ function seedConversationAndMessage(args: {
       source: args.source,
       conversationType: args.conversationType,
       memoryScopeId: "default",
+      ...(args.totalEstimatedCost != null
+        ? { totalEstimatedCost: args.totalEstimatedCost }
+        : {}),
     })
     .run();
   getDb()
@@ -236,9 +268,57 @@ describe("GET /v1/messages/:id/llm-context — conversationKind", () => {
   });
 });
 
+describe("GET /v1/messages/:id/llm-context — conversationTotalEstimatedCostUsd", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  test("returns the conversation's running cost total when present", async () => {
+    seedConversationAndMessage({
+      conversationId: "conv-with-cost",
+      messageId: "msg-with-cost",
+      source: "user",
+      conversationType: "standard",
+      totalEstimatedCost: 1.234,
+    });
+
+    const body = (await dispatchLlmContext("msg-with-cost")) as {
+      conversationTotalEstimatedCostUsd: number | null;
+    };
+
+    expect(body.conversationTotalEstimatedCostUsd).toBeCloseTo(1.234, 5);
+  });
+
+  test("returns 0 when the conversation hasn't accrued any cost yet", async () => {
+    seedConversationAndMessage({
+      conversationId: "conv-no-cost",
+      messageId: "msg-no-cost",
+      source: "user",
+      conversationType: "standard",
+    });
+
+    const body = (await dispatchLlmContext("msg-no-cost")) as {
+      conversationTotalEstimatedCostUsd: number | null;
+    };
+
+    expect(body.conversationTotalEstimatedCostUsd).toBe(0);
+  });
+
+  test("returns null when the message can't be resolved to a conversation", async () => {
+    const body = (await dispatchLlmContext("msg-missing-cost")) as {
+      conversationTotalEstimatedCostUsd: number | null;
+    };
+
+    expect(body.conversationTotalEstimatedCostUsd).toBeNull();
+  });
+});
+
 describe("PUT /v1/config/llm/profiles/:name", () => {
   beforeEach(() => {
     savedRawConfig = null;
+    invalidateConfigCacheCalls = 0;
+    initializeProvidersCalls = 0;
+    clearEmbeddingBackendCacheCalls = 0;
     rawConfigFixture = {
       llm: {
         profiles: {
@@ -264,8 +344,8 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
     };
   });
 
-  test("owns contextWindow maxInputTokens while preserving non-UI profile leaves", () => {
-    const result = replaceProfileRoute.handler({
+  test("owns contextWindow maxInputTokens while preserving non-UI profile leaves", async () => {
+    const result = await replaceProfileRoute.handler({
       pathParams: { name: "custom" },
       body: {
         provider: "openai",
@@ -294,8 +374,8 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
     expect(savedProfile.openrouter).toEqual({ only: ["anthropic"] });
   });
 
-  test("writes only the replacement contextWindow maxInputTokens override", () => {
-    const result = replaceProfileRoute.handler({
+  test("writes only the replacement contextWindow maxInputTokens override", async () => {
+    const result = await replaceProfileRoute.handler({
       pathParams: { name: "custom" },
       body: {
         provider: "openai",
@@ -325,4 +405,200 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
     });
     expect(savedProfile.openrouter).toEqual({ only: ["anthropic"] });
   });
+
+  test("writes provider_connection when present in body", async () => {
+    const result = await replaceProfileRoute.handler({
+      pathParams: { name: "custom" },
+      body: {
+        provider: "openai",
+        provider_connection: "personal-openai",
+        model: "gpt-5.5",
+      },
+    });
+
+    expect(result).toEqual({ ok: true });
+    const savedProfile = (
+      savedRawConfig?.llm as {
+        profiles: Record<string, Record<string, unknown>>;
+      }
+    ).profiles.custom;
+
+    expect(savedProfile.provider).toBe("openai");
+    expect(savedProfile.provider_connection).toBe("personal-openai");
+  });
+
+  test("clears provider_connection when omitted from body (UI-owned key)", async () => {
+    // Seed an existing binding so the test starts from a non-empty state.
+    (
+      rawConfigFixture.llm as {
+        profiles: { custom: Record<string, unknown> };
+      }
+    ).profiles.custom.provider_connection = "stale-openai";
+
+    const result = await replaceProfileRoute.handler({
+      pathParams: { name: "custom" },
+      body: {
+        provider: "openai",
+        model: "gpt-5.5",
+        // provider_connection deliberately omitted — the UI cleared the
+        // picker back to "Any active" and the route must wipe the saved
+        // binding, not silently round-trip it.
+      },
+    });
+
+    expect(result).toEqual({ ok: true });
+    const savedProfile = (
+      savedRawConfig?.llm as {
+        profiles: Record<string, Record<string, unknown>>;
+      }
+    ).profiles.custom;
+
+    expect(savedProfile.provider_connection).toBeUndefined();
+  });
+
+  describe("managed profile guard", () => {
+    beforeEach(() => {
+      // Seed a managed profile alongside the existing custom one.
+      (rawConfigFixture.llm as { profiles: Record<string, unknown> }).profiles[
+        "balanced"
+      ] = {
+        source: "managed",
+        provider: "anthropic",
+        model: "claude-sonnet-4-6",
+        label: "Balanced",
+        status: "active",
+      };
+    });
+
+    test("allows label edit on managed profile, preserving seed fields", async () => {
+      const result = await replaceProfileRoute.handler({
+        pathParams: { name: "balanced" },
+        body: { label: "My Balanced" },
+      });
+
+      expect(result).toEqual({ ok: true });
+      const savedProfile = (
+        savedRawConfig?.llm as {
+          profiles: Record<string, Record<string, unknown>>;
+        }
+      ).profiles.balanced;
+
+      expect(savedProfile.label).toBe("My Balanced");
+      // Seed fields preserved.
+      expect(savedProfile.provider).toBe("anthropic");
+      expect(savedProfile.model).toBe("claude-sonnet-4-6");
+      expect(savedProfile.source).toBe("managed");
+    });
+
+    test("allows status edit on managed profile", async () => {
+      const result = await replaceProfileRoute.handler({
+        pathParams: { name: "balanced" },
+        body: { status: "disabled" },
+      });
+
+      expect(result).toEqual({ ok: true });
+      const savedProfile = (
+        savedRawConfig?.llm as {
+          profiles: Record<string, Record<string, unknown>>;
+        }
+      ).profiles.balanced;
+
+      expect(savedProfile.status).toBe("disabled");
+      expect(savedProfile.provider).toBe("anthropic");
+    });
+
+    test("allows label+status edit together", async () => {
+      const result = await replaceProfileRoute.handler({
+        pathParams: { name: "balanced" },
+        body: { label: "Renamed", status: "disabled" },
+      });
+
+      expect(result).toEqual({ ok: true });
+      const savedProfile = (
+        savedRawConfig?.llm as {
+          profiles: Record<string, Record<string, unknown>>;
+        }
+      ).profiles.balanced;
+
+      expect(savedProfile.label).toBe("Renamed");
+      expect(savedProfile.status).toBe("disabled");
+    });
+
+    test("rejects provider edit on managed profile with disallowed-keys error", async () => {
+      // The handler is `async`, so synchronous BadRequest throws still
+      // surface as a rejected promise; assert via `.rejects.toThrow`.
+      await expect(
+        replaceProfileRoute.handler({
+          pathParams: { name: "balanced" },
+          body: { provider: "openai", model: "gpt-5" },
+        }),
+      ).rejects.toThrow(
+        /Cannot edit managed profile "balanced" fields \[provider, model\]/,
+      );
+    });
+
+    test("rejects mixed allowed+disallowed fields", async () => {
+      // label is allowed but maxTokens is not — must reject without partially
+      // applying label, so saver should never be invoked.
+      await expect(
+        replaceProfileRoute.handler({
+          pathParams: { name: "balanced" },
+          body: { label: "Try", maxTokens: 999 },
+        }),
+      ).rejects.toThrow(
+        /Cannot edit managed profile "balanced" fields \[maxTokens\]/,
+      );
+      expect(savedRawConfig).toBeNull();
+      // Reject path skips commitConfigWrite entirely — no provider reinit
+      // or cache invalidation should fire on a guard rejection.
+      expect(initializeProvidersCalls).toBe(0);
+      expect(invalidateConfigCacheCalls).toBe(0);
+      expect(clearEmbeddingBackendCacheCalls).toBe(0);
+    });
+  });
+
+  describe("commitConfigWrite side effects", () => {
+    test("status flip on managed profile triggers provider reinit + cache invalidation", async () => {
+      // Seed a managed profile that the user will disable. commitConfigWrite
+      // must reinit the provider registry so the status change is reflected
+      // in the running daemon immediately, not at the next watcher tick.
+      (rawConfigFixture.llm as { profiles: Record<string, unknown> }).profiles[
+        "balanced"
+      ] = {
+        source: "managed",
+        provider: "anthropic",
+        model: "claude-sonnet-4-6",
+        label: "Balanced",
+        status: "active",
+      };
+
+      const result = await replaceProfileRoute.handler({
+        pathParams: { name: "balanced" },
+        body: { status: "disabled" },
+      });
+
+      expect(result).toEqual({ ok: true });
+      expect(initializeProvidersCalls).toBe(1);
+      expect(invalidateConfigCacheCalls).toBe(1);
+      expect(clearEmbeddingBackendCacheCalls).toBe(1);
+    });
+
+    test("custom profile provider swap triggers provider reinit + cache invalidation", async () => {
+      // Custom profile path: provider/model swap on a user-owned profile.
+      // Same side-effect contract — registry must reinit so the new
+      // provider is wired into the running daemon without restart.
+      const result = await replaceProfileRoute.handler({
+        pathParams: { name: "custom" },
+        body: {
+          provider: "openai",
+          model: "gpt-5.5",
+        },
+      });
+
+      expect(result).toEqual({ ok: true });
+      expect(initializeProvidersCalls).toBe(1);
+      expect(invalidateConfigCacheCalls).toBe(1);
+      expect(clearEmbeddingBackendCacheCalls).toBe(1);
+    });
+  });
 });

package/src/runtime/routes/__tests__/home-feed-routes.test.ts

@@ -63,28 +63,8 @@ mock.module("../../../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
 }));
 
-// Stub the rollup producer so the on-visit refresh trigger inside
-// handleGetHomeFeed doesn't try to resolve a real provider or touch
-// relationship state. The route calls the producer fire-and-forget,
-// so tests observe the trigger via call-count on this spy rather
-// than awaiting a return value.
-//
-// Default skip reason is `empty_items` — a real LLM attempt that
-// returned nothing to consolidate. Using a real-run skip means the
-// debounce gate holds firm in the default case (matching production
-// semantics); individual tests override with `no_provider` etc. to
-// exercise the rollback path.
-const rollupProducerSpy = mock<() => Promise<unknown>>(async () => ({
-  wroteCount: 0,
-  skippedReason: "empty_items",
-}));
-mock.module("../../../home/rollup-producer.js", () => ({
-  runRollupProducer: rollupProducerSpy,
-}));
-
 // Dynamic imports so module mocks are wired before evaluation.
 const {
-  __resetOnVisitRefreshStateForTests,
   computeGreeting,
   formatRelativeTime,
   handleGetHomeFeed: _handleGetHomeFeed,
@@ -167,17 +147,14 @@ function homeFeedRouteDefinitions() {
 
 type FeedItemFixture = {
   id: string;
-  type: "nudge" | "digest" | "action" | "thread";
+  type: "notification";
   priority: number;
   title: string;
   summary: string;
-  source?: "gmail" | "slack" | "calendar" | "assistant";
   timestamp: string;
   status: "new" | "seen" | "acted_on";
   expiresAt?: string;
-  minTimeAway?: number;
   actions?: Array<{ id: string; label: string; prompt: string }>;
-  author: "assistant" | "platform";
   createdAt: string;
 };
 
@@ -185,13 +162,12 @@ function makeItem(
   overrides: Partial<FeedItemFixture> & { id: string },
 ): FeedItemFixture {
   return {
-    type: "nudge",
+    type: "notification",
     priority: 50,
     title: "Test",
     summary: "Test summary",
     timestamp: "2026-04-14T12:00:00.000Z",
     status: "new",
-    author: "platform",
     createdAt: "2026-04-14T12:00:00.000Z",
     ...overrides,
   };
@@ -204,7 +180,7 @@ function writeFeedFile(items: FeedItemFixture[]): void {
     path,
     JSON.stringify(
       {
-        version: 1,
+        version: 2,
         updatedAt: "2026-04-14T12:00:00.000Z",
         items,
       },
@@ -223,8 +199,6 @@ beforeEach(() => {
   origWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
   process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
   publishSpy.mockClear();
-  rollupProducerSpy.mockClear();
-  __resetOnVisitRefreshStateForTests();
   createdConversations.length = 0;
   addedMessages.length = 0;
   createConversationShouldThrow = false;
@@ -372,18 +346,12 @@ describe("handleGetHomeFeed", () => {
     expect(typeof body.contextBanner.greeting).toBe("string");
   });
 
-  test("filters out items whose minTimeAway exceeds timeAwaySeconds", async () => {
-    writeFeedFile([
-      makeItem({
-        id: "gated",
-        type: "nudge",
-        minTimeAway: 3600,
-      }),
-      makeItem({
-        id: "ungated",
-        type: "nudge",
-      }),
-    ]);
+  test("returns every item regardless of timeAwaySeconds (v2 dropped minTimeAway gating)", async () => {
+    // The v2 schema no longer carries `minTimeAway`, and the route
+    // handler no longer gates on it — every item flows through. The
+    // `timeAwaySeconds` query parameter survives only because the
+    // context banner's relative-time label is derived from it.
+    writeFeedFile([makeItem({ id: "a" }), makeItem({ id: "b" })]);
 
     const res = await handleGetHomeFeed(
       new Request("http://localhost/v1/home/feed?timeAwaySeconds=60"),
@@ -393,20 +361,13 @@ describe("handleGetHomeFeed", () => {
       items: Array<{ id: string }>;
       contextBanner: { newCount: number };
     };
-    const ids = body.items.map((i) => i.id);
-    expect(ids).toContain("ungated");
-    expect(ids).not.toContain("gated");
-    expect(body.contextBanner.newCount).toBe(1);
+    const ids = body.items.map((i) => i.id).sort();
+    expect(ids).toEqual(["a", "b"]);
+    expect(body.contextBanner.newCount).toBe(2);
   });
 
-  test("includes items when timeAwaySeconds >= minTimeAway", async () => {
-    writeFeedFile([
-      makeItem({
-        id: "gated",
-        type: "nudge",
-        minTimeAway: 3600,
-      }),
-    ]);
+  test("contextBanner.timeAwayLabel reflects the supplied timeAwaySeconds", async () => {
+    writeFeedFile([makeItem({ id: "any" })]);
 
     const res = await handleGetHomeFeed(
       new Request("http://localhost/v1/home/feed?timeAwaySeconds=7200"),
@@ -417,90 +378,11 @@ describe("handleGetHomeFeed", () => {
       contextBanner: { newCount: number; timeAwayLabel: string };
     };
     expect(body.items).toHaveLength(1);
-    expect(body.items[0]!.id).toBe("gated");
+    expect(body.items[0]!.id).toBe("any");
     expect(body.contextBanner.newCount).toBe(1);
     expect(body.contextBanner.timeAwayLabel).toBe("2 hours ago");
   });
 
-  test("fires the rollup producer fire-and-forget on the first GET", async () => {
-    const res = await handleGetHomeFeed(
-      new Request("http://localhost/v1/home/feed?timeAwaySeconds=0"),
-    );
-    expect(res.status).toBe(200);
-    // Yield a microtask so the fire-and-forget call reaches its
-    // first await point.
-    await Promise.resolve();
-    expect(rollupProducerSpy).toHaveBeenCalledTimes(1);
-  });
-
-  test("does NOT refire the rollup when the debounce window has not elapsed", async () => {
-    await handleGetHomeFeed(
-      new Request("http://localhost/v1/home/feed?timeAwaySeconds=0"),
-    );
-    await Promise.resolve();
-    expect(rollupProducerSpy).toHaveBeenCalledTimes(1);
-
-    // A second GET milliseconds later should NOT re-trigger the
-    // rollup — the 10-minute debounce prevents aggressive pollers or
-    // multiple panels from firing repeat refreshes.
-    await handleGetHomeFeed(
-      new Request("http://localhost/v1/home/feed?timeAwaySeconds=0"),
-    );
-    await handleGetHomeFeed(
-      new Request("http://localhost/v1/home/feed?timeAwaySeconds=0"),
-    );
-    await Promise.resolve();
-    expect(rollupProducerSpy).toHaveBeenCalledTimes(1);
-  });
-
-  test("debounce is rolled back when the producer skips before the LLM call", async () => {
-    // Simulate the daemon-boot race: the first GET fires the
-    // producer but the provider registry isn't ready yet, so the
-    // producer short-circuits with `no_provider`. A second GET a
-    // moment later must still be allowed to fire — otherwise Home
-    // stays stale for the full 10-minute debounce window while the
-    // user is actively trying to refresh.
-    rollupProducerSpy.mockImplementationOnce(async () => ({
-      wroteCount: 0,
-      skippedReason: "no_provider",
-    }));
-
-    await handleGetHomeFeed(
-      new Request("http://localhost/v1/home/feed?timeAwaySeconds=0"),
-    );
-    // Let the fire-and-forget `.then()` that performs the rollback
-    // run before we issue the second GET. Two microtask ticks
-    // because the chain is runRollupProducer -> .then handler.
-    await Promise.resolve();
-    await Promise.resolve();
-    expect(rollupProducerSpy).toHaveBeenCalledTimes(1);
-
-    // Second GET — producer is now ready. Gate must have been
-    // rolled back so this GET re-fires the producer.
-    await handleGetHomeFeed(
-      new Request("http://localhost/v1/home/feed?timeAwaySeconds=0"),
-    );
-    await Promise.resolve();
-    expect(rollupProducerSpy).toHaveBeenCalledTimes(2);
-  });
-
-  test("rollup producer failure does not turn the GET into an error", async () => {
-    // Even if the rollup producer rejects, the GET must still return
-    // 200 with the cached feed — the refresh is fire-and-forget.
-    rollupProducerSpy.mockImplementationOnce(async () => {
-      throw new Error("synthetic rollup failure");
-    });
-
-    const res = await handleGetHomeFeed(
-      new Request("http://localhost/v1/home/feed?timeAwaySeconds=0"),
-    );
-    expect(res.status).toBe(200);
-    // Drain the rejected promise so it doesn't leak into the next
-    // test as an unhandled rejection.
-    await Promise.resolve();
-    await Promise.resolve();
-  });
-
   test("newCount counts only status=new after filtering", async () => {
     writeFeedFile([
       makeItem({ id: "a", status: "new" }),
@@ -597,7 +479,6 @@ describe("handlePostFeedAction", () => {
     writeFeedFile([
       makeItem({
         id: "item-1",
-        type: "action",
         actions: [
           {
             id: "reply",
@@ -648,7 +529,6 @@ describe("handlePostFeedAction", () => {
     writeFeedFile([
       makeItem({
         id: "item-2",
-        type: "action",
         actions: [{ id: "reply", label: "Reply", prompt: "hi" }],
       }),
     ]);
@@ -668,7 +548,6 @@ describe("handlePostFeedAction", () => {
     writeFeedFile([
       makeItem({
         id: "item-3",
-        type: "action",
         actions: [{ id: "reply", label: "Reply", prompt: "hi" }],
       }),
     ]);