@vellumai/assistant 0.8.11 → 0.8.12-staging.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.11",
+  "version": "0.8.12-staging.2",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -50,7 +50,6 @@
     "@vellumai/skill-host-contracts": "file:../packages/skill-host-contracts",
     "@vellumai/slack-text": "file:../packages/slack-text",
     "@vellumai/twilio-client": "file:../packages/twilio-client",
-    "archiver": "7.0.1",
     "commander": "13.1.0",
     "croner": "10.0.1",
     "dotenv": "17.3.1",
@@ -97,7 +96,6 @@
   },
   "devDependencies": {
     "@microsoft/api-extractor": "7.58.8",
-    "@types/archiver": "7.0.0",
     "@types/bun": "1.3.10",
     "@types/node": "25.5.0",
     "@types/semver": "7.5.8",

package/src/__tests__/adaptive-thinking-repair.test.ts

@@ -0,0 +1,185 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { repairAdaptiveThinkingOnManagedProfiles } from "../workspace/adaptive-thinking-repair.js";
+import { enableAdaptiveThinkingManagedProfilesMigration } from "../workspace/migrations/097-enable-adaptive-thinking-managed-profiles.js";
+
+const ADAPTIVE = { enabled: true, streamThinking: true };
+
+let workspaceDir: string;
+
+beforeEach(() => {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-adaptive-thinking-repair-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function profile(name: string): Record<string, unknown> {
+  const config = readConfig();
+  const llm = config.llm as Record<string, unknown>;
+  const profiles = llm.profiles as Record<string, unknown>;
+  return profiles[name] as Record<string, unknown>;
+}
+
+// The startup repair and migration 097 keep frozen copies of the same logic
+// (migration modules must stay self-contained). Run every scenario against
+// both so the copies can't drift.
+const implementations: Array<[string, (dir: string) => void]> = [
+  ["startup repair", repairAdaptiveThinkingOnManagedProfiles],
+  [
+    "migration 097",
+    (dir) => enableAdaptiveThinkingManagedProfilesMigration.run(dir),
+  ],
+];
+
+describe.each(implementations)("%s", (_label, run) => {
+  test("patches managed Anthropic profiles missing thinking", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-sonnet-4-6" },
+        profiles: {
+          balanced: { source: "managed", provider: "anthropic" },
+          "quality-optimized": {
+            source: "managed",
+            provider: "anthropic",
+            thinking: { enabled: false },
+          },
+        },
+      },
+    });
+
+    run(workspaceDir);
+
+    expect(profile("balanced").thinking).toEqual(ADAPTIVE);
+    expect(profile("quality-optimized").thinking).toEqual(ADAPTIVE);
+  });
+
+  test("skips source-less empty shells when llm.default.provider is non-Anthropic", () => {
+    // Migration 052 seeds empty {} shells (no source, no provider) on legacy
+    // non-Anthropic workspaces. They inherit the non-Anthropic provider from
+    // llm.default and must stay off the Anthropic-specific repair.
+    writeConfig({
+      llm: {
+        default: { provider: "gemini", model: "gemini-2.5-pro" },
+        profiles: {
+          balanced: {},
+          "quality-optimized": {},
+        },
+      },
+    });
+
+    run(workspaceDir);
+
+    expect(profile("balanced")).toEqual({});
+    expect(profile("quality-optimized")).toEqual({});
+  });
+
+  test("treats absent llm.default.provider as Anthropic for source-less profiles", () => {
+    writeConfig({
+      llm: {
+        default: { model: "claude-sonnet-4-6" },
+        profiles: {
+          balanced: {},
+        },
+      },
+    });
+
+    run(workspaceDir);
+
+    expect(profile("balanced").thinking).toEqual(ADAPTIVE);
+  });
+
+  test("explicit Anthropic provider on the profile wins over a non-Anthropic default", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "gemini" },
+        profiles: {
+          balanced: { provider: "anthropic" },
+        },
+      },
+    });
+
+    run(workspaceDir);
+
+    expect(profile("balanced").thinking).toEqual(ADAPTIVE);
+  });
+
+  test("skips profiles with an explicit non-Anthropic provider", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        profiles: {
+          balanced: { provider: "gemini" },
+        },
+      },
+    });
+
+    run(workspaceDir);
+
+    expect(profile("balanced").thinking).toBeUndefined();
+  });
+
+  test("skips source: user profiles", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        profiles: {
+          balanced: { source: "user", provider: "anthropic" },
+        },
+      },
+    });
+
+    run(workspaceDir);
+
+    expect(profile("balanced").thinking).toBeUndefined();
+  });
+
+  test("is idempotent when thinking is already enabled", () => {
+    const config = {
+      llm: {
+        default: { provider: "anthropic" },
+        profiles: {
+          balanced: {
+            source: "managed",
+            thinking: { enabled: true, streamThinking: false },
+          },
+        },
+      },
+    };
+    writeConfig(config);
+
+    run(workspaceDir);
+
+    expect(profile("balanced").thinking).toEqual({
+      enabled: true,
+      streamThinking: false,
+    });
+  });
+});

