@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

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();

package/src/__tests__/memory-retrieval-hook.test.ts

@@ -0,0 +1,297 @@
+/**
+ * Tests for the default `user-prompt-submit-temp` hook (memory retrieval).
+ *
+ * Covers the retrieval behavior, the side effects the hook owns (injected-block
+ * metadata, recall log, `memory_recalled` event), trust gating, error
+ * propagation, and abort-signal forwarding. Uses `mock.module` to stub the
+ * persistence helpers so the test doesn't touch the developer's real
+ * `~/.vellum` or database. The memory graph handle is a hand-rolled fake
+ * passed on the hook context — the hook only needs `prepareMemory`.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Stub the persistence helpers BEFORE importing the module under test so the
+// bindings resolve through the mocks.
+const updateMessageMetadataMock = mock((_id: string, _updates: unknown) => {});
+mock.module("../memory/conversation-crud.js", () => ({
+  updateMessageMetadata: updateMessageMetadataMock,
+}));
+
+const recordMemoryRecallLogMock = mock((_entry: unknown) => {});
+mock.module("../memory/memory-recall-log-store.js", () => ({
+  recordMemoryRecallLog: recordMemoryRecallLogMock,
+}));
+
+import type { AssistantConfig } from "../config/schema.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
+import type { QdrantSparseVector } from "../memory/qdrant-client.js";
+import userPromptSubmitMemoryRetrieval, {
+  type MemoryRetrievalHookContext,
+} from "../plugins/defaults/memory-retrieval/hooks/user-prompt-submit-temp.js";
+import type { Message } from "../providers/types.js";
+
+/** Canonical metrics payload the graph retriever attaches to a real hit. */
+function makeMetrics() {
+  return {
+    embeddingProvider: "openai",
+    embeddingModel: "text-embedding-3-small",
+    semanticHits: 2,
+    mergedCount: 3,
+    selectedCount: 1,
+    tier1Count: 1,
+    tier2Count: 0,
+    hybridSearchLatencyMs: 5,
+    sparseVectorUsed: true,
+    topCandidates: [
+      {
+        nodeId: "node-1",
+        type: "fact",
+        score: 0.9,
+        semanticSimilarity: 0.8,
+        recencyBoost: 0.1,
+      },
+    ],
+    queryContext: "query-context",
+  };
+}
+
+/**
+ * Fake graph-memory whose `prepareMemory` returns a canonical result. The hook
+ * unpacks this return value onto `ctx.latestMessages` and records the selected
+ * PKB query pair back onto the handle via `recordPkbQueryVectors`, so tests
+ * can assert those outputs by comparing object identity.
+ */
+function makeFakeGraphMemory(overrides?: {
+  messages?: Message[];
+  injectedTokens?: number;
+  injectedBlockText?: string | null;
+  metrics?: ReturnType<typeof makeMetrics> | null;
+  queryVector?: number[];
+  sparseVector?: QdrantSparseVector;
+  userQueryVector?: number[];
+  userQuerySparseVector?: QdrantSparseVector;
+}): {
+  memory: ConversationGraphMemory;
+  prepareMemoryMock: ReturnType<typeof mock>;
+  recordPkbQueryVectorsMock: ReturnType<typeof mock>;
+} {
+  const returnValue = {
+    runMessages: overrides?.messages ?? [],
+    injectedTokens: overrides?.injectedTokens ?? 0,
+    latencyMs: 0,
+    mode: "none" as const,
+    injectedBlockText:
+      overrides?.injectedBlockText === undefined
+        ? null
+        : overrides.injectedBlockText,
+    metrics: overrides?.metrics ?? null,
+    queryVector: overrides?.queryVector,
+    sparseVector: overrides?.sparseVector,
+    userQueryVector: overrides?.userQueryVector,
+    userQuerySparseVector: overrides?.userQuerySparseVector,
+  };
+  const prepareMemoryMock = mock(async () => returnValue);
+  const recordPkbQueryVectorsMock = mock(() => {});
+  const memory = {
+    prepareMemory: prepareMemoryMock,
+    recordPkbQueryVectors: recordPkbQueryVectorsMock,
+  } as unknown as ConversationGraphMemory;
+  return { memory, prepareMemoryMock, recordPkbQueryVectorsMock };
+}
+
+function makeHookCtx(
+  overrides: Partial<MemoryRetrievalHookContext> = {},
+): MemoryRetrievalHookContext {
+  const { memory } = makeFakeGraphMemory();
+  return {
+    graphMemory: memory,
+    config: {} as AssistantConfig,
+    onEvent: () => {},
+    isTrustedActor: true,
+    conversationId: "conv-test",
+    userMessageId: "msg-test",
+    logger: {
+      warn: () => {},
+    } as unknown as MemoryRetrievalHookContext["logger"],
+    signal: new AbortController().signal,
+    latestMessages: [],
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  updateMessageMetadataMock.mockReset();
+  recordMemoryRecallLogMock.mockReset();
+});
+
+describe("user-prompt-submit-temp hook (memory retrieval)", () => {
+  test("adopts the injected run messages when the actor is trusted", async () => {
+    const injected: Message[] = [
+      { role: "user", content: [{ type: "text", text: "injected" }] },
+    ];
+    const { memory, prepareMemoryMock } = makeFakeGraphMemory({
+      messages: injected,
+    });
+    const ctx = makeHookCtx({ graphMemory: memory, isTrustedActor: true });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(prepareMemoryMock).toHaveBeenCalledTimes(1);
+    // The hook adopts the retriever's injected message array verbatim —
+    // consumers in the agent loop rely on that identity.
+    expect(ctx.latestMessages).toBe(injected);
+  });
+
+  test("selects the user-query dense/sparse pair when present, else the summary pair", async () => {
+    const userDense = [1, 1, 1];
+    const userSparse: QdrantSparseVector = { indices: [0], values: [1] };
+    const summaryDense = [2, 2, 2];
+    const summarySparse: QdrantSparseVector = { indices: [1], values: [2] };
+
+    const withUserQuery = makeFakeGraphMemory({
+      queryVector: summaryDense,
+      sparseVector: summarySparse,
+      userQueryVector: userDense,
+      userQuerySparseVector: userSparse,
+    });
+    const userCtx = makeHookCtx({ graphMemory: withUserQuery.memory });
+    await userPromptSubmitMemoryRetrieval(userCtx);
+    // User-query pair wins — never crossed with the summary signal — and is
+    // recorded back onto the graph handle for the PKB-reminder injector.
+    expect(withUserQuery.recordPkbQueryVectorsMock).toHaveBeenCalledWith(
+      userDense,
+      userSparse,
+    );
+
+    const summaryOnly = makeFakeGraphMemory({
+      queryVector: summaryDense,
+      sparseVector: summarySparse,
+    });
+    const summaryCtx = makeHookCtx({ graphMemory: summaryOnly.memory });
+    await userPromptSubmitMemoryRetrieval(summaryCtx);
+    expect(summaryOnly.recordPkbQueryVectorsMock).toHaveBeenCalledWith(
+      summaryDense,
+      summarySparse,
+    );
+  });
+
+  test("skips graph retrieval and side effects for untrusted actors", async () => {
+    const { memory, prepareMemoryMock, recordPkbQueryVectorsMock } =
+      makeFakeGraphMemory();
+    const seeded: Message[] = [
+      { role: "user", content: [{ type: "text", text: "seeded" }] },
+    ];
+    const ctx = makeHookCtx({
+      graphMemory: memory,
+      isTrustedActor: false,
+      latestMessages: seeded,
+    });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(prepareMemoryMock).not.toHaveBeenCalled();
+    // No graph retrieval ran: the working array stays the seeded input and no
+    // PKB query pair is recorded onto the graph handle.
+    expect(ctx.latestMessages).toBe(seeded);
+    expect(recordPkbQueryVectorsMock).not.toHaveBeenCalled();
+    expect(recordMemoryRecallLogMock).not.toHaveBeenCalled();
+    expect(updateMessageMetadataMock).not.toHaveBeenCalled();
+  });
+
+  test("persists injected block, recall log, and emits memory_recalled", async () => {
+    const received: ServerMessage[] = [];
+    const { memory } = makeFakeGraphMemory({
+      injectedBlockText: "injected-block",
+      metrics: makeMetrics(),
+    });
+    const ctx = makeHookCtx({
+      graphMemory: memory,
+      onEvent: (msg) => received.push(msg),
+      userMessageId: "msg-42",
+      conversationId: "conv-42",
+    });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(updateMessageMetadataMock).toHaveBeenCalledWith("msg-42", {
+      memoryInjectedBlock: "injected-block",
+    });
+    expect(recordMemoryRecallLogMock).toHaveBeenCalledTimes(1);
+    const logEntry = recordMemoryRecallLogMock.mock.calls[0]?.[0] as {
+      conversationId: string;
+      reason: string;
+    };
+    expect(logEntry.conversationId).toBe("conv-42");
+    expect(logEntry.reason).toBe("graph:none");
+    expect(received).toHaveLength(1);
+    expect(received[0]?.type).toBe("memory_recalled");
+  });
+
+  test("skips metadata persist when no block text is injected", async () => {
+    const { memory } = makeFakeGraphMemory({ injectedBlockText: null });
+    const ctx = makeHookCtx({ graphMemory: memory });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(updateMessageMetadataMock).not.toHaveBeenCalled();
+    // The recall log is still written even without an injected block.
+    expect(recordMemoryRecallLogMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("propagates errors from prepareMemory rather than swallowing them", async () => {
+    // Memory is critical — failures must surface to the caller (the agent
+    // loop) rather than silently degrading to an empty graph result.
+    const failingPrepare = mock(
+      (
+        _msgs: Message[],
+        _cfg: AssistantConfig,
+        _signal: AbortSignal,
+        _onEvent: (msg: ServerMessage) => void,
+      ) => Promise.reject(new Error("retrieval failed")),
+    );
+    const graphMemory = {
+      prepareMemory: failingPrepare,
+    } as unknown as ConversationGraphMemory;
+    const ctx = makeHookCtx({ graphMemory, isTrustedActor: true });
+
+    await expect(userPromptSubmitMemoryRetrieval(ctx)).rejects.toThrow(
+      "retrieval failed",
+    );
+  });
+
+  test("forwards the context abort signal into prepareMemory", async () => {
+    // The hook hands its `ctx.signal` straight to `prepareMemory` so an
+    // external cancel aborts the underlying retrieval.
+    let capturedSignal: AbortSignal | undefined;
+    const prepareMemoryMock = mock(
+      async (
+        _msgs: Message[],
+        _cfg: AssistantConfig,
+        signal: AbortSignal,
+        _onEvent: (msg: ServerMessage) => void,
+      ) => {
+        capturedSignal = signal;
+        return {
+          runMessages: [],
+          injectedTokens: 0,
+          latencyMs: 0,
+          mode: "none" as const,
+          injectedBlockText: null,
+          metrics: null,
+        };
+      },
+    );
+    const graphMemory = {
+      prepareMemory: prepareMemoryMock,
+      recordPkbQueryVectors: mock(() => {}),
+    } as unknown as ConversationGraphMemory;
+    const controller = new AbortController();
+    const ctx = makeHookCtx({ graphMemory, signal: controller.signal });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(capturedSignal).toBe(controller.signal);
+  });
+});