@vellumai/assistant 0.8.7 → 0.8.8

package/src/__tests__/injector-v3-suppression.test.ts

@@ -1,34 +1,38 @@
 /**
  * Tests for the memory-v3-live v2-suppression branch in
- * `applyRuntimeInjections` (PR L6 of the memory-v3-live plan).
+ * `applyRuntimeInjections`.
  *
- * When `suppressV2MemoryForV3` is on AND the v3 injector (id `memory-v3`,
+ * When the `memory-v3-live` flag is on AND the v3 injector (id `memory-v3`,
  * placement `after-memory-prefix`) actually produces a block, runtime
  * assembly strips the v2 `<memory>` prefix from EVERY user message before
  * splicing the v3 block — so v3 becomes the sole `<memory>` source and history
  * is byte-stable for prompt caching.
  *
- * Keyed off whether v3 produced a block, NOT off the option alone: a v3
+ * Keyed off whether v3 produced a block, NOT off the flag alone: a v3
  * failure (`produce()` → null) leaves v2's block intact (fallback-to-v2).
  *
  * The flag-off path must be byte-for-byte identical to today — that is the
- * load-bearing regression guard.
+ * load-bearing regression guard. `applyRuntimeInjections` reads the flag
+ * itself, so these tests drive it through the override cache.
  */
 
-import { beforeEach, describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import {
-  getInjectors,
-  registerPlugin,
-  resetPluginRegistryForTests,
-} from "../plugins/registry.js";
 import type {
   InjectionBlock,
   Injector,
-  Plugin,
   TurnContext,
 } from "../plugins/types.js";
 import type { Message } from "../providers/types.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
+
+// Drive the suppression branch by controlling the static injector chain that
+// `applyRuntimeInjections` walks. The slot is mutated per-test to stand in for
+// the memory-v3 injector producing (or not producing) a block.
+const injectorChainSlot: Injector[] = [];
+mock.module("../plugins/defaults/memory-retrieval/injector-chain.js", () => ({
+  getInjectorChain: () => injectorChainSlot,
+}));
 
 const { applyRuntimeInjections } =
   await import("../daemon/conversation-runtime-assembly.js");
@@ -42,10 +46,6 @@ function makeTurnContext(): TurnContext {
   };
 }
 