package/src/__tests__/agent-loop-compaction-events.test.ts

@@ -4,8 +4,9 @@
  * The compaction pipeline between `context_compacting` (start) and
  * `compaction_completed` (end) is plugin-owned, so consumers reconstruct a
  * compaction attempt purely from the pair — correlated by `compactionId`.
- * These tests pin the pairing contract: shared id, trigger, timestamps, and
- * pre-compaction state on the start event.
+ * These tests pin the pairing contract: shared id, trigger, timestamps,
+ * pre-compaction state on the start event, and the unnested
+ * `ContextWindowResult` fields on the end event.
  */
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
@@ -185,11 +186,11 @@ describe("AgentLoop compaction start/end event pair", () => {
     expect(end!.finishedAt).toBeGreaterThanOrEqual(end!.startedAt);
     expect(end!.finishedAt).toBeLessThanOrEqual(after);
 
-    // Start carries the pre-compaction history; end carries the result and
-    // the stripped history the summary was built from.
+    // Start carries the pre-compaction history; end carries the
+    // ContextWindowResult fields unnested on the event.
     expect(start!.messages.length).toBeGreaterThan(0);
-    expect(end!.result.compacted).toBe(true);
-    expect(end!.messages.length).toBeGreaterThan(0);
+    expect(end!.compacted).toBe(true);
+    expect(end!.exhausted).toBe(false);
 
     // Start precedes end in the event stream.
     expect(events.indexOf(start!)).toBeLessThan(events.indexOf(end!));

package/src/__tests__/anthropic-provider.test.ts

@@ -106,6 +106,7 @@ mock.module("@anthropic-ai/sdk", () => ({
 }));
 
 // Import after mocking
+import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../prompts/cache-boundary.js";
 import { AnthropicProvider } from "../providers/anthropic/client.js";
 import {
   isPlaceholderSentinelText,
@@ -308,6 +309,91 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     });
   });
 
+  test("splits a boundary-carrying system prompt into two cached blocks and drops the tool breakpoint", async () => {
+    /**
+     * Tests that the SYSTEM_PROMPT_CACHE_BOUNDARY marker yields two
+     * independently cached system blocks, and that the explicit
+     * last-tool breakpoint is suppressed (the first system breakpoint
+     * already covers tools) so the total stays within Anthropic's
+     * 4-breakpoint budget.
+     */
+    // GIVEN a system prompt carrying a cache boundary, plus tools and a
+    // tool-use loop (so turn-start and tail breakpoints also apply)
+    const prompt = `stable sections${SYSTEM_PROMPT_CACHE_BOUNDARY}volatile sections`;
+    const messages: Message[] = [
+      userMsg("Do something"),
+      toolUseMsg("tu_1", "bash"),
+      toolResultMsg("tu_1", "output"),
+    ];
+
+    // WHEN the message is sent
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: prompt,
+    });
+
+    // THEN the system prompt is split into two blocks, each 1h-cached
+    const system = lastStreamParams!.system as Array<{
+      type: string;
+      text: string;
+      cache_control?: { type: string; ttl?: string };
+    }>;
+    expect(system).toHaveLength(2);
+    expect(system[0].text).toBe("stable sections");
+    expect(system[1].text).toBe("volatile sections");
+    expect(system[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    expect(system[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+
+    // AND no tool carries a breakpoint (system block 1 covers them)
+    const tools = lastStreamParams!.tools as Array<{
+      cache_control?: { type: string; ttl?: string };
+    }>;
+    for (const tool of tools) {
+      expect(tool.cache_control).toBeUndefined();
+    }
+
+    // AND the turn-start and tail message breakpoints are unchanged,
+    // keeping the total at the 4-breakpoint cap
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+    const turnStart = sent[0];
+    expect(
+      turnStart.content[turnStart.content.length - 1].cache_control,
+    ).toEqual({ type: "ephemeral", ttl: "1h" });
+    const lastMsg = sent[sent.length - 1];
+    expect(lastMsg.content[lastMsg.content.length - 1].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "5m",
+    });
+  });
+
+  test("keeps the last-tool breakpoint when the system prompt has no boundary", async () => {
+    /**
+     * Tests that a boundary-free system prompt preserves the explicit
+     * tool breakpoint (single system block leaves budget for it).
+     */
+    // GIVEN a system prompt without a cache boundary and tools
+    // WHEN the message is sent
+    await provider.sendMessage([userMsg("Hi")], {
+      tools: sampleTools,
+      systemPrompt: "You are helpful.",
+    });
+
+    // THEN the last tool keeps its breakpoint
+    const tools = lastStreamParams!.tools as Array<{
+      cache_control?: { type: string; ttl?: string };
+    }>;
+    expect(tools[tools.length - 1].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
+  });
+
   // -----------------------------------------------------------------------
   // Tool cache control
   // -----------------------------------------------------------------------
@@ -389,6 +475,49 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     ).not.toContain("extended-cache-ttl-2025-04-11");
   });
 
