@vellumai/assistant 0.8.5 → 0.8.6

package/src/__tests__/inference-profile-reaper.test.ts

@@ -12,7 +12,7 @@ import {
   getConversation,
   setConversationInferenceProfileSession,
 } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import {
@@ -20,6 +20,7 @@ import {
   stopInferenceProfileSessionReaper,
   tickInferenceProfileReaper,
 } from "../runtime/routes/inference-profile-session-reaper.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -40,7 +41,7 @@ describe("inference-profile-session-reaper", () => {
 
   afterAll(() => {
     stopInferenceProfileSessionReaper();
-    resetDb();
+    resetDbForTesting();
     mock.restore();
   });
 

package/src/__tests__/inference-profile-session-ipc.test.ts

@@ -38,9 +38,10 @@ mock.module("../config/loader.js", () => ({
 }));
 
 import { createConversation } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { ROUTES } from "../runtime/routes/inference-profile-session-routes.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -66,7 +67,7 @@ function clearTables(): void {
 describe("inference_profile_open IPC op", () => {
   beforeEach(clearTables);
   afterAll(() => {
-    resetDb();
+    resetDbForTesting();
     mock.restore();
   });
 

package/src/__tests__/injector-disk-pressure.test.ts

@@ -1,6 +1,5 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import {
   applyRuntimeInjections,
   stripInjectionsForCompaction,
@@ -54,10 +53,9 @@ describe("disk-pressure-warning injector", () => {
   beforeEach(() => {
     resetPluginRegistryForTests();
     registerPlugin(defaultInjectorsPlugin);
-    _setOverridesForTesting({ "safe-storage-limits": true });
   });
 
-  test("emits the exact cleanup prompt while safe storage limits are enabled", async () => {
+  test("emits the exact cleanup prompt during disk pressure cleanup mode", async () => {
     const block = await diskPressureInjector.produce(
       makeContext({
         injectionInputs: { diskPressureContext: cleanupContext },
@@ -73,13 +71,13 @@ describe("disk-pressure-warning injector", () => {
       DEFAULT_INJECTOR_ORDER.diskPressureWarning,
     );
     expect(DISK_PRESSURE_WARNING_PROMPT).toBe(`<disk_pressure_warning>
-Disk usage is critically low: this assistant is in storage cleanup mode because the workspace volume is at least 95% full.
+Disk usage is critically low: this assistant is in storage cleanup mode because the workspace volume is critically full.
 
 In your first paragraph, warn the user that storage is critically low and that normal work is suspended until space is freed.
 
 Then help the user clean up storage. Prefer safe inspection steps first, such as checking available space and finding large directories. Ask before deleting files or caches unless the user has already clearly approved the specific cleanup action.
 
-Do not work on unrelated tasks until disk usage drops below the critical threshold or the user explicitly overrides the lock. Background processes and messages from trusted contacts are blocked while this cleanup mode is active.
+Do not work on unrelated tasks until enough space is freed to clear the lock or the user explicitly overrides it. Background processes and messages from trusted contacts are blocked while this cleanup mode is active.
 </disk_pressure_warning>`);
   });
 
@@ -101,18 +99,6 @@ Do not work on unrelated tasks until disk usage drops below the critical thresho
     ).resolves.toBeNull();
   });
 
-  test("omits the prompt when safe storage limits are disabled", async () => {
-    _setOverridesForTesting({ "safe-storage-limits": false });
-
-    await expect(
-      diskPressureInjector.produce(
-        makeContext({
-          injectionInputs: { diskPressureContext: cleanupContext },
-        }),
-      ),
-    ).resolves.toBeNull();
-  });
-
   test("prepends ahead of workspace and unified turn context in full mode", async () => {
     const runMessages: Message[] = [
       { role: "user", content: [{ type: "text", text: "clean up space" }] },

package/src/__tests__/inline-skill-load-permissions.test.ts

@@ -69,10 +69,10 @@ mockIpcResponse("get_global_thresholds", {
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import { check, generateAllowlistOptions } from "../permissions/checker.js";
 import { clearRiskCache } from "../permissions/checker.js";
 import { _clearGlobalCacheForTesting } from "../permissions/gateway-threshold-reader.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 // ── Helpers ───────────────────────────────────────────────────────────────
 
@@ -115,7 +115,7 @@ describe("inline-command skill_load permissions", () => {
   beforeEach(() => {
     clearRiskCache();
     _clearGlobalCacheForTesting();
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
     mockIpcResponse("get_global_thresholds", {
       interactive: "low",
       autonomous: "medium",
@@ -135,7 +135,7 @@ describe("inline-command skill_load permissions", () => {
   });
 
   afterEach(() => {
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
   });
 
   // ── Default behavior ─────────────────────────────────────────────────
@@ -197,7 +197,7 @@ describe("inline-command skill_load permissions", () => {
       writeDynamicSkill("dynamic-flag-off", "Dynamic Flag Off Skill");
 
       // Disable the feature flag
-      _setOverridesForTesting({
+      setOverridesForTesting({
         "inline-skill-commands": false,
       });
 

package/src/__tests__/list-messages-hidden-metadata.test.ts

@@ -26,12 +26,14 @@ mock.module("../config/loader.js", () => ({
 }));
 
 import {
+  _setPaginationScanCapForTesting,
   addMessage,
   createConversation,
   getMessages,
 } 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 { handleListMessages } from "../runtime/routes/conversation-routes.js";
 
 initializeDb();
@@ -177,6 +179,84 @@ describe("handleListMessages metadata.hidden filtering", () => {
     expect(older.hasMore).toBe(true);
   });
 
+  test("pagination keeps hasMore + a cursor when a >cap hidden block truncates the scan", () => {
+    // Exercise cap-truncation with a small cap + a few hundred rows rather than
+    // >10k: the large seed made the post-test resetTables DELETE slow enough to
+    // time out the next test's beforeEach under parallel CI load.
+    // SCAN_CAP must span a couple of PAGINATION_CHUNK_MIN (50) chunks so the cap
+    // (not DB exhaustion) stops the loop, and HIDDEN_COUNT sits just past it so
+    // the newest cap-worth of rows are all hidden.
+    const SCAN_CAP = 100;
+    _setPaginationScanCapForTesting(SCAN_CAP);
+    try {
+      const conv = createConversation();
+      const db = getDb();
+      const HIDDEN_COUNT = SCAN_CAP + 20; // > scan cap
+      const VISIBLE_COUNT = 2;
+      let createdAt = 0;
+      // Older visible rows first (lowest createdAt), then the hidden block.
+      db.transaction((tx) => {
+        for (let i = 0; i < VISIBLE_COUNT; i++) {
+          createdAt += 1;
+          tx.insert(messages)
+            .values({
+              id: `visible-${i}`,
+              conversationId: conv.id,
+              role: "user",
+              content: JSON.stringify([{ type: "text", text: `visible ${i}` }]),
+              createdAt,
+            })
+            .run();
+        }
+        for (let i = 0; i < HIDDEN_COUNT; i++) {
+          createdAt += 1;
+          tx.insert(messages)
+            .values({
+              id: `hidden-${i}`,
+              conversationId: conv.id,
+              role: "assistant",
+              content: JSON.stringify([{ type: "text", text: `hidden ${i}` }]),
+              createdAt,
+              metadata: JSON.stringify({ hidden: true }),
+            })
+            .run();
+        }
+      });
+
+      const latest = handleListMessages({
+        queryParams: { conversationId: conv.id, page: "latest", limit: "2" },
+      }) as {
+        messages: MessagePayload[];
+        hasMore: boolean;
+        oldestTimestamp: number | null;
+      };
+
+      // Page is empty (the cap was consumed entirely by hidden rows) but the
+      // client must still be told to keep paginating and given a cursor.
+      expect(latest.messages).toHaveLength(0);
+      expect(latest.hasMore).toBe(true);
+      expect(latest.oldestTimestamp).not.toBeNull();
+
+      // Resuming from the surfaced cursor drains the remaining hidden rows and
+      // surfaces the visible ones below the cap.
+      const older = handleListMessages({
+        queryParams: {
+          conversationId: conv.id,
+          beforeTimestamp: String(latest.oldestTimestamp),
+          limit: "2",
+        },
+      }) as { messages: MessagePayload[]; hasMore: boolean };
+
+      expect(older.messages.map((m) => m.content)).toEqual([
+        "visible 0",
+        "visible 1",
+      ]);
+      expect(older.hasMore).toBe(false);
+    } finally {
+      _setPaginationScanCapForTesting(undefined);
+    }
+  });
+
   test("pagination drains DB when every row in a page is hidden", async () => {
     const conv = createConversation();
     // 5 hidden rows then 2 visible older rows. With limit=2, the naive

package/src/__tests__/llm-context-normalization.test.ts

@@ -1732,6 +1732,48 @@ describe("normalizeLlmContextPayloads", () => {
     ]);
   });
 
+  test("counts Codex Responses native web_search request tools", () => {
+    const normalized = normalizeLlmContextPayloads({
+      createdAt: 1_742_400_000_032,
+      requestPayload: {
+        model: "gpt-5.4",
+        instructions: "Search the web when needed.",
+        input: [
+          {
+            role: "user",
+            content: [{ type: "input_text", text: "What is the weather?" }],
+            type: "message",
+          },
+        ],
+        tools: [{ type: "web_search", external_web_access: false }],
+      },
+      responsePayload: {
+        model: "gpt-5.4",
+        output: [
+          {
+            type: "message",
+            role: "assistant",
+            content: [
+              { type: "output_text", text: "It is sunny in Boston today." },
+            ],
+          },
+        ],
+        usage: { input_tokens: 30, output_tokens: 15 },
+        status: "completed",
+      },
+    });
+
+    expect(normalized.summary?.requestToolCount).toBe(1);
+    expect(normalized.requestSections).toContainEqual({
+      kind: "tool_definitions",
+      label: "Available tools",
+      data: {
+        tools: [{ type: "web_search", external_web_access: false }],
+      },
+      language: "json",
+    });
+  });
+
   test("normalizes Responses API response with only web_search_call (no message)", () => {
     const normalized = normalizeLlmContextPayloads({
       createdAt: 1_742_400_000_031,

package/src/__tests__/llm-resolver.test.ts

@@ -812,6 +812,299 @@ describe("resolveCallSiteConfig", () => {
   });
 });
 
+describe("mix profiles", () => {
+  // A mix that routes 80% to `a` (model-a) and 20% to `b` (model-b).
+  const mixLlm = LLMSchema.parse({
+    default: fullDefault,
+    profiles: {
+      a: { model: "model-a", effort: "low" },
+      b: { model: "model-b", effort: "high" },
+      ab: {
+        mix: [
+          { profile: "a", weight: 80 },
+          { profile: "b", weight: 20 },
+        ],
+      },
+    },
+    activeProfile: "ab",
+  });
+
+  test("same seed resolves to the same arm (stable across calls)", () => {
+    const first = resolveCallSiteConfig("mainAgent", mixLlm, {
+      selectionSeed: "conv-1",
+    });
+    const second = resolveCallSiteConfig("mainAgent", mixLlm, {
+      selectionSeed: "conv-1",
+    });
+    expect(first.model).toBe(second.model);
+    expect(["model-a", "model-b"]).toContain(first.model);
+    // The chosen arm's other fields flow through; the other arm's don't.
+    if (first.model === "model-a") expect(first.effort).toBe("low");
+    else expect(first.effort).toBe("high");
+  });
+
+  test("all dereference spots in a turn agree for the same seed", () => {
+    // mainAgent (mix layered as activeProfile) and a non-main call site
+    // resolving the same mix as activeProfile must pick the same arm when
+    // given the same conversation seed — guards the invariant that every
+    // resolver call within a conversation lands on one arm.
+    const main = resolveCallSiteConfig("mainAgent", mixLlm, {
+      selectionSeed: "conv-xyz",
+    });
+    const other = resolveCallSiteConfig("memoryExtraction", mixLlm, {
+      selectionSeed: "conv-xyz",
+    });
+    expect(other.model).toBe(main.model);
+  });
+
+  test("different seeds split across both arms by weight", () => {
+    let aCount = 0;
+    let bCount = 0;
+    for (let i = 0; i < 400; i++) {
+      const resolved = resolveCallSiteConfig("mainAgent", mixLlm, {
+        selectionSeed: `conv-${i}`,
+      });
+      if (resolved.model === "model-a") aCount++;
+      else if (resolved.model === "model-b") bCount++;
+    }
+    // Both arms must be reachable, and the 80/20 weighting must skew toward
+    // `a`. Wide band so the assertion locks weighting without coupling to the
+    // exact hash output (deterministic, so never flaky).
+    expect(aCount).toBeGreaterThan(bCount);
+    expect(bCount).toBeGreaterThan(0);
+    expect(aCount).toBeGreaterThan(240); // ~80% of 400 = 320
+    expect(aCount).toBeLessThan(390);
+  });
+
+  test("relative weights are normalized by their sum ([80,20] ≡ [4,1])", () => {
+    const llm2 = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        a: { model: "model-a" },
+        b: { model: "model-b" },
+        ab: {
+          mix: [
+            { profile: "a", weight: 4 },
+            { profile: "b", weight: 1 },
+          ],
+        },
+      },
+      activeProfile: "ab",
+    });
+    for (let i = 0; i < 200; i++) {
+      const seed = `conv-${i}`;
+      expect(
+        resolveCallSiteConfig("mainAgent", llm2, { selectionSeed: seed }).model,
+      ).toBe(
+        resolveCallSiteConfig("mainAgent", mixLlm, { selectionSeed: seed })
+          .model,
+      );
+    }
+  });
+
+  test("mix works as overrideProfile", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        a: { model: "model-a" },
+        b: { model: "model-b" },
+        ab: {
+          mix: [
+            { profile: "a", weight: 50 },
+            { profile: "b", weight: 50 },
+          ],
+        },
+      },
+    });
+    const resolved = resolveCallSiteConfig("mainAgent", llm, {
+      overrideProfile: "ab",
+      selectionSeed: "conv-1",
+    });
+    expect(["model-a", "model-b"]).toContain(resolved.model);
+  });
+
+  test("mix works as a call-site profile (non-mainAgent and mainAgent)", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        a: { model: "model-a" },
+        b: { model: "model-b" },
+        ab: {
+          mix: [
+            { profile: "a", weight: 50 },
+            { profile: "b", weight: 50 },
+          ],
+        },
+      },
+      callSites: {
+        memoryExtraction: { profile: "ab" },
+        mainAgent: { profile: "ab" },
+      },
+    });
+    expect(["model-a", "model-b"]).toContain(
+      resolveCallSiteConfig("memoryExtraction", llm, { selectionSeed: "c1" })
+        .model,
+    );
+    expect(["model-a", "model-b"]).toContain(
+      resolveCallSiteConfig("mainAgent", llm, { selectionSeed: "c1" }).model,
+    );
+  });
+
+  test("onMixSelected reports the mix name and the chosen arm matching the resolved model", () => {
+    const calls: Array<{ mixProfile: string; chosenProfile: string }> = [];
+    const resolved = resolveCallSiteConfig("mainAgent", mixLlm, {
+      selectionSeed: "conv-1",
+      onMixSelected: (info) => calls.push(info),
+    });
+    expect(calls).toHaveLength(1);
+    expect(calls[0].mixProfile).toBe("ab");
+    expect(["a", "b"]).toContain(calls[0].chosenProfile);
+    expect(resolved.model).toBe(
+      calls[0].chosenProfile === "a" ? "model-a" : "model-b",
+    );
+  });
+
+  test("no seed falls back to random selection without throwing (both arms reachable)", () => {
+    const seen = new Set<string>();
+    for (let i = 0; i < 200; i++) {
+      seen.add(resolveCallSiteConfig("mainAgent", mixLlm).model);
+    }
+    expect(seen.has("model-a")).toBe(true);
+    expect(seen.has("model-b")).toBe(true);
+  });
+});
+
+describe("mix validation (LLMSchema.superRefine)", () => {
+  const base = {
+    default: fullDefault,
+    profiles: {
+      a: { model: "model-a" },
+      b: { model: "model-b" },
+    },
+  };
+
+  test("valid mix parses cleanly", () => {
+    expect(() =>
+      LLMSchema.parse({
+        ...base,
+        profiles: {
+          ...base.profiles,
+          ab: {
+            mix: [
+              { profile: "a", weight: 80 },
+              { profile: "b", weight: 20 },
+            ],
+          },
+        },
+      }),
+    ).not.toThrow();
+  });
+
+  test("rejects a mix referencing an undefined profile", () => {
+    expect(() =>
+      LLMSchema.parse({
+        ...base,
+        profiles: {
+          ...base.profiles,
+          ab: {
+            mix: [
+              { profile: "a", weight: 1 },
+              { profile: "ghost", weight: 1 },
+            ],
+          },
+        },
+      }),
+    ).toThrow(/not defined in llm\.profiles/);
+  });
+
+  test("rejects a nested mix (arm references another mix)", () => {
+    expect(() =>
+      LLMSchema.parse({
+        ...base,
+        profiles: {
+          ...base.profiles,
+          ab: {
+            mix: [
+              { profile: "a", weight: 1 },
+              { profile: "b", weight: 1 },
+            ],
+          },
+          outer: {
+            mix: [
+              { profile: "ab", weight: 1 },
+              { profile: "a", weight: 1 },
+            ],
+          },
+        },
+      }),
+    ).toThrow(/cannot be nested/);
+  });
+
+  test("rejects a self-referencing mix", () => {
+    expect(() =>
+      LLMSchema.parse({
+        ...base,
+        profiles: {
+          ...base.profiles,
+          ab: {
+            mix: [
+              { profile: "ab", weight: 1 },
+              { profile: "a", weight: 1 },
+            ],
+          },
+        },
+      }),
+    ).toThrow(/cannot reference itself/);
+  });
+
+  test("rejects a mix that also sets a config field", () => {
+    expect(() =>
+      LLMSchema.parse({
+        ...base,
+        profiles: {
+          ...base.profiles,
+          ab: {
+            model: "model-c",
+            mix: [
+              { profile: "a", weight: 1 },
+              { profile: "b", weight: 1 },
+            ],
+          },
+        },
+      }),
+    ).toThrow(/cannot also set/);
+  });
+
+  test("rejects a mix with fewer than two arms", () => {
+    expect(() =>
+      LLMSchema.parse({
+        ...base,
+        profiles: {
+          ...base.profiles,
+          ab: { mix: [{ profile: "a", weight: 1 }] },
+        },
+      }),
+    ).toThrow();
+  });
+
+  test("rejects a non-positive arm weight", () => {
+    expect(() =>
+      LLMSchema.parse({
+        ...base,
+        profiles: {
+          ...base.profiles,
+          ab: {
+            mix: [
+              { profile: "a", weight: 0 },
+              { profile: "b", weight: 1 },
+            ],
+          },
+        },
+      }),
+    ).toThrow();
+  });
+});
+
 describe("resolveDefaultProfileKey", () => {
   test("mainAgent returns activeProfile when set and enabled", () => {
     const llm = LLMSchema.parse({
@@ -894,6 +1187,44 @@ describe("resolveDefaultProfileKey", () => {
       "custom-cost-optimized",
     );
   });
+
+  test("mainAgent returns the mix key (not an arm) when activeProfile is a mix", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        a: { model: "model-a" },
+        b: { model: "model-b" },
+        ab: {
+          mix: [
+            { profile: "a", weight: 1 },
+            { profile: "b", weight: 1 },
+          ],
+        },
+      },
+      activeProfile: "ab",
+    });
+    expect(resolveDefaultProfileKey("mainAgent", llm)).toBe("ab");
+  });
+
+  test("mainAgent falls back to catalog default when the mix activeProfile is disabled", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
+        a: { model: "model-a" },
+        b: { model: "model-b" },
+        ab: {
+          status: "disabled",
+          mix: [
+            { profile: "a", weight: 1 },
+            { profile: "b", weight: 1 },
+          ],
+        },
+      },
+      activeProfile: "ab",
+    });
+    expect(resolveDefaultProfileKey("mainAgent", llm)).toBe("balanced");
+  });
 });
 
 describe("memory v3 call sites resolve through the standard resolver", () => {

package/src/__tests__/llm-schema.test.ts

@@ -72,7 +72,7 @@ describe("LLMSchema", () => {
     const parsed = LLMSchema.parse({});
     expect(parsed.default).toEqual({
       provider: "anthropic",
-      model: "claude-opus-4-7",
+      model: "claude-opus-4-8",
       maxTokens: 64000,
       effort: "max",
       speed: "standard",