@vellumai/assistant 0.8.1 → 0.8.3

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

@@ -0,0 +1,147 @@
+import { describe, expect, it } from "bun:test";
+
+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)";
+
+  it("reduces the verbatim stored format to date+time", () => {
+    expect(canonicalDateTimeKey(stored)).toBe("2026-04-02T01:52:33");
+  });
+
+  it("matches when the model drops the weekday parens", () => {
+    expect(
+      canonicalDateTimeKey("2026-04-02 01:52:33 -05:00 (America/Chicago)"),
+    ).toBe("2026-04-02T01:52:33");
+  });
+
+  it("matches when the model drops the timezone parens", () => {
+    expect(canonicalDateTimeKey("2026-04-02 (Thursday) 01:52:33 -05:00")).toBe(
+      "2026-04-02T01:52:33",
+    );
+  });
+
+  it("matches when the model emits ISO-8601 with a T separator", () => {
+    expect(canonicalDateTimeKey("2026-04-02T01:52:33-05:00")).toBe(
+      "2026-04-02T01:52:33",
+    );
+  });
+
+  it("matches when the model emits only date and time", () => {
+    expect(canonicalDateTimeKey("2026-04-02 01:52:33")).toBe(
+      "2026-04-02T01:52:33",
+    );
+  });
+
+  it("returns null when no date+time pair is present", () => {
+    expect(canonicalDateTimeKey("hello world")).toBeNull();
+    expect(canonicalDateTimeKey("2026-04-02")).toBeNull();
+    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-schema.test.ts

@@ -361,6 +361,27 @@ describe("AssistantConfigSchema", () => {
     });
   });
 
+  test("scratchpad injection defaults to enabled", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.memory.retrieval.scratchpadInjection).toEqual({
+      enabled: true,
+    });
+  });
+
+  test("scratchpad injection accepts disabled override", () => {
+    const result = AssistantConfigSchema.parse({
+      memory: { retrieval: { scratchpadInjection: { enabled: false } } },
+    });
+    expect(result.memory.retrieval.scratchpadInjection.enabled).toBe(false);
+  });
+
+  test("scratchpad injection rejects non-boolean enabled", () => {
+    const result = AssistantConfigSchema.safeParse({
+      memory: { retrieval: { scratchpadInjection: { enabled: "yes" } } },
+    });
+    expect(result.success).toBe(false);
+  });
+
   test("applies memory.cleanup defaults", () => {
     const result = AssistantConfigSchema.parse({});
     expect(result.memory.cleanup).toEqual({

package/src/__tests__/config-set-route.test.ts

@@ -27,6 +27,8 @@ mock.module("../config/loader.js", () => ({
   deepMergeOverwrite: () => {},
   getConfig: () => rawConfig,
   invalidateConfigCache: () => {},
+  withSuppressedConfigDiskWrites: async (fn: () => unknown) => fn(),
+  withSuppressedConfigDiskWritesSync: (fn: () => unknown) => fn(),
   // setNestedValue is also exported by loader; handleSetConfig imports the
   // real one from this module, so we re-export a thin implementation that
   // mutates in place (matches loader's behavior).
@@ -143,6 +145,84 @@ describe("config_set route - request validation", () => {
       .calls as Record<string, unknown>;
     expect(calls.enabled).toBe(true);
   });
+
+  test("preserves user profiles and custom settings when setting unrelated key", async () => {
+    rawConfig = {
+      llm: {
+        activeProfile: "my-custom-profile",
+        profiles: {
+          balanced: {
+            source: "managed",
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+          },
+          "my-custom-profile": {
+            source: "user",
+            provider: "anthropic",
+            model: "claude-opus-4-6",
+            maxTokens: 32000,
+          },
+        },
+      },
+      memory: {
+        embeddings: { provider: "openai" },
+      },
+    };
+    savedRaw = null;
+    const result = await configSetRoute.handler({
+      body: {
+        path: "memory.cleanup.llmRequestLogRetentionMs",
+        value: 86400000,
+      },
+    });
+    expect(result).toEqual({ ok: true });
+    expect(savedRaw).not.toBeNull();
+
+    const saved = savedRaw as unknown as Record<string, unknown>;
+    const llm = saved.llm as Record<string, unknown>;
+    expect(llm.activeProfile).toBe("my-custom-profile");
+
+    const profiles = llm.profiles as Record<string, Record<string, unknown>>;
+    expect(profiles["my-custom-profile"]).toEqual({
+      source: "user",
+      provider: "anthropic",
+      model: "claude-opus-4-6",
+      maxTokens: 32000,
+    });
+    expect(profiles.balanced).toEqual({
+      source: "managed",
+      provider: "anthropic",
+      model: "claude-sonnet-4-6",
+    });
+
+    const memory = saved.memory as Record<string, unknown>;
+    expect((memory.embeddings as Record<string, unknown>).provider).toBe(
+      "openai",
+    );
+    expect(
+      (memory.cleanup as Record<string, unknown>).llmRequestLogRetentionMs,
+    ).toBe(86400000);
+  });
+
+  test("preserves all top-level keys when setting a nested path", async () => {
+    rawConfig = {
+      llm: { default: { provider: "anthropic" } },
+      calls: { enabled: true },
+      heartbeat: { activeHoursStart: "09:00", activeHoursEnd: "22:00" },
+    };
+    savedRaw = null;
+    await configSetRoute.handler({
+      body: { path: "memory.cleanup.conversationRetentionDays", value: 30 },
+    });
+    expect(savedRaw).not.toBeNull();
+    const saved = savedRaw as unknown as Record<string, unknown>;
+    expect(saved.llm).toEqual({ default: { provider: "anthropic" } });
+    expect(saved.calls).toEqual({ enabled: true });
+    expect(saved.heartbeat).toEqual({
+      activeHoursStart: "09:00",
+      activeHoursEnd: "22:00",
+    });
+  });
 });
 
 // ---------------------------------------------------------------------------