+  test("disableCache sends no cache_control anywhere and strips caller-stamped block markers", async () => {
+    // A one-shot call site that opted out of prompt caching: no breakpoint
+    // on system, tools, turn-start, or tail — and a caller-stamped block
+    // marker is removed rather than forwarded.
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          cachedPrefixBlock("stable pages block"),
+          { type: "text", text: "Do something" },
+        ],
+      },
+      toolUseMsg("tu_1", "bash"),
+      toolResultMsg("tu_1", "output"),
+    ];
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: "You are a helpful assistant.",
+      config: { disableCache: true },
+    });
+
+    const system = lastStreamParams!.system as Array<{
+      cache_control?: unknown;
+    }>;
+    expect(system[0].cache_control).toBeUndefined();
+
+    const tools = lastStreamParams!.tools as Array<{
+      cache_control?: unknown;
+    }>;
+    for (const tool of tools) {
+      expect(tool.cache_control).toBeUndefined();
+    }
+
+    const sent = lastStreamParams!.messages as Array<{
+      content: Array<{ cache_control?: unknown }>;
+    }>;
+    for (const message of sent) {
+      for (const block of message.content) {
+        expect(block.cache_control).toBeUndefined();
+      }
+    }
+  });
+
   test("v3-shape call (system + tools + cached prefix block) stays within the 4-breakpoint cap", async () => {
     // Mirrors a v3 L2 selector call: a system prompt, a forced tool, and a user
     // message whose stable <pages> block carries a cache_control breakpoint

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -52,7 +52,7 @@ mock.module("../config/loader.js", () => ({
   getNestedValue: () => undefined,
   setNestedValue: () => {},
   API_KEY_PROVIDERS: [],
-  _appendQuarantineBulletin: () => {},
+  _writeQuarantineNotice: () => {},
   invalidateConfigCache: () => {},
 }));
 
@@ -158,6 +158,9 @@ mock.module("../memory/conversation-crud.js", () => ({
 
 mock.module("../memory/conversation-title-service.js", () => ({
   GENERATING_TITLE: "Generating title...",
+  AUTO_TITLE_DETERMINISTIC: 2,
+  deriveDeterministicTitle: (context: { systemHint?: string }) =>
+    context.systemHint ?? "Untitled Conversation",
   isReplaceableTitle: () => true,
   queueGenerateConversationTitle: () => {},
   queueRegenerateConversationTitle: () => {},

package/src/__tests__/btw-routes.test.ts

@@ -8,7 +8,7 @@
 
 import { rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Mocks — must be defined before importing the module under test
@@ -22,7 +22,11 @@ mock.module("../util/logger.js", () => ({
 }));
 
 const mockGetConversationByKey = mock(
-  (_key: string): { conversationId: string } | null => ({
+  (
+    _key: string,
+  ): {
+    conversationId: string;
+  } | null => ({
     conversationId: "conv-test-123",
   }),
 );
@@ -80,13 +84,6 @@ mock.module("../runtime/routes/identity-intro-cache.js", () => ({
   setCachedIntro: () => {},
 }));
 
-const assistantFeatureFlags: Record<string, boolean> = {};
-
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string) =>
-    assistantFeatureFlags[key] ?? false,
-}));
-
 // Mock getOrCreateConversation from conversation-store so the handler
 // never touches DaemonServer.
 const mockGetOrCreateConversation = mock(async (_id: string) =>
@@ -185,12 +182,6 @@ function makeMockSession(
 const route = ROUTES.find((r) => r.endpoint === "btw" && r.method === "POST");
 if (!route) throw new Error("btw route not found in ROUTES");
 
-beforeEach(() => {
-  for (const key of Object.keys(assistantFeatureFlags)) {
-    delete assistantFeatureFlags[key];
-  }
-});
-
 async function callHandler(
   body: Record<string, unknown>,
 ): Promise<{ result: unknown; error?: unknown }> {
@@ -338,25 +329,7 @@ describe("POST /v1/btw", () => {
     expect(options!.config!.modelIntent).toBeUndefined();
   });
 
-  test("greeting requests return static fallback when the dynamic greetings flag is off", async () => {
-    mockGetOrCreateConversation.mockClear();
-
-    const { result } = await callHandler({
-      conversationKey: "greeting",
-      content: "Generate a greeting",
-    });
-    const text = await readStream(result as ReadableStream<Uint8Array>);
-
-    expect(text).toContain(
-      `event: btw_text_delta\ndata: {"text":"What are we working on?"}`,
-    );
-    expect(text).toContain("event: btw_complete\ndata: {}");
-    expect(mockGetOrCreateConversation).not.toHaveBeenCalled();
-  });
-
-  test("greeting requests pass callSite: 'emptyStateGreeting' when the dynamic greetings flag is on", async () => {
-    assistantFeatureFlags["empty-state-dynamic-greetings"] = true;
-
+  test("greeting requests pass callSite: 'emptyStateGreeting'", async () => {
     const provider = makeMockProvider();
     const session = makeMockSession(provider);
     mockGetOrCreateConversation.mockImplementationOnce(async () => session);

package/src/__tests__/checker.test.ts

@@ -428,21 +428,15 @@ describe("Permission Checker", () => {
       expect(result.decision).toBe("allow");
     });
 
-    test("file_read of workspace UPDATES.md is auto-allowed", async () => {
-      const updatesPath = join(checkerTestDir, "UPDATES.md");
-      const result = await check("file_read", { path: updatesPath }, "/tmp");
-      expect(result.decision).toBe("allow");
-    });
-
-    test("file_write of workspace UPDATES.md is auto-allowed", async () => {
-      const updatesPath = join(checkerTestDir, "UPDATES.md");
-      const result = await check("file_write", { path: updatesPath }, "/tmp");
+    test("file_read of workspace BOOTSTRAP.md is auto-allowed", async () => {
+      const bootstrapPath = join(checkerTestDir, "BOOTSTRAP.md");
+      const result = await check("file_read", { path: bootstrapPath }, "/tmp");
       expect(result.decision).toBe("allow");
     });
 
-    test("file_edit of workspace UPDATES.md is auto-allowed", async () => {
-      const updatesPath = join(checkerTestDir, "UPDATES.md");
-      const result = await check("file_edit", { path: updatesPath }, "/tmp");
+    test("file_edit of workspace BOOTSTRAP.md is auto-allowed", async () => {
+      const bootstrapPath = join(checkerTestDir, "BOOTSTRAP.md");
+      const result = await check("file_edit", { path: bootstrapPath }, "/tmp");
       expect(result.decision).toBe("allow");
     });
 

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

@@ -82,6 +82,7 @@ import { migrateProviderConnectionStatusLabel } from "../memory/migrations/244-p
 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 { getConfigQuarantineNoticePath } from "../util/platform.js";
 import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
 
 // ---------------------------------------------------------------------------
@@ -325,8 +326,9 @@ describe("loadConfig startup behavior", () => {
         }
       }
     }
-    const updatesPath = join(WORKSPACE_DIR, "UPDATES.md");
-    if (existsSync(updatesPath)) rmSync(updatesPath, { force: true });
+    // Clear any leftover config-quarantine notice sentinel from prior runs.
+    const noticePath = getConfigQuarantineNoticePath();
+    if (existsSync(noticePath)) rmSync(noticePath, { force: true });
     ensureTestDir();
     setStorePathForTesting(join(WORKSPACE_DIR, "keys.enc"));
     delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;