@vellumai/assistant 0.8.2 → 0.8.4

package/src/__tests__/compactor-preserved-tail-count.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, mock, test } from "bun:test";
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getMessages: () => [],
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  getAttachmentMetadataForMessage: () => [],
+  getAttachmentContent: () => null,
+}));
+
+import { runAssistantDrivenCompaction } from "../context/compactor.js";
+import type { Message, Provider } from "../providers/types.js";
+
+const TAIL_TIMESTAMP =
+  "2026-05-21 (Thursday) 10:00:00 -05:00 (America/Chicago)";
+
+const compactionResponse = `
+<compaction_result>
+<summary>
+Earlier turns summarized here.
+</summary>
+
+<key_state>
+- Nothing critical pending.
+</key_state>
+
+<tail_start timestamp="${TAIL_TIMESTAMP}" preview="tail anchor message" />
+</compaction_result>
+`;
+
+function makeProvider(): Provider {
+  return {
+    name: "mock-provider",
+    sendMessage: async () => ({
+      content: [{ type: "text", text: compactionResponse }],
+      model: "mock-model",
+      usage: { inputTokens: 100, outputTokens: 50 },
+      stopReason: "end_turn",
+    }),
+  };
+}
+
+const userText = (text: string): Message => ({
+  role: "user",
+  content: [{ type: "text", text }],
+});
+
+const userTextWithTurnContext = (text: string, timestamp: string): Message => ({
+  role: "user",
+  content: [
+    {
+      type: "text",
+      text: `<turn_context>\ncurrent_time: ${timestamp}\n</turn_context>\n${text}`,
+    },
+  ],
+});
+
+const assistantText = (text: string): Message => ({
+  role: "assistant",
+  content: [{ type: "text", text }],
+});
+
+describe("runAssistantDrivenCompaction — preservedTailMessages count", () => {
+  test("reflects the pre-strip tail size so the reported cut point matches the user-visible split", async () => {
+    const messages: Message[] = [
+      userText("old user turn 1"),
+      assistantText("old assistant reply 1"),
+      userText("old user turn 2"),
+      userTextWithTurnContext("tail anchor message", TAIL_TIMESTAMP),
+      userText("<system_reminder>\nstale reminder\n</system_reminder>"),
+      userText("<knowledge_base>\nstale pkb\n</knowledge_base>"),
+      assistantText("most recent assistant reply"),
+    ];
+
+    const result = await runAssistantDrivenCompaction({
+      conversationId: "conv-test",
+      messages,
+      provider: makeProvider(),
+      systemPrompt: "system",
+      compaction: { enabled: true, autoThreshold: 0.7 },
+      maxInputTokens: 1000,
+      previousEstimatedInputTokens: 900,
+    });
+
+    expect(result.compacted).toBe(true);
+    expect(result.preservedTailMessages).toBe(4);
+  });
+});

package/src/__tests__/compactor-tail-resolution.test.ts

@@ -1,6 +1,46 @@
 import { describe, expect, it } from "bun:test";
 
-import { canonicalDateTimeKey } from "../context/compactor.js";
+import {
+  adjustTailIndexForToolPairing,
+  canonicalDateTimeKey,
+} from "../context/compactor.js";
+import type { Message } from "../providers/types.js";
+
+const userText = (text: string): Message => ({
+  role: "user",
+  content: [{ type: "text", text }],
+});
+
+const userToolResult = (toolUseId: string): Message => ({
+  role: "user",
+  content: [{ type: "tool_result", tool_use_id: toolUseId, content: "ok" }],
+});
+
+const userToolResultAndText = (toolUseId: string, text: string): Message => ({
+  role: "user",
+  content: [
+    { type: "tool_result", tool_use_id: toolUseId, content: "ok" },
+    { type: "text", text },
+  ],
+});
+
+const assistantToolUse = (id: string): Message => ({
+  role: "assistant",
+  content: [{ type: "tool_use", id, name: "Bash", input: {} }],
+});
+
+const assistantText = (text: string): Message => ({
+  role: "assistant",
+  content: [{ type: "text", text }],
+});
+
+const assistantWebSearch = (id: string): Message => ({
+  role: "assistant",
+  content: [
+    { type: "server_tool_use", id, name: "web_search", input: {} },
+    { type: "web_search_tool_result", tool_use_id: id, content: [] },
+  ],
+});
 
 describe("canonicalDateTimeKey", () => {
   const stored = "2026-04-02 (Thursday) 01:52:33 -05:00 (America/Chicago)";
@@ -39,3 +79,69 @@ describe("canonicalDateTimeKey", () => {
     expect(canonicalDateTimeKey("01:52:33")).toBeNull();
   });
 });