-function wrapInPlugin(name: string, injectors: Injector[]): Plugin {
-  return { manifest: { name, version: "0.0.1" }, injectors };
-}
-
 /**
  * A fake v3 injector that mirrors the real one's id + placement. The real
  * injector's `renderMemoryBlock` already wraps its content in
@@ -88,11 +88,15 @@ function tailTexts(messages: Message[]): string[] {
 
 describe("memory-v3-live v2 suppression", () => {
   beforeEach(() => {
-    resetPluginRegistryForTests();
+    injectorChainSlot.length = 0;
+    // Clean baseline: no overrides → `memory-v3-live` resolves to its registry
+    // default (off). Each test seeds the flag it needs.
+    setOverridesForTesting({});
   });
 
   test("flag ON + v3 produced a block → v2 stripped from all turns, exactly one <memory> (the v3 block)", async () => {
-    registerPlugin(wrapInPlugin("v3", [v3Injector("v3 working set")]));
+    setOverridesForTesting({ "memory-v3-live": true });
+    injectorChainSlot.push(v3Injector("v3 working set"));
 
     // History: a prior user turn that still carries a v2 block (rehydrated),
     // plus the current tail user turn with its own v2 block.
@@ -107,7 +111,6 @@ describe("memory-v3-live v2 suppression", () => {
 
     const result = await applyRuntimeInjections(runMessages, {
       turnContext: makeTurnContext(),
-      suppressV2MemoryForV3: true,
     });
 
     // Exactly one <memory> source across the WHOLE assembled context.
@@ -138,7 +141,8 @@ describe("memory-v3-live v2 suppression", () => {
   });
 
   test("flag ON but v3 produced NOTHING → v2 block left intact (fallback-to-v2)", async () => {
-    registerPlugin(wrapInPlugin("v3", [v3Injector(null)]));
+    setOverridesForTesting({ "memory-v3-live": true });
+    injectorChainSlot.push(v3Injector(null));
 
     const runMessages: Message[] = [
       userMsgWithV2Memory("fresh recalled fact", "current question"),
@@ -146,7 +150,6 @@ describe("memory-v3-live v2 suppression", () => {
 
     const result = await applyRuntimeInjections(runMessages, {
       turnContext: makeTurnContext(),
-      suppressV2MemoryForV3: true,
     });
 
     // v2's block survives — the turn still ships memory.
@@ -158,7 +161,7 @@ describe("memory-v3-live v2 suppression", () => {
   });
 
   test("flag OFF → byte-for-byte identical to today even when v3 would have produced a block", async () => {
-    registerPlugin(wrapInPlugin("v3", [v3Injector("v3 working set")]));
+    injectorChainSlot.push(v3Injector("v3 working set"));
 
     const runMessages: Message[] = [
       userMsgWithV2Memory("old recalled fact", "earlier question"),
@@ -169,16 +172,16 @@ describe("memory-v3-live v2 suppression", () => {
       userMsgWithV2Memory("fresh recalled fact", "current question"),
     ];
 
-    // With suppression off, the v3 injector still runs through the chain
-    // (after-memory-prefix), but NO v2 stripping happens. This captures the
-    // exact pre-flag assembly behavior: v2 prefix stays, v3 splices after it.
+    // With the flag off (registry default), the v3 injector still runs through
+    // the chain (after-memory-prefix), but NO v2 stripping happens. This
+    // captures the exact pre-flag assembly behavior: v2 prefix stays, v3
+    // splices after it.
     const offResult = await applyRuntimeInjections(runMessages, {
       turnContext: makeTurnContext(),
-      suppressV2MemoryForV3: false,
     });
 
     // The tail keeps v2's block AND gains v3's (the historical double-injection
-    // the suppression PR exists to prevent) — proving suppression is the ONLY
+    // the suppression exists to prevent) — proving suppression is the ONLY
     // behavior change and it is fully gated off here.
     const texts = tailTexts(offResult.messages);
     expect(texts[0]).toBe("<memory>\nfresh recalled fact\n</memory>");
@@ -190,21 +193,13 @@ describe("memory-v3-live v2 suppression", () => {
       .filter((b): b is { type: "text"; text: string } => b.type === "text")
       .map((b) => b.text);
     expect(firstUserTexts[0]).toBe("<memory>\nold recalled fact\n</memory>");
-
-    // Strongest guard: omitting the option entirely yields the SAME result as
-    // passing it false — the default path is untouched by this PR.
-    resetPluginRegistryForTests();
-    registerPlugin(wrapInPlugin("v3", [v3Injector("v3 working set")]));
-    const defaultResult = await applyRuntimeInjections(runMessages, {
-      turnContext: makeTurnContext(),
-    });
-    expect(defaultResult.messages).toEqual(offResult.messages);
   });
 
   test("no v3 injector registered + flag ON → no stripping, messages untouched", async () => {
     // No injector named memory-v3 at all (e.g. plugin not loaded): the
     // suppression branch keys off the produced block, so nothing is stripped.
-    expect(getInjectors()).toHaveLength(0);
+    setOverridesForTesting({ "memory-v3-live": true });
+    expect(injectorChainSlot).toHaveLength(0);
 
     const runMessages: Message[] = [
       userMsgWithV2Memory("fresh recalled fact", "current question"),
@@ -212,7 +207,6 @@ describe("memory-v3-live v2 suppression", () => {
 
     const result = await applyRuntimeInjections(runMessages, {
       turnContext: makeTurnContext(),
-      suppressV2MemoryForV3: true,
     });
 
     expect(result.messages).toEqual(runMessages);

package/src/__tests__/internal-telemetry-routes.test.ts

@@ -0,0 +1,109 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Toggle for the collectUsageData opt-out the real store consults. The store
+// module is intentionally NOT mocked here — it has its own DB-backed tests, and
+// Bun's `mock.module` is process-global, so mocking it would leak into those
+// tests when files share an invocation. Exercising the real store keeps every
+// auth-fallback test order-independent.
+let collectUsageData = true;
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+    collectUsageData,
+  }),
+}));
+
+import { queryUnreportedAuthFallbackEvents } from "../memory/auth-fallback-events-store.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { authFallbackEvents } from "../memory/schema.js";
+import { GATEWAY_PRINCIPALS } from "../runtime/auth/route-policy.js";
+import { RouteError } from "../runtime/routes/errors.js";
+import { ROUTES } from "../runtime/routes/internal-telemetry-routes.js";
+import type { RouteHandlerArgs } from "../runtime/routes/types.js";
+
+initializeDb();
+
+const route = ROUTES.find(
+  (r) => r.operationId === "internal_telemetry_auth_fallback",
+);
+
+function call(body: unknown) {
+  if (!route) throw new Error("route not found");
+  return route.handler({ body } as RouteHandlerArgs);
+}
+
+const VALID_BODY = {
+  window_start: 1000,
+  window_end: 2000,
+  counts: [
+    {
+      guard: "edge",
+      path: "/v1/messages",
+      failure_kind: "missing_authorization",
+      count: 5,
+    },
+  ],
+};
+
+describe("internal-telemetry-routes: auth-fallback", () => {
+  beforeEach(() => {
+    collectUsageData = true;
+    getDb().delete(authFallbackEvents).run();
+  });
+
+  test("route is locked to service-token callers (GATEWAY_PRINCIPALS + internal.write)", () => {
+    expect(route).toBeDefined();
+    expect(route?.endpoint).toBe("internal/telemetry/auth-fallback");
+    expect(route?.method).toBe("POST");
+    expect(route?.policy?.allowedPrincipalTypes).toEqual(GATEWAY_PRINCIPALS);
+    expect(route?.policy?.requiredScopes).toEqual(["internal.write"]);
+  });
+
+  test("valid batch is persisted with snake_case → camelCase mapping", () => {
+    const result = call(VALID_BODY);
+    expect(result).toEqual({ recorded: 1 });
+
+    const rows = queryUnreportedAuthFallbackEvents(0, undefined, 100);
+    expect(rows.length).toBe(1);
+    expect(rows[0]).toMatchObject({
+      guard: "edge",
+      path: "/v1/messages",
+      failureKind: "missing_authorization",
+      count: 5,
+      windowStart: 1000,
+      windowEnd: 2000,
+    });
+  });
+
+  test("returns skipped and persists nothing under the opt-out", () => {
+    collectUsageData = false;
+    expect(call(VALID_BODY)).toEqual({ skipped: true });
+    expect(queryUnreportedAuthFallbackEvents(0, undefined, 100).length).toBe(0);
+  });
+
+  test("rejects a malformed body without persisting", () => {
+    expect(() => call({ window_start: 1000 })).toThrow(RouteError);
+    expect(() => call({ ...VALID_BODY, counts: [] })).toThrow(RouteError);
+    expect(() =>
+      call({
+        ...VALID_BODY,
+        counts: [{ guard: "edge", path: "/x", failure_kind: "y", count: 0 }],
+      }),
+    ).toThrow(RouteError);
+    expect(queryUnreportedAuthFallbackEvents(0, undefined, 100).length).toBe(0);
+  });
+});

package/src/__tests__/list-messages-page-latest.test.ts

@@ -42,6 +42,10 @@ import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { messages } from "../memory/schema.js";
 import { writeSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
+import {
+  _resetStreamStateForTesting,
+  recordPersistedSeq,
+} from "../runtime/assistant-stream-state.js";
 import { handleListMessages } from "../runtime/routes/conversation-routes.js";
 import { BadRequestError } from "../runtime/routes/errors.js";
 
@@ -107,6 +111,7 @@ interface ListResponse {
   hasMore?: boolean;
   oldestTimestamp?: number | null;
   oldestMessageId?: string | null;
+  seq?: number | null;
 }
 
 function callList(query: Record<string, string>): ListResponse {
@@ -118,9 +123,64 @@ function callList(query: Record<string, string>): ListResponse {
 describe("handleListMessages page=latest", () => {
   beforeEach(() => {
     resetTables();
+    _resetStreamStateForTesting();
     mockAssistantName = null;
   });
 
+  describe("persisted seq", () => {
+    test("returns the recorded persisted seq for the conversation", () => {
+      /**
+       * The snapshot must advertise the `seq` of the last durably-persisted
+       * event so a client can align it with the `/events` stream.
+       */
+
+      // GIVEN a conversation with persisted messages
+      const conv = createConversation();
+      seedMessages(conv.id, 3);
+      // AND the daemon has recorded a persisted seq for it
+      recordPersistedSeq(conv.id, 42);
+
+      // WHEN the snapshot is fetched
+      const body = callList({ conversationId: conv.id, page: "latest" });
+
+      // THEN the response carries that seq
+      expect(body.seq).toBe(42);
+    });
+
+    test("returns null seq when nothing has been persisted in-process", () => {
+      /**
+       * A cold conversation (or one aged out / post-restart) reports no seq,
+       * signalling the client to cold-start rather than align to a stale
+       * position.
+       */
+
+      // GIVEN a conversation with no recorded persisted seq
+      const conv = createConversation();
+      seedMessages(conv.id, 2);
+
+      // WHEN the snapshot is fetched
+      const body = callList({ conversationId: conv.id, page: "latest" });
+
+      // THEN seq is null
+      expect(body.seq).toBeNull();
+    });
+
+    test("the no-pagination path also returns the persisted seq", () => {
+      /** `seq` is present on every resolved-conversation response shape. */
+
+      // GIVEN a conversation with a recorded persisted seq
+      const conv = createConversation();
+      seedMessages(conv.id, 2);
+      recordPersistedSeq(conv.id, 7);
+
+      // WHEN fetched with no pagination params
+      const body = callList({ conversationId: conv.id });
+
+      // THEN the seq still rides along
+      expect(body.seq).toBe(7);
+    });
+  });
+
   test("page=latest with no limit returns all messages chronologically", () => {
     const conv = createConversation();
     seedMessages(conv.id, 120);

package/src/__tests__/list-messages-tool-merge.test.ts

@@ -57,6 +57,8 @@ interface MessagePayload {
   role: string;
   toolCalls?: ToolCallPayload[];
   textSegments?: string[];
+  contentOrder?: string[];
+  contentBlocks?: Array<{ type: string; [key: string]: unknown }>;
 }
 
 describe("handleListMessages tool_result merging", () => {
@@ -106,6 +108,24 @@ describe("handleListMessages tool_result merging", () => {
     expect(toolCalls).toHaveLength(1);
     expect(toolCalls![0].name).toBe("bash");
     expect(toolCalls![0].result).toBe("file1.txt\nfile2.txt");
+
+    // The unified contentBlocks projection ships alongside the legacy arrays,
+    // in contentOrder order, with the tool_result already paired onto the
+    // tool_use block.
+    expect(body.messages[1].contentOrder).toEqual(["text:0", "tool:0"]);
+    expect(body.messages[1].contentBlocks).toEqual([
+      { type: "text", text: "Running command." },
+      {
+        type: "tool_use",
+        toolCall: {
+          id: "tu1",
+          name: "bash",
+          input: { command: "ls" },
+          result: "file1.txt\nfile2.txt",
+          isError: false,
+        },
+      },
+    ]);
   });
 
   test("merges multiple tool_results into matching tool_uses", async () => {

package/src/__tests__/llm-usage-store.test.ts

@@ -6,7 +6,7 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
 }));
 
-import { getDb } from "../memory/db-connection.js";
+import { getDb, getSqlite } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import {
   getUsageDayBuckets,
@@ -456,6 +456,228 @@ describe("getUsageTotals", () => {
   });
 });
 
+describe("usage aggregation schedule filters", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM llm_usage_events`);
+    db.run(`DELETE FROM cron_runs`);
+    db.run(`DELETE FROM cron_jobs`);
+  });
+
+  function insertScheduleJob(id: string, name: string): void {
+    const now = Date.UTC(2026, 0, 1);
+    getSqlite().run(
+      `INSERT INTO cron_jobs (
+        id,
+        name,
+        cron_expression,
+        message,
+        next_run_at,
+        created_by,
+        created_at,
+        updated_at
+      ) VALUES (?, ?, '* * * * *', 'Example scheduled task', ?, 'user', ?, ?)`,
+      [id, name, now, now, now],
+    );
+  }
+
+  function insertScheduleRun({
+    id,
+    scheduleId,
+    conversationId,
+    startedAt,
+    finishedAt,
+  }: {
+    id: string;
+    scheduleId: string;
+    conversationId: string;
+    startedAt: number;
+    finishedAt: number | null;
+  }): void {
+    getSqlite().run(
+      `INSERT INTO cron_runs (
+        id,
+        job_id,
+        status,
+        started_at,
+        finished_at,
+        conversation_id,
+        created_at
+      ) VALUES (?, ?, 'ok', ?, ?, ?, ?)`,
+      [id, scheduleId, startedAt, finishedAt, conversationId, startedAt],
+    );
+  }
+
+  function seedScheduleUsage(): void {
+    insertScheduleJob("schedule-a", "Morning summary");
+    insertScheduleJob("schedule-b", "Nightly sync");
+    insertScheduleRun({
+      id: "run-a-1",
+      scheduleId: "schedule-a",
+      conversationId: "conv-reused",
+      startedAt: 1_000,
+      finishedAt: 2_000,
+    });
+    insertScheduleRun({
+      id: "run-b-1",
+      scheduleId: "schedule-b",
+      conversationId: "conv-reused",
+      startedAt: 3_000,
+      finishedAt: 3_500,
+    });
+
+    insertEventAt(
+      900,
+      { conversationId: "conv-reused", inputTokens: 90 },
+      { estimatedCostUsd: 0.09, pricingStatus: "priced" },
+    );
+    insertEventAt(
+      1_000,
+      {
+        conversationId: "conv-reused",
+        callSite: "mainAgent",
+        inputTokens: 100,
+      },
+      { estimatedCostUsd: 0.1, pricingStatus: "priced" },
+    );
+    insertEventAt(
+      1_500,
+      {
+        conversationId: "conv-reused",
+        callSite: "mainAgent",
+        inputTokens: 200,
+      },
+      { estimatedCostUsd: 0.2, pricingStatus: "priced" },
+    );
+    insertEventAt(
+      2_000,
+      {
+        conversationId: "conv-reused",
+        callSite: "mainAgent",
+        inputTokens: 300,
+      },
+      { estimatedCostUsd: 0.3, pricingStatus: "priced" },
+    );
+    insertEventAt(
+      2_500,
+      { conversationId: "conv-reused", inputTokens: 400 },
+      { estimatedCostUsd: 0.4, pricingStatus: "priced" },
+    );
+    insertEventAt(
+      3_200,
+      {
+        conversationId: "conv-reused",
+        provider: "openai",
+        inputTokens: 500,
+      },
+      { estimatedCostUsd: 0.5, pricingStatus: "priced" },
+    );
+    insertEventAt(
+      1_500,
+      { conversationId: "conv-other", inputTokens: 800 },
+      { estimatedCostUsd: 0.8, pricingStatus: "priced" },
+    );
+  }
+
+  test("filters totals, buckets, breakdowns, and series by cron run windows", () => {
+    seedScheduleUsage();
+    const range = { from: 0, to: 4_000 };
+    const filter = { scheduleId: "schedule-a" };
+
+    const totals = getUsageTotals(range, filter);
+    expect(totals.eventCount).toBe(3);
+    expect(totals.totalInputTokens).toBe(600);
+    expect(totals.totalEstimatedCostUsd).toBeCloseTo(0.6);
+
+    const dailyBuckets = getUsageDayBuckets(range, "UTC", {}, filter);
+    expect(dailyBuckets).toHaveLength(1);
+    expect(dailyBuckets[0].totalInputTokens).toBe(600);
+    expect(dailyBuckets[0].eventCount).toBe(3);
+
+    const hourlyBuckets = getUsageHourBuckets(range, "UTC", {}, filter);
+    expect(hourlyBuckets).toHaveLength(1);
+    expect(hourlyBuckets[0].totalInputTokens).toBe(600);
+    expect(hourlyBuckets[0].eventCount).toBe(3);
+
+    const breakdown = getUsageGroupBreakdown(range, "provider", filter);
+    expect(breakdown).toHaveLength(1);
+    expect(breakdown[0].group).toBe("anthropic");
+    expect(breakdown[0].totalInputTokens).toBe(600);
+    expect(breakdown[0].eventCount).toBe(3);
+
+    const series = getUsageGroupedSeries(
+      range,
+      "call_site",
+      "daily",
+      "UTC",
+      {},
+      filter,
+    );
+    expect(series).toHaveLength(1);
+    expect(series[0].totalInputTokens).toBe(600);
+    expect(series[0].groups["null:call_site"]).toBeUndefined();
+    expect(series[0].groups["null:schedule"]).toBeUndefined();
+    expect(series[0].groups["value:mainAgent"]).toMatchObject({
+      group: "Main Agent",
+      totalInputTokens: 600,
+      eventCount: 3,
+    });
+  });
+
+  test("groups schedule-attributed usage by schedule id with schedule names", () => {
+    seedScheduleUsage();
+    const range = { from: 0, to: 4_000 };
+
+    const breakdown = getUsageGroupBreakdown(range, "schedule");
+    const scheduleA = breakdown.find((row) => row.groupKey === "schedule-a");
+    const scheduleB = breakdown.find((row) => row.groupKey === "schedule-b");
+    const other = breakdown.find((row) => row.groupKey === null);
+
+    expect(scheduleA).toMatchObject({
+      group: "Morning summary",
+      groupId: "schedule-a",
+      groupKey: "schedule-a",
+      totalInputTokens: 600,
+      eventCount: 3,
+    });
+    expect(scheduleB).toMatchObject({
+      group: "Nightly sync",
+      groupId: "schedule-b",
+      groupKey: "schedule-b",
+      totalInputTokens: 500,
+      eventCount: 1,
+    });
+    expect(other).toMatchObject({
+      group: "Other",
+      groupId: null,
+      groupKey: null,
+      totalInputTokens: 1_290,
+      eventCount: 3,
+    });
+
+    const series = getUsageGroupedSeries(range, "schedule", "daily", "UTC", {});
+    expect(series).toHaveLength(1);
+    expect(series[0].groups["value:schedule-a"]).toMatchObject({
+      group: "Morning summary",
+      groupKey: "schedule-a",
+      totalInputTokens: 600,
+      eventCount: 3,
+    });
+    expect(series[0].groups["value:schedule-b"]).toMatchObject({
+      group: "Nightly sync",
+      groupKey: "schedule-b",
+      totalInputTokens: 500,
+      eventCount: 1,
+    });
+    expect(series[0].groups["null:schedule"]).toMatchObject({
+      group: "Other",
+      groupKey: null,
+      totalInputTokens: 1_290,
+      eventCount: 3,
+    });
+  });
+});
+
 describe("getUsageDayBuckets", () => {
   beforeEach(() => {
     const db = getDb();