@vellumai/assistant 0.8.12 → 0.9.0-staging.2

package/src/__tests__/tool-approval-seed-content-blocks.test.ts

@@ -0,0 +1,209 @@
+import { describe, expect, test } from "bun:test";
+
+import { buildToolApprovalSeedContentBlocks } from "../notifications/tool-approval-copy.js";
+
+describe("buildToolApprovalSeedContentBlocks", () => {
+  const toolApprovalPayload: Record<string, unknown> = {
+    requestId: "req-tool-456",
+    requestCode: "XYZ789",
+    requestKind: "tool_approval",
+    toolName: "bash",
+    questionText:
+      'Bob wants to use "bash": mkdir -p scratch && assistant credentials reveal --service slack',
+    sourceChannel: "slack",
+    requesterIdentifier: "Bob",
+  };
+
+  const toolGrantPayload: Record<string, unknown> = {
+    requestId: "req-grant-789",
+    requestCode: "GHI012",
+    requestKind: "tool_grant_request",
+    toolName: "web_search",
+    questionText: 'Alice wants to use "web_search": search for latest news',
+    sourceChannel: "telegram",
+    requesterIdentifier: "Alice",
+  };
+
+  const voiceToolApprovalPayload: Record<string, unknown> = {
+    requestId: "req-voice-101",
+    requestCode: "VOICE1",
+    requestKind: "pending_question",
+    toolName: "bash",
+    questionText: 'Bob wants to use "bash": echo hello',
+    sourceChannel: "phone",
+    requesterIdentifier: "Bob",
+  };
+
+  test("returns null for non-tool-approval request kinds", () => {
+    expect(
+      buildToolApprovalSeedContentBlocks({ requestKind: "pending_question" }),
+    ).toBeNull();
+    expect(
+      buildToolApprovalSeedContentBlocks({ requestKind: "access_request" }),
+    ).toBeNull();
+    expect(buildToolApprovalSeedContentBlocks({})).toBeNull();
+  });
+
+  test("produces blocks for pending_question with toolName (voice tool approval)", () => {
+    const blocks = buildToolApprovalSeedContentBlocks(
+      voiceToolApprovalPayload,
+    )!;
+    expect(blocks).toHaveLength(2);
+    expect((blocks[0] as Record<string, unknown>).type).toBe("ui_surface");
+    const surface = blocks[0] as Record<string, unknown>;
+    expect(surface.surfaceType).toBe("card");
+    expect(surface.surfaceId).toBe("tool-approval-req-voice-101");
+    const data = surface.data as Record<string, unknown>;
+    expect(data.subtitle).toBe("Requesting approval to run this tool");
+    const metadata = data.metadata as Array<{ label: string; value: string }>;
+    expect(metadata).toContainEqual({ label: "Tool", value: "bash" });
+    expect(metadata).toContainEqual({ label: "Source", value: "phone" });
+  });
+
+  test("returns null for pending_question without toolName", () => {
+    const payload = { ...voiceToolApprovalPayload, toolName: undefined };
+    expect(buildToolApprovalSeedContentBlocks(payload)).toBeNull();
+  });
+
+  test("produces a ui_surface block and a text fallback block for tool_approval", () => {
+    const blocks = buildToolApprovalSeedContentBlocks(toolApprovalPayload)!;
+    expect(blocks).toHaveLength(2);
+    expect((blocks[0] as Record<string, unknown>).type).toBe("ui_surface");
+    expect((blocks[1] as Record<string, unknown>).type).toBe("text");
+  });
+
+  test("produces a ui_surface block and a text fallback block for tool_grant_request", () => {
+    const blocks = buildToolApprovalSeedContentBlocks(toolGrantPayload)!;
+    expect(blocks).toHaveLength(2);
+    expect((blocks[0] as Record<string, unknown>).type).toBe("ui_surface");
+    expect((blocks[1] as Record<string, unknown>).type).toBe("text");
+  });
+
+  test("card surface has correct surfaceType and surfaceId for tool_approval", () => {
+    const blocks = buildToolApprovalSeedContentBlocks(toolApprovalPayload)!;
+    const surface = blocks[0] as Record<string, unknown>;
+    expect(surface.surfaceType).toBe("card");
+    expect(surface.surfaceId).toBe("tool-approval-req-tool-456");
+    expect(surface.title).toBe("Tool Approval");
+  });
+
+  test("card surface has correct title for tool_grant_request", () => {
+    const blocks = buildToolApprovalSeedContentBlocks(toolGrantPayload)!;
+    const surface = blocks[0] as Record<string, unknown>;
+    expect(surface.title).toBe("Tool Grant Request");
+  });
+
+  test("card data uses requesterIdentifier as title", () => {
+    const blocks = buildToolApprovalSeedContentBlocks(toolApprovalPayload)!;
+    const data = (blocks[0] as Record<string, unknown>).data as Record<
+      string,
+      unknown
+    >;
+    expect(data.title).toBe("Bob");
+  });
+
+  test("card data falls back to 'Someone' when no requesterIdentifier", () => {
+    const payload = { ...toolApprovalPayload, requesterIdentifier: undefined };
+    const blocks = buildToolApprovalSeedContentBlocks(payload)!;
+    const data = (blocks[0] as Record<string, unknown>).data as Record<
+      string,
+      unknown
+    >;
+    expect(data.title).toBe("Someone");
+  });
+
+  test("card subtitle differs for tool_approval vs tool_grant_request", () => {
+    const approvalBlocks =
+      buildToolApprovalSeedContentBlocks(toolApprovalPayload)!;
+    const grantBlocks = buildToolApprovalSeedContentBlocks(toolGrantPayload)!;
+    const approvalData = (approvalBlocks[0] as Record<string, unknown>)
+      .data as Record<string, unknown>;
+    const grantData = (grantBlocks[0] as Record<string, unknown>)
+      .data as Record<string, unknown>;
+    expect(approvalData.subtitle).toBe("Requesting approval to run this tool");
+    expect(grantData.subtitle).toBe("Requesting permission to use this tool");
+  });
+
+  test("includes tool name and source channel in metadata", () => {
+    const blocks = buildToolApprovalSeedContentBlocks(toolApprovalPayload)!;
+    const data = (blocks[0] as Record<string, unknown>).data as Record<
+      string,
+      unknown
+    >;
+    const metadata = data.metadata as Array<{ label: string; value: string }>;
+    expect(metadata).toContainEqual({ label: "Tool", value: "bash" });
+    expect(metadata).toContainEqual({ label: "Source", value: "slack" });
+  });
+
+  test("body includes questionText as blockquote", () => {
+    const blocks = buildToolApprovalSeedContentBlocks(toolApprovalPayload)!;
+    const data = (blocks[0] as Record<string, unknown>).data as Record<
+      string,
+      unknown
+    >;
+    expect(data.body).toContain("Bob wants to use");
+    expect(data.body).toContain("bash");
+  });
+
+  test("body shows fallback when no questionText", () => {
+    const payload = { ...toolApprovalPayload, questionText: undefined };
+    const blocks = buildToolApprovalSeedContentBlocks(payload)!;
+    const data = (blocks[0] as Record<string, unknown>).data as Record<
+      string,
+      unknown
+    >;
+    expect(data.body).toBe("No additional context available.");
+  });
+
+  test("surface block includes approve/reject actions when requestId present", () => {
+    const blocks = buildToolApprovalSeedContentBlocks(toolApprovalPayload)!;
+    const surface = blocks[0] as Record<string, unknown>;
+    const actions = surface.actions as Array<{
+      id: string;
+      label: string;
+      style: string;
+    }>;
+    expect(actions).toHaveLength(2);
+    expect(actions[0]).toEqual({
+      id: "apr:req-tool-456:approve_once",
+      label: "Approve",
+      style: "primary",
+    });
+    expect(actions[1]).toEqual({
+      id: "apr:req-tool-456:reject",
+      label: "Reject",
+      style: "destructive",
+    });
+  });
+
+  test("surface block omits actions when requestId is missing", () => {
+    const payload = { ...toolApprovalPayload, requestId: undefined };
+    const blocks = buildToolApprovalSeedContentBlocks(payload)!;
+    const surface = blocks[0] as Record<string, unknown>;
+    expect(surface.actions).toBeUndefined();
+  });
+
+  test("text fallback block contains questionText and request-code instruction", () => {
+    const blocks = buildToolApprovalSeedContentBlocks(toolApprovalPayload)!;
+    const textBlock = blocks[1] as Record<string, unknown>;
+    expect(textBlock.type).toBe("text");
+    expect(textBlock.text).toContain("Bob wants to use");
+    expect(textBlock.text).toContain("XYZ789");
+    expect(textBlock.text).toContain("approve");
+  });
+
+  test("text fallback block omits request-code instruction when no requestCode", () => {
+    const payload = { ...toolApprovalPayload, requestCode: undefined };
+    const blocks = buildToolApprovalSeedContentBlocks(payload)!;
+    const textBlock = blocks[1] as Record<string, unknown>;
+    expect(textBlock.text).toContain("Bob wants to use");
+    expect(textBlock.text).not.toContain("XYZ789");
+  });
+
+  test("text fallback block uses generic text when no questionText", () => {
+    const payload = { ...toolApprovalPayload, questionText: undefined };
+    const blocks = buildToolApprovalSeedContentBlocks(payload)!;
+    const textBlock = blocks[1] as Record<string, unknown>;
+    expect(textBlock.text).toContain("requesting approval to use bash");
+  });
+});

