@vellumai/assistant 0.8.4 → 0.8.6

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

@@ -66,6 +66,7 @@ import {
   recordMemoryV2ActivationLog,
 } from "../../../memory/memory-v2-activation-log-store.js";
 import {
+  conversationKeys,
   conversations,
   llmRequestLogs,
   memoryV2ActivationLogs,
@@ -89,6 +90,10 @@ const llmContextRoute = ROUTES.find(
   (r) => r.method === "GET" && r.endpoint === "messages/:id/llm-context",
 )!;
 
+const conversationLlmContextRoute = ROUTES.find(
+  (r) => r.method === "GET" && r.endpoint === "conversations/llm-context",
+)!;
+
 const replaceProfileRoute = ROUTES.find(
   (r) => r.operationId === "config_llm_profiles_replace",
 )!;
@@ -97,11 +102,16 @@ function dispatchLlmContext(messageId: string) {
   return llmContextRoute.handler({ pathParams: { id: messageId } });
 }
 
+function dispatchConversationLlmContext(queryParams: Record<string, string>) {
+  return conversationLlmContextRoute.handler({ queryParams });
+}
+
 function clearTables(): void {
   const db = getDb();
   db.delete(llmRequestLogs).run();
   db.delete(memoryV2ActivationLogs).run();
   db.delete(messages).run();
+  db.delete(conversationKeys).run();
   db.delete(conversations).run();
 }
 
@@ -165,6 +175,102 @@ function seedRequestLog(
     .run();
 }
 
+function seedConversationKey(conversationKey: string, conversationId: string): void {
+  getDb()
+    .insert(conversationKeys)
+    .values({
+      id: `key-${conversationKey}`,
+      conversationKey,
+      conversationId,
+      createdAt: Date.now(),
+    })
+    .run();
+}
+
+describe("GET /v1/conversations/llm-context", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  test("returns all LLM calls for a resolved conversation key", async () => {
+    seedConversationAndMessage({
+      conversationId: "conv-1",
+      messageId: "msg-1",
+      source: "user",
+      conversationType: "standard",
+      totalEstimatedCost: 0.42,
+    });
+    getDb()
+      .insert(messages)
+      .values({
+        id: "msg-2",
+        conversationId: "conv-1",
+        role: "assistant",
+        content: "",
+        createdAt: Date.now() + 1,
+        metadata: null,
+      })
+      .run();
+    seedConversationAndMessage({
+      conversationId: "conv-other",
+      messageId: "msg-other",
+      source: "user",
+      conversationType: "standard",
+    });
+    seedConversationKey("conv-key", "conv-1");
+    seedRequestLog("msg-2", "log-b");
+    seedRequestLog("msg-1", "log-a");
+    getDb()
+      .insert(llmRequestLogs)
+      .values({
+        id: "log-other",
+        conversationId: "conv-other",
+        messageId: "msg-other",
+        provider: "openai",
+        requestPayload: JSON.stringify({ model: "gpt-4.1", messages: [] }),
+        responsePayload: JSON.stringify({
+          choices: [{ message: { content: "other" } }],
+        }),
+        createdAt: 1_700_000_000_001,
+      })
+      .run();
+
+    const body = (await dispatchConversationLlmContext({
+      conversationKey: "conv-key",
+    })) as {
+      conversationId: string;
+      conversationKey: string;
+      conversationKind: string;
+      conversationTotalEstimatedCostUsd: number | null;
+      logs: Array<{ id: string }>;
+      memoryRecall: null;
+      memoryV2Activation: null;
+    };
+
+    expect(body.conversationId).toBe("conv-1");
+    expect(body.conversationKey).toBe("conv-key");
+    expect(body.conversationKind).toBe("user");
+    expect(body.conversationTotalEstimatedCostUsd).toBe(0.42);
+    expect(body.logs.map((log) => log.id)).toEqual(["log-a", "log-b"]);
+    expect(body.memoryRecall).toBeNull();
+    expect(body.memoryV2Activation).toBeNull();
+  });
+
+  test("returns an empty inspector response for an unresolved conversation key", async () => {
+    const body = (await dispatchConversationLlmContext({
+      conversationKey: "missing-key",
+    })) as {
+      conversationId: string | null;
+      conversationKey: string;
+      logs: unknown[];
+    };
+
+    expect(body.conversationId).toBeNull();
+    expect(body.conversationKey).toBe("missing-key");
+    expect(body.logs).toEqual([]);
+  });
+});
+
 describe("GET /v1/messages/:id/llm-context — memoryV2Activation", () => {
   beforeEach(() => {
     clearTables();
@@ -371,6 +477,104 @@ describe("GET /v1/messages/:id/llm-context — agentLoopExitReason", () => {
   });
 });
 
+describe("GET /v1/messages/:id/llm-context — synthetic call_site projection", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  test("projects callSite='syntheticAgentErrorMessage' and the stamped exit reason for a synthetic row", async () => {
+    const messageId = "msg-yield";
+    seedConversationAndMessage({
+      conversationId: "conv-1",
+      messageId,
+      source: "user",
+      conversationType: "standard",
+    });
+    // Mirror what `recordSyntheticAgentErrorMessageLog` writes: synthetic
+    // envelope in BOTH payload columns (request = prepared LLM body the
+    // loop was about to send; response = the notice text the user saw),
+    // `call_site = "syntheticAgentErrorMessage"`, exit reason stamped at
+    // insert time.
+    getDb()
+      .insert(llmRequestLogs)
+      .values({
+        id: "log-yield",
+        conversationId: "conv-1",
+        messageId,
+        provider: null,
+        requestPayload: JSON.stringify({
+          syntheticAgentErrorMessage: {
+            exitReason: "budget_yield_unrecovered",
+            preparedRequest: { messages: [], maxInputTokensBudget: 200000 },
+          },
+        }),
+        responsePayload: JSON.stringify({
+          syntheticAgentErrorMessage: {
+            exitReason: "budget_yield_unrecovered",
+            noticeText:
+              "I tried to compact this but couldn't fit the next step.",
+          },
+        }),
+        createdAt: 1_700_000_000_000,
+        agentLoopExitReason: "budget_yield_unrecovered",
+        callSite: "syntheticAgentErrorMessage",
+      })
+      .run();
+
+    const body = (await dispatchLlmContext(messageId)) as {
+      logs: Array<{
+        id: string;
+        callSite: string | null;
+        agentLoopExitReason: string | null;
+      }>;
+    };
+
+    expect(body.logs).toHaveLength(1);
+    const row = body.logs[0]!;
+    expect(row.callSite).toBe("syntheticAgentErrorMessage");
+    expect(row.agentLoopExitReason).toBe("budget_yield_unrecovered");
+    // Frontend branches on `callSite` alone — no separate syntheticEvent
+    // field needs to be projected.
+    expect(row).not.toHaveProperty("syntheticEvent");
+  });
+
+  test("projects callSite='mainAgent' for regular LLM-call rows", async () => {
+    const messageId = "msg-regular";
+    seedConversationAndMessage({
+      conversationId: "conv-1",
+      messageId,
+      source: "user",
+      conversationType: "standard",
+    });
+    getDb()
+      .insert(llmRequestLogs)
+      .values({
+        id: "log-regular",
+        conversationId: "conv-1",
+        messageId,
+        provider: "openai",
+        requestPayload: JSON.stringify({ model: "gpt-4.1", messages: [] }),
+        responsePayload: JSON.stringify({
+          choices: [{ message: { content: "hi" } }],
+        }),
+        createdAt: 1_700_000_000_000,
+        callSite: "mainAgent",
+      })
+      .run();
+
+    const body = (await dispatchLlmContext(messageId)) as {
+      logs: Array<{
+        id: string;
+        callSite: string | null;
+      }>;
+    };
+
+    expect(body.logs[0]!.callSite).toBe("mainAgent");
+    // No leftover syntheticEvent projection field on regular rows either.
+    expect(body.logs[0]!).not.toHaveProperty("syntheticEvent");
+  });
+});
+
 describe("PUT /v1/config/llm/profiles/:name", () => {
   beforeEach(() => {
     savedRawConfig = null;

package/src/runtime/routes/__tests__/heartbeat-routes.test.ts

@@ -90,7 +90,7 @@ describe("setHeartbeatConfig handler", () => {
     // invalidation + getConfig() read picked up the new on-disk state.
     expect(result.success).toBe(true);
     expect(result.enabled).toBe(true);
-    expect(result.intervalMs).toBe(30 * 60_000);
+    expect(result.intervalMs).toBe(60 * 60_000);
     expect(result.activeHoursStart).toBe(8);
     expect(result.activeHoursEnd).toBe(22);
   });

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

@@ -22,6 +22,7 @@ mock.module("../../../runtime/assistant-event-hub.js", () => ({
     publish: publishSpy,
     subscribe: () => () => {},
   },
+  broadcastMessage: async () => {},
 }));
 
 // Stub conversation CRUD so we don't spin up a real sqlite DB.
@@ -61,6 +62,7 @@ mock.module("../../../memory/conversation-crud.js", () => ({
   getMessages: () => [],
   getMessagesPaginated: () => ({ messages: [], hasMore: false }),
   getMessageById: () => null,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 // Dynamic imports so module mocks are wired before evaluation.
@@ -68,6 +70,7 @@ const {
   computeGreeting,
   formatRelativeTime,
   handleGetHomeFeed: _handleGetHomeFeed,
+  handleListHomeFeed,
   handlePatchFeedItem: _handlePatchFeedItem,
   handlePostFeedAction: _handlePostFeedAction,
   ROUTES,
@@ -152,9 +155,14 @@ type FeedItemFixture = {
   title: string;
   summary: string;
   timestamp: string;
-  status: "new" | "seen" | "acted_on";
+  status: "new" | "seen" | "acted_on" | "dismissed";
   expiresAt?: string;
   actions?: Array<{ id: string; label: string; prompt: string }>;
+  urgency?: "low" | "medium" | "high" | "critical";
+  category?: "security" | "scheduling" | "background" | "email" | "system";
+  conversationId?: string;
+  fromAssistant?: boolean;
+  noteworthy?: boolean;
   createdAt: string;
 };
 
@@ -563,3 +571,203 @@ describe("handlePostFeedAction", () => {
     expect(res.status).toBe(500);
   });
 });
+
+// ─── handleListHomeFeed ────────────────────────────────────────────────────
+
+describe("handleListHomeFeed", () => {
+  type ListResult = {
+    items: Array<{ id: string; status: string }>;
+    total: number;
+    returned: number;
+    hasMore: boolean;
+  };
+
+  test("excludes dismissed items by default", () => {
+    writeFeedFile([
+      makeItem({ id: "a", status: "new" }),
+      makeItem({ id: "b", status: "seen" }),
+      makeItem({ id: "c", status: "acted_on" }),
+      makeItem({ id: "d", status: "dismissed" }),
+    ]);
+
+    const result = handleListHomeFeed({ body: {} }) as ListResult;
+    expect(result.items.map((i) => i.id).sort()).toEqual(["a", "b", "c"]);
+    expect(result.total).toBe(3);
+    expect(result.hasMore).toBe(false);
+  });
+
+  test("includeDismissed: true returns dismissed items too", () => {
+    writeFeedFile([
+      makeItem({ id: "a", status: "new" }),
+      makeItem({ id: "d", status: "dismissed" }),
+    ]);
+
+    const result = handleListHomeFeed({
+      body: { includeDismissed: true },
+    }) as ListResult;
+    expect(result.items.map((i) => i.id).sort()).toEqual(["a", "d"]);
+  });
+
+  test("statuses filter overrides the dismissed-default exclusion", () => {
+    writeFeedFile([
+      makeItem({ id: "a", status: "new" }),
+      makeItem({ id: "b", status: "seen" }),
+      makeItem({ id: "d", status: "dismissed" }),
+    ]);
+
+    const result = handleListHomeFeed({
+      body: { statuses: ["dismissed"] },
+    }) as ListResult;
+    expect(result.items.map((i) => i.id)).toEqual(["d"]);
+  });
+
+  test("urgencies filter narrows by urgency and excludes items missing urgency", () => {
+    writeFeedFile([
+      makeItem({ id: "a", urgency: "high" }),
+      makeItem({ id: "b", urgency: "low" }),
+      makeItem({ id: "c" }),
+    ]);
+
+    const result = handleListHomeFeed({
+      body: { urgencies: ["high"] },
+    }) as ListResult;
+    expect(result.items.map((i) => i.id)).toEqual(["a"]);
+  });
+
+  test("categories filter narrows by category", () => {
+    writeFeedFile([
+      makeItem({ id: "a", category: "email" }),
+      makeItem({ id: "b", category: "background" }),
+    ]);
+
+    const result = handleListHomeFeed({
+      body: { categories: ["email"] },
+    }) as ListResult;
+    expect(result.items.map((i) => i.id)).toEqual(["a"]);
+  });
+
+  test("conversationId filter narrows by conversation", () => {
+    writeFeedFile([
+      makeItem({ id: "a", conversationId: "conv-1" }),
+      makeItem({ id: "b", conversationId: "conv-2" }),
+      makeItem({ id: "c" }),
+    ]);
+
+    const result = handleListHomeFeed({
+      body: { conversationId: "conv-1" },
+    }) as ListResult;
+    expect(result.items.map((i) => i.id)).toEqual(["a"]);
+  });
+
+  test("fromAssistant: true returns only assistant-emitted items", () => {
+    writeFeedFile([
+      makeItem({ id: "a", fromAssistant: true }),
+      makeItem({ id: "b", fromAssistant: false }),
+      makeItem({ id: "c" }),
+    ]);
+
+    const result = handleListHomeFeed({
+      body: { fromAssistant: true },
+    }) as ListResult;
+    expect(result.items.map((i) => i.id)).toEqual(["a"]);
+  });
+
+  test("noteworthy: true returns only noteworthy items", () => {
+    writeFeedFile([
+      makeItem({ id: "a", noteworthy: true }),
+      makeItem({ id: "b" }),
+    ]);
+
+    const result = handleListHomeFeed({
+      body: { noteworthy: true },
+    }) as ListResult;
+    expect(result.items.map((i) => i.id)).toEqual(["a"]);
+  });
+
+  test("before filter is strict (createdAt < before)", () => {
+    writeFeedFile([
+      makeItem({ id: "old", createdAt: "2026-05-01T00:00:00.000Z" }),
+      makeItem({ id: "edge", createdAt: "2026-05-15T00:00:00.000Z" }),
+      makeItem({ id: "new", createdAt: "2026-05-20T00:00:00.000Z" }),
+    ]);
+
+    const result = handleListHomeFeed({
+      body: { before: "2026-05-15T00:00:00.000Z" },
+    }) as ListResult;
+    expect(result.items.map((i) => i.id)).toEqual(["old"]);
+  });
+
+  test("after filter is strict (createdAt > after)", () => {
+    writeFeedFile([
+      makeItem({ id: "old", createdAt: "2026-05-01T00:00:00.000Z" }),
+      makeItem({ id: "edge", createdAt: "2026-05-15T00:00:00.000Z" }),
+      makeItem({ id: "new", createdAt: "2026-05-20T00:00:00.000Z" }),
+    ]);
+
+    const result = handleListHomeFeed({
+      body: { after: "2026-05-15T00:00:00.000Z" },
+    }) as ListResult;
+    expect(result.items.map((i) => i.id)).toEqual(["new"]);
+  });
+
+  test("limit and offset paginate; hasMore reflects remaining items", () => {
+    writeFeedFile(
+      Array.from({ length: 25 }, (_, i) =>
+        makeItem({
+          id: `i${String(i).padStart(2, "0")}`,
+          // distinct priorities so the file's sort is stable + deterministic
+          priority: 100 - i,
+        }),
+      ),
+    );
+
+    const page1 = handleListHomeFeed({
+      body: { limit: 10, offset: 0 },
+    }) as ListResult;
+    expect(page1.items).toHaveLength(10);
+    expect(page1.total).toBe(25);
+    expect(page1.returned).toBe(10);
+    expect(page1.hasMore).toBe(true);
+
+    const page3 = handleListHomeFeed({
+      body: { limit: 10, offset: 20 },
+    }) as ListResult;
+    expect(page3.items).toHaveLength(5);
+    expect(page3.hasMore).toBe(false);
+  });
+
+  test("invalid before timestamp throws 400", () => {
+    writeFeedFile([]);
+    let caught: unknown;
+    try {
+      handleListHomeFeed({ body: { before: "not-a-date" } });
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(RouteError);
+    expect((caught as { statusCode: number }).statusCode).toBe(400);
+  });
+
+  test("invalid filter shape throws 400", () => {
+    writeFeedFile([]);
+    let caught: unknown;
+    try {
+      handleListHomeFeed({ body: { urgencies: ["extreme"] } });
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(RouteError);
+    expect((caught as { statusCode: number }).statusCode).toBe(400);
+  });
+
+  test("expired items are excluded (matches readHomeFeed TTL behavior)", () => {
+    const past = new Date(Date.now() - 60_000).toISOString();
+    writeFeedFile([
+      makeItem({ id: "alive" }),
+      makeItem({ id: "dead", expiresAt: past }),
+    ]);
+
+    const result = handleListHomeFeed({ body: {} }) as ListResult;
+    expect(result.items.map((i) => i.id)).toEqual(["alive"]);
+  });
+});

package/src/runtime/routes/__tests__/inference-provider-connection-routes.test.ts

@@ -29,7 +29,7 @@ mock.module("../../../util/logger.js", () => ({
 
 // ── Real imports (after mocks) ────────────────────────────────────────────────
 
-import { _setOverridesForTesting } from "../../../config/assistant-feature-flags.js";
+import { setOverridesForTesting } from "../../../__tests__/feature-flag-test-helpers.js";
 import { getDb } from "../../../memory/db-connection.js";
 import { initializeDb } from "../../../memory/db-init.js";
 import { providerConnections } from "../../../memory/schema/inference.js";
@@ -90,7 +90,7 @@ function seedConnection(opts: {
 beforeEach(() => {
   clearConnections();
   fakeConfig = {};
-  _setOverridesForTesting({ "openai-compatible-endpoints": true });
+  setOverridesForTesting({ "openai-compatible-endpoints": true });
 });
 
 // ── GET list ─────────────────────────────────────────────────────────────────
@@ -160,7 +160,7 @@ describe("GET inference/provider-connections (list)", () => {
   });
 
   test("hides openai-compatible rows when the feature flag is disabled", async () => {
-    _setOverridesForTesting({ "openai-compatible-endpoints": false });
+    setOverridesForTesting({ "openai-compatible-endpoints": false });
     seedConnection({
       name: "my-openai",
       provider: "openai",
@@ -181,7 +181,7 @@ describe("GET inference/provider-connections (list)", () => {
   });
 
   test("rejects openai-compatible provider filter when the feature flag is disabled", async () => {
-    _setOverridesForTesting({ "openai-compatible-endpoints": false });
+    setOverridesForTesting({ "openai-compatible-endpoints": false });
 
     await expect(
       call(findHandler("inference_provider_connections_list"), {
@@ -219,7 +219,7 @@ describe("GET inference/provider-connections/:name (single)", () => {
   });
 
   test("throws 404 for openai-compatible row when the feature flag is disabled", async () => {
-    _setOverridesForTesting({ "openai-compatible-endpoints": false });
+    setOverridesForTesting({ "openai-compatible-endpoints": false });
     seedConnection({
       name: "my-compatible",
       provider: "openai-compatible",
@@ -317,7 +317,7 @@ describe("POST inference/provider-connections (create)", () => {
   });
 
   test("rejects openai-compatible creation when the feature flag is disabled", async () => {
-    _setOverridesForTesting({ "openai-compatible-endpoints": false });
+    setOverridesForTesting({ "openai-compatible-endpoints": false });
 
     await expect(
       call(findHandler("inference_provider_connections_create"), {
@@ -530,10 +530,10 @@ describe("DELETE inference/provider-connections/:name (delete)", () => {
   });
 });
 
-// ── status + label fields ─────────────────────────────────────────────────────
+// ── label fields ─────────────────────────────────────────────────────────────
 
-describe("POST with label and status", () => {
-  test("creates connection with label and status, both echoed in response", async () => {
+describe("POST with label", () => {
+  test("creates connection with label, echoed in response", async () => {
     const result = (await call(
       findHandler("inference_provider_connections_create"),
       {
@@ -542,13 +542,11 @@ describe("POST with label and status", () => {
           provider: "anthropic",
           auth: { type: "platform" },
           label: "My Anthropic",
-          status: "active",
         },
       },
-    )) as { name: string; label: string | null; status: string };
+    )) as { name: string; label: string | null };
     expect(result.name).toBe("labeled-conn");
     expect(result.label).toBe("My Anthropic");
-    expect(result.status).toBe("active");
   });
 
   test("creates connection without label — label is null in response", async () => {
@@ -561,30 +559,12 @@ describe("POST with label and status", () => {
           auth: { type: "platform" },
         },
       },
-    )) as { label: string | null; status: string };
+    )) as { label: string | null };
     expect(result.label).toBeNull();
-    expect(result.status).toBe("active");
   });
 });
 
-describe("PATCH with status and label", () => {
-  test("updates status to disabled", async () => {
-    seedConnection({
-      name: "toggleable",
-      provider: "anthropic",
-      auth: { type: "platform" },
-    });
-
-    const result = (await call(
-      findHandler("inference_provider_connections_update"),
-      {
-        pathParams: { name: "toggleable" },
-        body: { auth: { type: "platform" }, status: "disabled" },
-      },
-    )) as { status: string };
-    expect(result.status).toBe("disabled");
-  });
-
+describe("PATCH with label", () => {
   test("updates label to a string", async () => {
     seedConnection({
       name: "set-label",
@@ -758,24 +738,7 @@ describe("Managed connection write protection", () => {
     });
   });
 
-  describe("PATCH status + label (allowed)", () => {
-    test("allows disabling a managed connection", async () => {
-      seedConnection({
-        name: "anthropic-managed",
-        provider: "anthropic",
-        auth: { type: "platform" },
-      });
-
-      const result = (await call(
-        findHandler("inference_provider_connections_update"),
-        {
-          pathParams: { name: "anthropic-managed" },
-          body: { auth: { type: "platform" }, status: "disabled" },
-        },
-      )) as { status: string };
-      expect(result.status).toBe("disabled");
-    });
-
+  describe("PATCH label (allowed)", () => {
     test("allows relabeling a managed connection", async () => {
       seedConnection({
         name: "openai-managed",