+
+describe("adjustTailIndexForToolPairing", () => {
+  it("returns tailIndex unchanged when the tail starts on a clean user turn", () => {
+    const messages: Message[] = [
+      userText("hi"),
+      assistantText("hello"),
+      userText("how are you"),
+    ];
+    expect(adjustTailIndexForToolPairing(messages, 2)).toBe(2);
+  });
+
+  it("walks back past the orphan tool_result cluster to the prior user turn", () => {
+    const messages: Message[] = [
+      userText("setup"),
+      assistantText("ok"),
+      userText("run a command"),
+      assistantToolUse("X"),
+      userToolResult("X"),
+    ];
+    expect(adjustTailIndexForToolPairing(messages, 4)).toBe(2);
+  });
+
+  it("keeps walking when the candidate also leads with tool_result", () => {
+    const messages: Message[] = [
+      userText("first"),
+      userText("second"),
+      assistantToolUse("X1"),
+      userToolResult("X1"),
+      assistantToolUse("X2"),
+      userToolResult("X2"),
+    ];
+    expect(adjustTailIndexForToolPairing(messages, 5)).toBe(1);
+  });
+
+  it("returns 0 when the walk falls off the front of the array", () => {
+    const messages: Message[] = [
+      userToolResult("X"),
+      assistantToolUse("Y"),
+      userToolResult("Y"),
+    ];
+    expect(adjustTailIndexForToolPairing(messages, 2)).toBe(0);
+  });
+
+  it("ignores server-side web_search_tool_result blocks", () => {
+    const messages: Message[] = [
+      userText("look it up"),
+      assistantWebSearch("WS1"),
+      userText("thanks"),
+    ];
+    expect(adjustTailIndexForToolPairing(messages, 2)).toBe(2);
+  });
+
+  it("treats mixed tool_result + text user messages as unsafe", () => {
+    const messages: Message[] = [
+      userText("kick off"),
+      assistantToolUse("X"),
+      userToolResultAndText("X", "and here is more text"),
+    ];
+    expect(adjustTailIndexForToolPairing(messages, 2)).toBe(0);
+  });
+
+  it("returns tailIndex unchanged when tailIndex is 0", () => {
+    const messages: Message[] = [userText("only one")];
+    expect(adjustTailIndexForToolPairing(messages, 0)).toBe(0);
+  });
+});

package/src/__tests__/config-get-vision-flag.test.ts

