@vellumai/assistant 0.8.1 → 0.8.2

package/src/__tests__/lifecycle-memory-v2-seed.test.ts

@@ -23,6 +23,7 @@ import type { AssistantConfig } from "../config/schema.js";
 
 interface TestState {
   seedCallCount: number;
+  seedCallOpts: Array<{ throwOnError?: boolean } | undefined>;
   seedShouldReject: Error | null;
   warnCalls: Array<{ obj: unknown; msg: unknown }>;
   infoCalls: Array<{ obj: unknown; msg: unknown }>;
@@ -34,10 +35,14 @@ interface TestState {
   listPagesResult: string[];
   enqueueCalls: Array<{ type: string; payload: Record<string, unknown> }>;
   clearSentinelCallCount: number;
+  // BM25 corpus-stats rebuild + reseed mocks.
+  corpusStatsBuildCount: number;
+  corpusStatsThrows: Error | null;
 }
 
 const state: TestState = {
   seedCallCount: 0,
+  seedCallOpts: [],
   seedShouldReject: null,
   warnCalls: [],
   infoCalls: [],
@@ -48,6 +53,8 @@ const state: TestState = {
   listPagesResult: [],
   enqueueCalls: [],
   clearSentinelCallCount: 0,
+  corpusStatsBuildCount: 0,
+  corpusStatsThrows: null,
 };
 
 // ---------------------------------------------------------------------------
@@ -55,8 +62,11 @@ const state: TestState = {
 // ---------------------------------------------------------------------------
 
 mock.module("../memory/v2/skill-store.js", () => ({
-  seedV2SkillEntries: async (): Promise<void> => {
+  seedV2SkillEntries: async (opts?: {
+    throwOnError?: boolean;
+  }): Promise<void> => {
     state.seedCallCount += 1;
+    state.seedCallOpts.push(opts);
     if (state.seedShouldReject) throw state.seedShouldReject;
   },
 }));
@@ -81,6 +91,13 @@ mock.module("../memory/v2/page-store.js", () => ({
     state.listPagesResult.length > 0,
 }));
 
+mock.module("../memory/v2/sparse-bm25.js", () => ({
+  rebuildConceptPageCorpusStats: async (): Promise<void> => {
+    state.corpusStatsBuildCount += 1;
+    if (state.corpusStatsThrows) throw state.corpusStatsThrows;
+  },
+}));
+
 mock.module("../memory/jobs-store.js", () => ({
   enqueueMemoryJob: (
     type: string,
@@ -113,8 +130,11 @@ mock.module("../util/logger.js", () => ({
   }),
 }));
 
-const { maybeSeedMemoryV2Skills, maybeRebuildMemoryV2Concepts } =
-  await import("../daemon/memory-v2-startup.js");
+const {
+  maybeSeedMemoryV2Skills,
+  maybeRebuildMemoryV2Concepts,
+  rebuildBm25CorpusStatsAndReseedSkills,
+} = await import("../daemon/memory-v2-startup.js");
 
 // ---------------------------------------------------------------------------
 // Test fixtures
@@ -149,6 +169,7 @@ async function flushMicrotasks(): Promise<void> {
 
 function resetState(): void {
   state.seedCallCount = 0;
+  state.seedCallOpts = [];
   state.seedShouldReject = null;
   state.warnCalls = [];
   state.infoCalls = [];
@@ -159,6 +180,8 @@ function resetState(): void {
   state.listPagesResult = [];
   state.enqueueCalls = [];
   state.clearSentinelCallCount = 0;
+  state.corpusStatsBuildCount = 0;
+  state.corpusStatsThrows = null;
 }
 
 describe("maybeSeedMemoryV2Skills (daemon startup gate)", () => {
@@ -274,3 +297,69 @@ describe("maybeRebuildMemoryV2Concepts (daemon startup gate)", () => {
     );
   });
 });
+
+describe("rebuildBm25CorpusStatsAndReseedSkills", () => {
+  beforeEach(resetState);
+
+  test("builds corpus stats then re-seeds skills when v2 is enabled", async () => {
+    await rebuildBm25CorpusStatsAndReseedSkills(makeConfig(true));
+
+    expect(state.corpusStatsBuildCount).toBe(1);
+    expect(state.seedCallCount).toBe(1);
+    // Must pass throwOnError: true so a swallowed internal seed failure
+    // cannot trip the unconditional success log in the caller.
+    expect(state.seedCallOpts[0]).toEqual({ throwOnError: true });
+    expect(state.warnCalls).toHaveLength(0);
+  });
+
+  test("builds corpus stats but skips skill reseed when v2 is disabled", async () => {
+    await rebuildBm25CorpusStatsAndReseedSkills(makeConfig(false));
+
+    expect(state.corpusStatsBuildCount).toBe(1);
+    expect(state.seedCallCount).toBe(0);
+    expect(state.warnCalls).toHaveLength(0);
+  });
+
+  test("skips the reseed and logs a warning when the corpus-stats build throws", async () => {
+    state.corpusStatsThrows = new Error("listPages failed");
+
+    // Must not throw — fire-and-forget startup must not block.
+    let thrown: unknown = null;
+    try {
+      await rebuildBm25CorpusStatsAndReseedSkills(makeConfig(true));
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeNull();
+
+    expect(state.corpusStatsBuildCount).toBe(1);
+    expect(state.seedCallCount).toBe(0);
+    const corpusWarn = state.warnCalls.find(
+      (w) =>
+        typeof w.msg === "string" &&
+        w.msg.includes("BM25 corpus-stats rebuild failed"),
+    );
+    expect(corpusWarn).toBeTruthy();
+  });
+
+  test("swallows skill-reseed rejections after a successful corpus-stats build", async () => {
+    state.seedShouldReject = new Error("reseed failed");
+
+    let thrown: unknown = null;
+    try {
+      await rebuildBm25CorpusStatsAndReseedSkills(makeConfig(true));
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeNull();
+
+    expect(state.corpusStatsBuildCount).toBe(1);
+    expect(state.seedCallCount).toBe(1);
+    const reseedWarn = state.warnCalls.find(
+      (w) =>
+        typeof w.msg === "string" &&
+        w.msg.includes("Failed to re-seed v2 skill entries"),
+    );
+    expect(reseedWarn).toBeTruthy();
+  });
+});

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

@@ -25,6 +25,10 @@ mock.module("../config/loader.js", () => ({
     provider: "test",
     memory: { enabled: false },
     rateLimit: { maxRequestsPerMinute: 0 },
+    slack: {
+      teamId: "T123",
+      teamUrl: "https://example.slack.com/",
+    },
   }),
 }));
 
@@ -32,6 +36,7 @@ import { createConversation } from "../memory/conversation-crud.js";
 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 { handleListMessages } from "../runtime/routes/conversation-routes.js";
 import { BadRequestError } from "../runtime/routes/errors.js";
 
@@ -82,6 +87,13 @@ interface MessagePayload {
   role: string;
   content: string;
   timestamp: string;
+  slackMessage?: {
+    channelId: string;
+    channelTs: string;
+    threadTs?: string;
+    messageLink?: { appUrl?: string; webUrl?: string };
+    threadLink?: { appUrl?: string; webUrl?: string };
+  };
 }
 
 interface ListResponse {
@@ -194,6 +206,49 @@ describe("handleListMessages page=latest", () => {
     expect(body.oldestMessageId).toBeNull();
   });
 
+  test("messages expose Slack message and thread links from slackMeta", () => {
+    const conv = createConversation();
+    const db = getDb();
+    db.insert(messages)
+      .values({
+        id: "msg-slack",
+        conversationId: conv.id,
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Slack reply" }]),
+        metadata: JSON.stringify({
+          slackMeta: writeSlackMetadata({
+            source: "slack",
+            channelId: "C123ABCDEF",
+            channelTs: "1710000000.000200",
+            threadTs: "1710000000.000100",
+            eventKind: "message",
+          }),
+        }),
+        createdAt: 1,
+      })
+      .run();
+
+    const body = callList({ conversationId: conv.id, page: "latest" });
+
+    expect(body.messages[0].slackMessage).toEqual({
+      channelId: "C123ABCDEF",
+      channelTs: "1710000000.000200",
+      threadTs: "1710000000.000100",
+      messageLink: {
+        appUrl:
+          "slack://channel?team=T123&id=C123ABCDEF&message=1710000000.000200",
+        webUrl:
+          "https://example.slack.com/archives/C123ABCDEF/p1710000000000200",
+      },
+      threadLink: {
+        appUrl:
+          "slack://channel?team=T123&id=C123ABCDEF&message=1710000000.000100",
+        webUrl:
+          "https://example.slack.com/archives/C123ABCDEF/p1710000000000100",
+      },
+    });
+  });
+
   test("page=latest on unresolved conversationKey returns null metadata contract", () => {
     const body = callList({
       conversationKey: "no-such-key",

package/src/__tests__/llm-call-pipeline.test.ts

@@ -157,7 +157,6 @@ describe("llmCall pipeline", () => {
       manifest: {
         name: "spy-llm",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1" },
       },
       middleware: {
         llmCall: async (args, next, _ctx) => {
@@ -209,7 +208,6 @@ describe("llmCall pipeline", () => {
       manifest: {
         name: "spy-llm-after-default",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1" },
       },
       middleware: {
         llmCall: async (args, next, _ctx) => {
@@ -255,7 +253,6 @@ describe("llmCall pipeline", () => {
       manifest: {
         name: "short-circuit-llm",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1" },
       },
       middleware: { llmCall: shortCircuit },
     };

package/src/__tests__/llm-catalog-parity.test.ts

@@ -2,8 +2,8 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
-import { MANAGED_PROVIDER_META } from "../providers/managed-proxy/constants.js";
 import { PROVIDER_CATALOG } from "../providers/model-catalog.js";
+import { PLATFORM_PROVIDER_META } from "../providers/platform-proxy/constants.js";
 import { resolvePricing, resolvePricingForUsage } from "../util/pricing.js";
 
 /**
@@ -29,6 +29,15 @@ function getRepoRoot(): string {
   return join(process.cwd(), "..");
 }
 
+const META_JSON_PATH = join(getRepoRoot(), "meta", "llm-provider-catalog.json");
+const SWIFTPM_MIRROR_PATH = join(
+  getRepoRoot(),
+  "clients",
+  "shared",
+  "Resources",
+  "llm-provider-catalog.json",
+);
+
 interface ClientCatalogCredentialsGuide {
   description: string;
   url: string;
@@ -71,7 +80,7 @@ interface ClientCatalogEntry {
   envVar?: string;
   apiKeyPlaceholder?: string;
   credentialsGuide?: ClientCatalogCredentialsGuide;
-  supportsManagedAuth?: boolean;
+  supportsPlatformAuth?: boolean;
   defaultModel: string;
   models: ClientCatalogModel[];
 }
@@ -82,8 +91,7 @@ interface ClientCatalog {
 }
 
 function loadClientCatalog(): ClientCatalog {
-  const catalogPath = join(getRepoRoot(), "meta", "llm-provider-catalog.json");
-  const raw = readFileSync(catalogPath, "utf-8");
+  const raw = readFileSync(META_JSON_PATH, "utf-8");
   return JSON.parse(raw);
 }
 
@@ -124,8 +132,8 @@ describe("LLM catalog parity: daemon vs client", () => {
       expect(clientEntry.setupHint).toBe(daemonEntry.setupHint);
       expect(clientEntry.envVar).toBe(daemonEntry.envVar);
       expect(clientEntry.apiKeyPlaceholder).toBe(daemonEntry.apiKeyPlaceholder);
-      expect(clientEntry.supportsManagedAuth).toBe(
-        daemonEntry.supportsManagedAuth,
+      expect(clientEntry.supportsPlatformAuth).toBe(
+        daemonEntry.supportsPlatformAuth,
       );
       expect(clientEntry.credentialsGuide).toEqual(
         daemonEntry.credentialsGuide,
@@ -134,16 +142,16 @@ describe("LLM catalog parity: daemon vs client", () => {
     }
   });
 
-  test("supportsManagedAuth mirrors MANAGED_PROVIDER_META", () => {
-    // The catalog field is derived from MANAGED_PROVIDER_META at build
+  test("supportsPlatformAuth mirrors PLATFORM_PROVIDER_META", () => {
+    // The catalog field is derived from PLATFORM_PROVIDER_META at build
     // time. This test guards against future hand-edits to model-catalog.ts
-    // that would let the two drift. Adding a provider to MANAGED_PROVIDER_META
+    // that would let the two drift. Adding a provider to PLATFORM_PROVIDER_META
     // must auto-propagate; flipping `managed: true` to `false` (or vice
     // versa) must propagate too.
     for (const entry of PROVIDER_CATALOG) {
       const expectedSupportsManagedAuth =
-        MANAGED_PROVIDER_META[entry.id]?.managed === true;
-      expect(entry.supportsManagedAuth).toBe(expectedSupportsManagedAuth);
+        PLATFORM_PROVIDER_META[entry.id]?.managed === true;
+      expect(entry.supportsPlatformAuth).toBe(expectedSupportsManagedAuth);
     }
   });
 
@@ -208,6 +216,26 @@ describe("LLM catalog parity: daemon vs client", () => {
     }
   });
 
+  test("cache pricing rates are positive when defined", () => {
+    for (const entry of PROVIDER_CATALOG) {
+      for (const model of entry.models) {
+        if (!model.pricing) continue;
+        if (model.pricing.cacheReadPer1mTokens !== undefined) {
+          expect(
+            model.pricing.cacheReadPer1mTokens,
+            `${entry.id}/${model.id} cacheReadPer1mTokens must be positive`,
+          ).toBeGreaterThan(0);
+        }
+        if (model.pricing.cacheWritePer1mTokens !== undefined) {
+          expect(
+            model.pricing.cacheWritePer1mTokens,
+            `${entry.id}/${model.id} cacheWritePer1mTokens must be positive`,
+          ).toBeGreaterThan(0);
+        }
+      }
+    }
+  });
+
   test("every model default context is capped by its context window", () => {
     const json = loadClientCatalog();
 
@@ -383,8 +411,7 @@ describe("LLM catalog parity: daemon vs client", () => {
             `${provider.id}/${model.id} unpriced at tier ${tier.inputTokenThreshold}`,
           ).toBe("priced");
           const resolvedRate =
-            (result.estimatedCostUsd ?? 0) *
-            (TOKENS_PER_MILLION / probeTokens);
+            (result.estimatedCostUsd ?? 0) * (TOKENS_PER_MILLION / probeTokens);
           expect(
             resolvedRate,
             `${provider.id}/${model.id} input rate drift at tier ${tier.inputTokenThreshold}`,
@@ -407,4 +434,19 @@ describe("LLM catalog parity: daemon vs client", () => {
       longContextMode: "native-model",
     });
   });
+
+  // -----------------------------------------------------------------------
+  // Mirror byte-equality
+  // -----------------------------------------------------------------------
+
+  test("SwiftPM mirror is byte-identical to meta/ copy", () => {
+    // `sync-llm-catalog.ts` writes both files from the same serializer; this
+    // guard catches any case where one copy is regenerated without the other.
+    // Byte equality is required because SwiftPM bundles the resource verbatim
+    // into `VellumAssistantShared` while the meta/ JSON is consumed as a
+    // cross-package artifact (web codegen, etc.).
+    const metaBytes = readFileSync(META_JSON_PATH);
+    const swiftPmBytes = readFileSync(SWIFTPM_MIRROR_PATH);
+    expect(swiftPmBytes.equals(metaBytes)).toBe(true);
+  });
 });

package/src/__tests__/llm-request-log-source-clickhouse.test.ts

@@ -162,6 +162,40 @@ describe("ClickHouseLlmRequestLogSource", () => {
     expect(rows).toEqual([]);
   });
 
+  test("getRequestLogsByMessageId binds message ids via parameterized placeholders", async () => {
+    // Regression for ATL-537. `getAssistantMessageIdsInTurn` returns the
+    // caller-supplied id straight through when the message lookup misses,
+    // so the value passed in here is what the IN clause receives. The id
+    // ends in a backslash on purpose: with the old inline-literal approach
+    // (quote-doubling only), ClickHouse would honor `\'` as an escaped
+    // quote and the string literal would break out of the IN clause.
+    // The fix binds each id as a typed `{id_N:String}` parameter, so the
+    // hostile content flows as data, never syntax.
+    const recorder: FakeFetchCall[] = [];
+    const malicious = "foo\\";
+    const src = makeSource({
+      body: "",
+      recorder,
+      resolveTurnMessageIds: () => [malicious, "msg-b"],
+    });
+    await src.getRequestLogsByMessageId(malicious);
+    expect(recorder).toHaveLength(1);
+    const call = recorder[0]!;
+    const parsed = new URL(call.url);
+    expect(parsed.searchParams.get("param_assistant_id")).toBe(
+      "asst-fixture-001",
+    );
+    expect(parsed.searchParams.get("param_id_0")).toBe(malicious);
+    expect(parsed.searchParams.get("param_id_1")).toBe("msg-b");
+    const body = String(call.init?.body ?? "");
+    expect(body).toContain("message_id IN ({id_0:String},{id_1:String})");
+    // No inline single-quoted literal should appear for the IN clause:
+    // if any caller-supplied id surfaces unbound in the SQL, that's the
+    // injection surface the regression test guards against.
+    expect(body).not.toContain(`'${malicious}'`);
+    expect(body).not.toContain(`'msg-b'`);
+  });
+
   test("missing clickhouse:url credential surfaces a clear error", async () => {
     const src = new ClickHouseLlmRequestLogSource(DEFAULT_CONFIG, {
       resolveUrl: async () => null,

package/src/__tests__/llm-request-log-source-factory.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterAll, describe, expect, mock, test } from "bun:test";
 
 function makeLoggerStub(): Record<string, unknown> {
   const stub: Record<string, unknown> = {};
@@ -22,19 +22,10 @@ mock.module("../util/logger.js", () => ({
 }));
 
 // Configurable config stub. Each test sets `currentConfig` before calling
-// the factory. The ClickHouse source is dynamic-imported, so its constructor
-// runs lazily; we don't need to mock conversation-crud here because none of
-// the factory's tests actually exercise the CH read path.
-const LOCAL_DEFAULT_CONFIG = {
-  llmRequestLogs: {
-    readSource: "local",
-    clickhouse: {
-      database: "default",
-      table: "llm_request_logs",
-      user: "default",
-    },
-  },
-};
+// the factory. The ClickHouse source is dynamic-imported, so its
+// constructor runs lazily; we don't need to mock conversation-crud here
+// because none of the factory tests exercise the CH read path.
+const LOCAL_DEFAULT_CONFIG = { llmRequestLogs: { readSource: "local" } };
 let currentConfig: unknown = LOCAL_DEFAULT_CONFIG;
 mock.module("../config/loader.js", () => ({
   getConfig: () => currentConfig,
@@ -43,32 +34,18 @@ mock.module("../config/loader.js", () => ({
 // Bun's `mock.module()` persists process-wide; reset to the safe local
 // default after this file runs so other test files that touch this module
 // (or transitively call `getConfig()` through the factory) don't pick up
-// a stale `readSource=clickhouse` value. Also drop the factory's internal
-// cache so the next caller resolves fresh against the reset config.
+// a stale `readSource=clickhouse` value.
 afterAll(() => {
   currentConfig = LOCAL_DEFAULT_CONFIG;
-  invalidateLlmRequestLogSourceCache();
 });
 
-import {
-  getLlmRequestLogSource,
-  invalidateLlmRequestLogSourceCache,
-} from "../memory/llm-request-log-source.js";
+import { getLlmRequestLogSource } from "../memory/llm-request-log-source.js";
 import { ClickHouseLlmRequestLogSource } from "../memory/llm-request-log-source-clickhouse.js";
 import { LocalLlmRequestLogSource } from "../memory/llm-request-log-source-local.js";
 
 describe("getLlmRequestLogSource factory", () => {
-  beforeEach(() => {
-    invalidateLlmRequestLogSourceCache();
-  });
-
   test("returns LocalLlmRequestLogSource when readSource is 'local'", async () => {
-    currentConfig = {
-      llmRequestLogs: {
-        readSource: "local",
-        clickhouse: { database: "default", table: "llm_request_logs", user: "default" },
-      },
-    };
+    currentConfig = { llmRequestLogs: { readSource: "local" } };
     const src = await getLlmRequestLogSource();
     expect(src).toBeInstanceOf(LocalLlmRequestLogSource);
   });
@@ -83,42 +60,41 @@ describe("getLlmRequestLogSource factory", () => {
     currentConfig = {
       llmRequestLogs: {
         readSource: "clickhouse",
-        clickhouse: { database: "default", table: "llm_request_logs", user: "default" },
+        clickhouse: {
+          database: "default",
+          table: "llm_request_logs",
+          user: "default",
+        },
       },
     };
     const src = await getLlmRequestLogSource();
     expect(src).toBeInstanceOf(ClickHouseLlmRequestLogSource);
   });
 
-  test("caches the resolved source across calls", async () => {
-    currentConfig = {
-      llmRequestLogs: {
-        readSource: "local",
-        clickhouse: { database: "default", table: "llm_request_logs", user: "default" },
-      },
-    };
+  test("instantiates a fresh source on every call (no module-level cache)", async () => {
+    currentConfig = { llmRequestLogs: { readSource: "local" } };
     const first = await getLlmRequestLogSource();
     const second = await getLlmRequestLogSource();
-    expect(second).toBe(first);
+    expect(second).not.toBe(first);
+    expect(second).toBeInstanceOf(LocalLlmRequestLogSource);
   });
 
-  test("invalidateLlmRequestLogSourceCache forces a fresh resolution", async () => {
-    currentConfig = {
-      llmRequestLogs: {
-        readSource: "local",
-        clickhouse: { database: "default", table: "llm_request_logs", user: "default" },
-      },
-    };
-    const first = await getLlmRequestLogSource();
-    invalidateLlmRequestLogSourceCache();
+  test("picks up live config changes without an invalidation hook", async () => {
+    currentConfig = { llmRequestLogs: { readSource: "local" } };
+    const before = await getLlmRequestLogSource();
+    expect(before).toBeInstanceOf(LocalLlmRequestLogSource);
+
     currentConfig = {
       llmRequestLogs: {
         readSource: "clickhouse",
-        clickhouse: { database: "default", table: "llm_request_logs", user: "default" },
+        clickhouse: {
+          database: "default",
+          table: "llm_request_logs",
+          user: "default",
+        },
       },
     };
-    const second = await getLlmRequestLogSource();
-    expect(second).not.toBe(first);
-    expect(second).toBeInstanceOf(ClickHouseLlmRequestLogSource);
+    const after = await getLlmRequestLogSource();
+    expect(after).toBeInstanceOf(ClickHouseLlmRequestLogSource);
   });
 });