package/src/__tests__/tool-result-spool.test.ts

@@ -110,12 +110,13 @@ describe("spoolAndStubOversizedToolResults", () => {
     expect(messages).toBe(history);
   });
 
-  test("skips below-threshold, error, exempt, file_read, marked, and ax-tree results", () => {
+  test("skips below-threshold, error, exempt, file_read, host_file_read, marked, and ax-tree results", () => {
     const blocks = [
       makeToolResult(SHORT, "tu_short"),
       makeToolResult(LONG, "tu_err", true),
       makeToolResult(LONG, "tu_skill"),
       makeToolResult(LONG, "tu_read"),
+      makeToolResult(LONG, "tu_host_read"),
       makeToolResult(`${LONG}${TRUNCATION_MARKER}`, "tu_marked"),
       makeToolResult(`<ax-tree>${LONG}</ax-tree>`, "tu_ax"),
       { type: "text" as const, text: LONG },
@@ -127,6 +128,7 @@ describe("spoolAndStubOversizedToolResults", () => {
       toolNameById: (id) => {
         if (id === "tu_skill") return "skill_load";
         if (id === "tu_read") return "file_read";
+        if (id === "tu_host_read") return "host_file_read";
         return undefined;
       },
     });

package/src/__tests__/workspace-migration-102-preserve-heartbeat-enabled-for-existing-workspaces.test.ts

@@ -0,0 +1,181 @@
+/**
+ * Tests for workspace migration `102-preserve-heartbeat-enabled-for-existing-workspaces`.
+ *
+ * The schema default for `heartbeat.enabled` flipped from true to false so
+ * heartbeats are opt-in for new users. The migration persists an explicit
+ * `enabled: true` for upgrading workspaces that never wrote the key (they
+ * relied on the old default-on behavior), creating `config.json` when it
+ * does not exist. It must skip fresh workspaces, leave explicit user values
+ * untouched, and be idempotent.
+ */
+
+import {
+  existsSync,
+  mkdtempSync,
+  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 { HeartbeatConfigSchema } from "../config/schemas/heartbeat.js";
+import { preserveHeartbeatEnabledForExistingWorkspacesMigration } from "../workspace/migrations/102-preserve-heartbeat-enabled-for-existing-workspaces.js";
+import type { MigrationRunContext } from "../workspace/migrations/types.js";
+
+const NEW_WORKSPACE_CTX: MigrationRunContext = { isNewWorkspace: true };
+const UPGRADE_CTX: MigrationRunContext = { isNewWorkspace: false };
+
+let workspaceDir: string;
+let configPath: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-102-test-"));
+  configPath = join(workspaceDir, "config.json");
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(configPath, "utf-8"));
+}
+
+describe("102-preserve-heartbeat-enabled-for-existing-workspaces migration", () => {
+  test("has correct id and description", () => {
+    expect(preserveHeartbeatEnabledForExistingWorkspacesMigration.id).toBe(
+      "102-preserve-heartbeat-enabled-for-existing-workspaces",
+    );
+    expect(
+      preserveHeartbeatEnabledForExistingWorkspacesMigration.description,
+    ).toContain("heartbeat.enabled");
+  });
+
+  test("schema default is disabled (the flip this migration compensates for)", () => {
+    expect(HeartbeatConfigSchema.parse({}).enabled).toBe(false);
+  });
+
+  test("skips fresh workspaces so new users get the opt-in default", () => {
+    preserveHeartbeatEnabledForExistingWorkspacesMigration.run(
+      workspaceDir,
+      NEW_WORKSPACE_CTX,
+    );
+
+    expect(existsSync(configPath)).toBe(false);
+  });
+
+  test("creates config.json with enabled=true when an existing workspace has none", () => {
+    preserveHeartbeatEnabledForExistingWorkspacesMigration.run(
+      workspaceDir,
+      UPGRADE_CTX,
+    );
+
+    expect(readConfig()).toEqual({ heartbeat: { enabled: true } });
+  });
+
+  test("adds heartbeat block to an existing config without one", () => {
+    writeFileSync(configPath, JSON.stringify({ name: "Assistant" }), "utf-8");
+
+    preserveHeartbeatEnabledForExistingWorkspacesMigration.run(
+      workspaceDir,
+      UPGRADE_CTX,
+    );
+
+    expect(readConfig()).toEqual({
+      name: "Assistant",
+      heartbeat: { enabled: true },
+    });
+  });
+
+  test("adds enabled=true to a heartbeat block without the key, preserving siblings", () => {
+    writeFileSync(
+      configPath,
+      JSON.stringify({ heartbeat: { intervalMs: 1800000 } }),
+      "utf-8",
+    );
+
+    preserveHeartbeatEnabledForExistingWorkspacesMigration.run(
+      workspaceDir,
+      UPGRADE_CTX,
+    );
+
+    expect(readConfig()).toEqual({
+      heartbeat: { intervalMs: 1800000, enabled: true },
+    });
+  });
+
+  test.each([[true], [false]])(
+    "leaves an explicit enabled=%p untouched",
+    (enabled) => {
+      const original = JSON.stringify({ heartbeat: { enabled } });
+      writeFileSync(configPath, original, "utf-8");
+
+      preserveHeartbeatEnabledForExistingWorkspacesMigration.run(
+        workspaceDir,
+        UPGRADE_CTX,
+      );
+
+      expect(readFileSync(configPath, "utf-8")).toBe(original);
+    },
+  );
+
+  test("treats a missing context as an existing workspace", () => {
+    preserveHeartbeatEnabledForExistingWorkspacesMigration.run(workspaceDir);
+
+    expect(readConfig()).toEqual({ heartbeat: { enabled: true } });
+  });
+
+  test("leaves malformed config.json untouched", () => {
+    writeFileSync(configPath, "{ not json", "utf-8");
+
+    preserveHeartbeatEnabledForExistingWorkspacesMigration.run(
+      workspaceDir,
+      UPGRADE_CTX,
+    );
+
+    expect(readFileSync(configPath, "utf-8")).toBe("{ not json");
+  });
+
+  test("leaves a non-object heartbeat value untouched", () => {
+    const original = JSON.stringify({ heartbeat: "off" });
+    writeFileSync(configPath, original, "utf-8");
+
+    preserveHeartbeatEnabledForExistingWorkspacesMigration.run(
+      workspaceDir,
+      UPGRADE_CTX,
+    );
+
+    expect(readFileSync(configPath, "utf-8")).toBe(original);
+  });
+
+  test("is idempotent", () => {
+    preserveHeartbeatEnabledForExistingWorkspacesMigration.run(
+      workspaceDir,
+      UPGRADE_CTX,
+    );
+    const afterFirst = readFileSync(configPath, "utf-8");
+
+    preserveHeartbeatEnabledForExistingWorkspacesMigration.run(
+      workspaceDir,
+      UPGRADE_CTX,
+    );
+
+    expect(readFileSync(configPath, "utf-8")).toBe(afterFirst);
+  });
+
+  test("down is a no-op", () => {
+    preserveHeartbeatEnabledForExistingWorkspacesMigration.run(
+      workspaceDir,
+      UPGRADE_CTX,
+    );
+    const before = readFileSync(configPath, "utf-8");
+
+    preserveHeartbeatEnabledForExistingWorkspacesMigration.down(workspaceDir);
+
+    expect(readFileSync(configPath, "utf-8")).toBe(before);
+  });
+});

package/src/__tests__/workspace-migration-103-upgrade-quality-profile-to-opus-4-8.test.ts

@@ -0,0 +1,174 @@
+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 { upgradeQualityProfileToOpus48Migration } from "../workspace/migrations/103-upgrade-quality-profile-to-opus-4-8.js";
+
+let workspaceDir: string;
+
+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 readProfiles(): Record<string, Record<string, unknown>> {
+  const llm = readConfig().llm as Record<string, unknown>;
+  return llm.profiles as Record<string, Record<string, unknown>>;
+}
+
+beforeEach(() => {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-103-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("103-upgrade-quality-profile-to-opus-4-8 migration", () => {
+  test("no-op when config.json does not exist", () => {
+    upgradeQualityProfileToOpus48Migration.run(workspaceDir);
+    expect(existsSync(join(workspaceDir, "config.json"))).toBe(false);
+  });
+
+  test("no-op when config has no llm.profiles", () => {
+    const original = { llm: { default: { provider: "anthropic" } } };
+    writeConfig(original);
+    upgradeQualityProfileToOpus48Migration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("gracefully handles invalid JSON", () => {
+    writeFileSync(join(workspaceDir, "config.json"), "not-valid-json");
+    upgradeQualityProfileToOpus48Migration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      "not-valid-json",
+    );
+  });
+
+  test("upgrades quality-optimized from claude-fable-5", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            provider: "anthropic",
+            model: "claude-fable-5",
+            label: "Quality",
+          },
+        },
+      },
+    });
+    upgradeQualityProfileToOpus48Migration.run(workspaceDir);
+    const profile = readProfiles()["quality-optimized"]!;
+    expect(profile.model).toBe("claude-opus-4-8");
+    expect(profile.label).toBe("Quality");
+  });
+
+  test("upgrades the managed profile but not the user-owned custom copy", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            provider: "anthropic",
+            model: "claude-fable-5",
+          },
+          "custom-quality-optimized": {
+            provider: "anthropic",
+            model: "claude-fable-5",
+          },
+        },
+      },
+    });
+    upgradeQualityProfileToOpus48Migration.run(workspaceDir);
+    const profiles = readProfiles();
+    expect(profiles["quality-optimized"]!.model).toBe("claude-opus-4-8");
+    expect(profiles["custom-quality-optimized"]!.model).toBe("claude-fable-5");
+  });
+
+  test("upgrades OpenRouter-prefixed model ids", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            provider: "openrouter",
+            model: "anthropic/claude-fable-5",
+          },
+        },
+      },
+    });
+    upgradeQualityProfileToOpus48Migration.run(workspaceDir);
+    expect(readProfiles()["quality-optimized"]!.model).toBe(
+      "anthropic/claude-opus-4.8",
+    );
+  });
+
+  test("leaves user-customized models untouched", () => {
+    const original = {
+      llm: {
+        profiles: {
+          "quality-optimized": { provider: "openai", model: "gpt-5.4" },
+        },
+      },
+    };
+    writeConfig(original);
+    upgradeQualityProfileToOpus48Migration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("leaves non-quality profiles untouched", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: { provider: "anthropic", model: "claude-fable-5" },
+          "quality-optimized": {
+            provider: "anthropic",
+            model: "claude-fable-5",
+          },
+        },
+      },
+    });
+    upgradeQualityProfileToOpus48Migration.run(workspaceDir);
+    const profiles = readProfiles();
+    expect(profiles["balanced"]!.model).toBe("claude-fable-5");
+    expect(profiles["quality-optimized"]!.model).toBe("claude-opus-4-8");
+  });
+
+  test("idempotency: no-op on already-upgraded config (no writes)", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            provider: "anthropic",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    });
+    const beforeContent = readFileSync(
+      join(workspaceDir, "config.json"),
+      "utf-8",
+    );
+    upgradeQualityProfileToOpus48Migration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      beforeContent,
+    );
+  });
+});

package/src/agent/compaction-circuit.ts

@@ -27,6 +27,17 @@ export class CompactionCircuit {
   readonly conversationId: string;
   consecutiveCompactionFailures = 0;
   compactionCircuitOpenUntil: number | null = null;
+  /**
+   * Estimated input tokens immediately after the most recent compaction pass,
+   * or `null` before any pass this process. The budget gate's regrowth
+   * hysteresis reads it: if the history has not grown by at least
+   * `MIN_REGROWTH` tokens since this watermark, the previous pass already
+   * proved it cannot free more, so re-compacting would only thrash. Lives here
+   * because its lifetime must match the per-conversation circuit (the loop owns
+   * one circuit per conversation). Reset on process restart, the intended "one
+   * free retry after restart" behavior the failure counter already has.
+   */
+  lastPostCompactionEstimate: number | null = null;
 
   constructor(conversationId: string) {
     this.conversationId = conversationId;