@@ -0,0 +1,136 @@
+/**
+ * Verifies that `GET /v1/config` enriches each profile in `llm.profiles`
+ * with `supportsVision` resolved from the model catalog.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+// ---------------------------------------------------------------------------
+// Mocks for handleGetConfig's transitive deps
+// ---------------------------------------------------------------------------
+
+let rawConfig: Record<string, unknown> = {};
+
+mock.module("../config/loader.js", () => ({
+  loadRawConfig: () => structuredClone(rawConfig),
+  saveRawConfig: () => {},
+  deepMergeOverwrite: () => {},
+  getConfig: () => rawConfig,
+  getDeploymentContextDefaults: () => ({}),
+  fillContextDefaultsForMissingKeys: () => {},
+  invalidateConfigCache: () => {},
+  setNestedValue: () => {},
+}));
+
+mock.module("../providers/registry.js", () => ({
+  initializeProviders: async () => {},
+}));
+
+mock.module("../memory/embedding-backend.js", () => ({
+  clearEmbeddingBackendCache: () => {},
+}));
+
+mock.module("../security/secret-allowlist.js", () => ({
+  validateAllowlistFile: () => null,
+}));
+
+import { ROUTES } from "../runtime/routes/conversation-query-routes.js";
+
+const configGetRoute = ROUTES.find((r) => r.operationId === "config_get")!;
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("GET /v1/config profile vision enrichment", () => {
+  test("profile with a non-vision model gets supportsVision: false", () => {
+    rawConfig = {
+      llm: {
+        profiles: {
+          "test-no-vision": {
+            provider: "fireworks",
+            model: "accounts/fireworks/models/kimi-k2p5",
+          },
+        },
+      },
+    };
+
+    const result = configGetRoute.handler({}) as {
+      llm?: {
+        profiles?: Record<string, { supportsVision?: boolean }>;
+      };
+    };
+
+    expect(result?.llm?.profiles?.["test-no-vision"]?.supportsVision).toBe(
+      false,
+    );
+  });
+
+  test("profile with a vision-capable model gets supportsVision: true", () => {
+    rawConfig = {
+      llm: {
+        profiles: {
+          "test-vision": {
+            provider: "anthropic",
+            model: "claude-opus-4-6",
+          },
+        },
+      },
+    };
+
+    const result = configGetRoute.handler({}) as {
+      llm?: {
+        profiles?: Record<string, { supportsVision?: boolean }>;
+      };
+    };
+
+    expect(result?.llm?.profiles?.["test-vision"]?.supportsVision).toBe(true);
+  });
+
+  test("profile with an unknown model defaults supportsVision to true (fail-open)", () => {
+    rawConfig = {
+      llm: {
+        profiles: {
+          "test-unknown": {
+            provider: "anthropic",
+            model: "some-unknown-model-xyz",
+          },
+        },
+      },
+    };
+
+    const result = configGetRoute.handler({}) as {
+      llm?: {
+        profiles?: Record<string, { supportsVision?: boolean }>;
+      };
+    };
+
+    expect(result?.llm?.profiles?.["test-unknown"]?.supportsVision).toBe(true);
+  });
+
+  test("profile without provider/model is left without supportsVision", () => {
+    rawConfig = {
+      llm: {
+        profiles: {
+          "test-empty": {},
+        },
+      },
+    };
+
+    const result = configGetRoute.handler({}) as {
+      llm?: {
+        profiles?: Record<string, { supportsVision?: boolean }>;
+      };
+    };
+
+    expect(
+      result?.llm?.profiles?.["test-empty"]?.supportsVision,
+    ).toBeUndefined();
+  });
+});

package/src/__tests__/config-loader-backfill.test.ts

@@ -7,6 +7,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
+import { Database } from "bun:sqlite";
 import {
   afterAll,
   afterEach,
@@ -17,6 +18,8 @@ import {
   test,
 } from "bun:test";
 
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
 // ---------------------------------------------------------------------------
 // Mocks — declared before imports that depend on platform/logger
 // ---------------------------------------------------------------------------
@@ -73,6 +76,12 @@ import {
   mergeDefaultWorkspaceConfig,
 } from "../config/loader.js";
 import { seedInferenceProfiles } from "../config/seed-inference-profiles.js";
+import type { DrizzleDb } from "../memory/db-connection.js";
+import { migrateCreateProviderConnections } from "../memory/migrations/243-provider-connections.js";
+import { migrateProviderConnectionStatusLabel } from "../memory/migrations/244-provider-connection-status-label.js";
+import { migrateProviderConnectionBaseUrlAndModels } from "../memory/migrations/250-provider-connection-base-url-and-models.js";
+import * as schema from "../memory/schema.js";
+import { getConnection } from "../providers/inference/connections.js";
 import { _setStorePath } from "../security/encrypted-store.js";
 
 // ---------------------------------------------------------------------------
@@ -83,15 +92,26 @@ function writeConfig(obj: unknown): void {
   writeFileSync(CONFIG_PATH, JSON.stringify(obj, null, 2) + "\n");
 }
 
-function mergeDefaultConfigAndSeedInferenceProfiles(): void {
+function mergeDefaultConfigAndSeedInferenceProfiles(db?: DrizzleDb): void {
   const defaultConfigMerge = mergeDefaultWorkspaceConfig();
   seedInferenceProfiles({
     preserveProfileNames: defaultConfigMerge.providedLlmProfileNames,
     preserveActiveProfile: defaultConfigMerge.providedLlmActiveProfile,
     isHatch: defaultConfigMerge.hadOverlay,
+    db,
   });
 }
 
+function createProviderConnectionsDb(): DrizzleDb {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  const db = drizzle(sqlite, { schema });
+  migrateCreateProviderConnections(db);
+  migrateProviderConnectionStatusLabel(db);
+  migrateProviderConnectionBaseUrlAndModels(db);
+  return db;
+}
+
 // ---------------------------------------------------------------------------
 // Tests: deepMergeOverwrite (unit) — JSON-null-as-deletion semantics
 //
@@ -523,7 +543,7 @@ describe("loadConfig startup behavior", () => {
     expect(raw.llm.profiles["custom-balanced"].provider_connection).toBe(
       "anthropic-personal",
     );
-    // Managed profiles are also seeded for anthropic-managed.
+    // Managed balanced profile is seeded for anthropic-managed.
     expect(raw.llm.profiles.balanced.provider).toBe("anthropic");
     expect(raw.llm.profiles.balanced.provider_connection).toBe(
       "anthropic-managed",
@@ -589,11 +609,8 @@ describe("loadConfig startup behavior", () => {
     const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
     writeFileSync(
       overlayPath,
-      JSON.stringify(
-        { llm: { default: { provider: "openai" } } },
-        null,
-        2,
-      ) + "\n",
+      JSON.stringify({ llm: { default: { provider: "openai" } } }, null, 2) +
+        "\n",
     );
     process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = overlayPath;
 
@@ -617,7 +634,7 @@ describe("loadConfig startup behavior", () => {
       "gpt-5.4-nano",
     );
 
-    // Managed anthropic profiles are also seeded.
+    // Managed profiles are also seeded (balanced uses Anthropic).
     expect(raw.llm.profiles.balanced.provider).toBe("anthropic");
     expect(raw.llm.profiles.balanced.provider_connection).toBe(
       "anthropic-managed",
@@ -981,11 +998,8 @@ describe("seedInferenceProfiles BYOK-mode managed profile labels", () => {
     const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
     writeFileSync(
       overlayPath,
-      JSON.stringify(
-        { llm: { default: { provider: "anthropic" } } },
-        null,
-        2,
-      ) + "\n",
+      JSON.stringify({ llm: { default: { provider: "anthropic" } } }, null, 2) +
+        "\n",
     );
     process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = overlayPath;
 
@@ -997,6 +1011,92 @@ describe("seedInferenceProfiles BYOK-mode managed profile labels", () => {
     expect(config.llm.profiles["cost-optimized"]?.status).toBe("disabled");
   });
 
+  test("off-platform managed-inference hatch keeps selected managed connection active", () => {
+    const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
+    writeFileSync(
+      overlayPath,
+      JSON.stringify(
+        {
+          llm: {
+            default: { provider: "anthropic" },
+            activeProfile: "balanced",
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = overlayPath;
+    const db = createProviderConnectionsDb();
+
+    mergeDefaultConfigAndSeedInferenceProfiles(db);
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+
+    expect(raw.llm.activeProfile).toBe("balanced");
+    expect(raw.llm.profiles.balanced.provider_connection).toBe(
+      "anthropic-managed",
+    );
+    expect("status" in raw.llm.profiles.balanced).toBe(false);
+    expect(getConnection(db, "anthropic-managed")?.status).toBe("active");
+    expect(getConnection(db, "openai-managed")?.status).toBe("disabled");
+    expect(getConnection(db, "gemini-managed")?.status).toBe("disabled");
+  });
+
+  test("off-platform managed-inference hatch respects explicit non-managed active connection", () => {
+    const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
+    writeFileSync(
+      overlayPath,
+      JSON.stringify(
+        {
+          llm: {
+            default: { provider: "anthropic" },
+            profiles: {
+              balanced: {
+                source: "managed",
+                provider: "anthropic",
+                provider_connection: "anthropic-personal",
+                model: "claude-sonnet-4-6",
+              },
+            },
+            activeProfile: "balanced",
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = overlayPath;
+    const db = createProviderConnectionsDb();
+
+    mergeDefaultConfigAndSeedInferenceProfiles(db);
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+
+    expect(raw.llm.activeProfile).toBe("balanced");
+    expect(raw.llm.profiles.balanced.provider_connection).toBe(
+      "anthropic-personal",
+    );
+    expect(getConnection(db, "anthropic-managed")?.status).toBe("disabled");
+    expect(getConnection(db, "openai-managed")?.status).toBe("disabled");
+    expect(getConnection(db, "gemini-managed")?.status).toBe("disabled");
+  });
+
+  test("off-platform BYOK hatch still disables managed connections", () => {
+    const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
+    writeFileSync(
+      overlayPath,
+      JSON.stringify({ llm: { default: { provider: "anthropic" } } }, null, 2) +
+        "\n",
+    );
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = overlayPath;
+    const db = createProviderConnectionsDb();
+
+    mergeDefaultConfigAndSeedInferenceProfiles(db);
+
+    expect(getConnection(db, "anthropic-managed")?.status).toBe("disabled");
+    expect(getConnection(db, "openai-managed")?.status).toBe("disabled");
+    expect(getConnection(db, "gemini-managed")?.status).toBe("disabled");
+  });
+
   test("non-hatch off-platform boot does NOT auto-disable freshly-materialized managed profiles", () => {
     // Existing installs that upgrade to a version where the managed
     // profile didn't previously exist (e.g. a new template added later)
@@ -1029,11 +1129,8 @@ describe("seedInferenceProfiles BYOK-mode managed profile labels", () => {
     const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
     writeFileSync(
       overlayPath,
-      JSON.stringify(
-        { llm: { default: { provider: "anthropic" } } },
-        null,
-        2,
-      ) + "\n",
+      JSON.stringify({ llm: { default: { provider: "anthropic" } } }, null, 2) +
+        "\n",
     );
     process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = overlayPath;
 

package/src/__tests__/config-watcher.test.ts

@@ -117,7 +117,7 @@ mock.module("../providers/registry.js", () => ({
   getProvider: () => undefined,
   listProviders: () => [],
   getProviderRoutingSource: () => undefined,
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
   // Required by `providers/inference/connections.ts` and
   // `providers/connection-resolution.ts`, both loaded transitively when
   // ConfigWatcher's deps resolve. Without these, the import chain throws