@vellumai/assistant 0.6.5 → 0.6.6

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

@@ -3,13 +3,10 @@ import { describe, expect, test } from "bun:test";
 import {
   calculateMaxToolResultChars,
   HARD_MAX_TOOL_RESULT_CHARS,
-  isOversizedToolResult,
   MIN_KEEP_CHARS,
-  truncateOversizedToolResults,
   truncateToolResultText,
   TRUNCATION_SUFFIX,
 } from "../context/tool-result-truncation.js";
-import type { ContentBlock, ToolResultContent } from "../providers/types.js";
 
 function hasOrphanedSurrogate(str: string): boolean {
   for (let i = 0; i < str.length; i++) {
@@ -25,22 +22,6 @@ function hasOrphanedSurrogate(str: string): boolean {
   return false;
 }
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeToolResult(content: string): ToolResultContent {
-  return {
-    type: "tool_result",
-    tool_use_id: "test-id",
-    content,
-  };
-}
-
-function makeTextBlock(text: string): ContentBlock {
-  return { type: "text", text };
-}
-
 // ---------------------------------------------------------------------------
 // truncateToolResultText
 // ---------------------------------------------------------------------------
@@ -161,94 +142,3 @@ describe("calculateMaxToolResultChars", () => {
     expect(result).toBe(216_000);
   });
 });
-
-// ---------------------------------------------------------------------------
-// isOversizedToolResult
-// ---------------------------------------------------------------------------
-
-describe("isOversizedToolResult", () => {
-  test("returns false for small tool results", () => {
-    const block = makeToolResult("small content");
-    expect(isOversizedToolResult(block, 180_000)).toBe(false);
-  });
-
-  test("returns true for oversized tool results", () => {
-    const block = makeToolResult("x".repeat(500_000));
-    expect(isOversizedToolResult(block, 180_000)).toBe(true);
-  });
-
-  test("returns false for non-tool-result blocks (cast safely)", () => {
-    const textBlock = makeTextBlock("hello") as unknown as ToolResultContent;
-    // A text block has no `.content` string of meaningful length, so it
-    // should not be considered oversized. We cast to exercise the function
-    // safely even with unexpected input.
-    expect(isOversizedToolResult(textBlock, 180_000)).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// truncateOversizedToolResults
-// ---------------------------------------------------------------------------
-
-describe("truncateOversizedToolResults", () => {
-  const contextWindow = 180_000; // maxChars = 216_000
-
-  test("returns unchanged blocks when nothing is oversized", () => {
-    const blocks: ContentBlock[] = [
-      makeTextBlock("hello"),
-      makeToolResult("short"),
-    ];
-    const { blocks: result, truncatedCount } = truncateOversizedToolResults(
-      blocks,
-      contextWindow,
-    );
-    expect(truncatedCount).toBe(0);
-    expect(result).toEqual(blocks);
-  });
-
-  test("truncates oversized tool results", () => {
-    const big = makeToolResult("y".repeat(500_000));
-    const { blocks: result, truncatedCount } = truncateOversizedToolResults(
-      [big],
-      contextWindow,
-    );
-    expect(truncatedCount).toBe(1);
-    const truncated = result[0] as ToolResultContent;
-    expect(truncated.content.length).toBeLessThan(500_000);
-    expect(truncated.content).toContain(TRUNCATION_SUFFIX);
-  });
-
-  test("preserves non-tool-result blocks unchanged", () => {
-    const text = makeTextBlock("keep me");
-    const big = makeToolResult("z".repeat(500_000));
-    const { blocks: result } = truncateOversizedToolResults(
-      [text, big],
-      contextWindow,
-    );
-    expect(result[0]).toBe(text); // same reference
-  });
-
-  test("reports correct truncatedCount", () => {
-    const small = makeToolResult("ok");
-    const big = makeToolResult("a".repeat(500_000));
-    const { truncatedCount } = truncateOversizedToolResults(
-      [small, big],
-      contextWindow,
-    );
-    expect(truncatedCount).toBe(1);
-  });
-
-  test("handles multiple oversized results", () => {
-    const big1 = makeToolResult("a".repeat(500_000));
-    const big2 = makeToolResult("b".repeat(500_000));
-    const { blocks: result, truncatedCount } = truncateOversizedToolResults(
-      [big1, big2],
-      contextWindow,
-    );
-    expect(truncatedCount).toBe(2);
-    for (const b of result) {
-      const tr = b as ToolResultContent;
-      expect(tr.content).toContain(TRUNCATION_SUFFIX);
-    }
-  });
-});

package/src/__tests__/user-plugin-loader.test.ts

@@ -0,0 +1,191 @@
+/**
+ * Tests for the user plugin loader (PR 29).
+ *
+ * Redirects `vellumRoot()` into a per-test temp directory via `BASE_DATA_DIR`
+ * (the canonical multi-instance override read by `util/platform.ts`) so
+ * `loadUserPlugins()` walks an isolated tree that we populate on demand.
+ *
+ * Covers:
+ * - A plugin whose `register.ts` calls `registerPlugin()` at import time
+ *   ends up in the registry after `loadUserPlugins()` resolves.
+ * - A plugin whose `register.ts` throws during import is logged + skipped;
+ *   other plugins in the same directory still load.
+ * - A missing `vellumRoot()/plugins/` directory is a no-op (zero installed
+ *   user plugins is the default shape of a fresh daemon).
+ */
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getRegisteredPlugins,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import { loadUserPlugins } from "../plugins/user-loader.js";
+
+// Isolate every run under its own tempdir so parallel test files (and
+// repeated runs of this file) cannot collide on `~/.vellum/plugins/`.
+// Each describe-scope gets a fresh subdirectory.
+const TEST_INSTANCE_DIR = join(
+  tmpdir(),
+  `vellum-user-plugin-loader-test-${process.pid}-${Date.now()}`,
+);
+process.env.BASE_DATA_DIR = TEST_INSTANCE_DIR;
+
+/** The plugins directory the loader will walk. */
+const PLUGINS_DIR = join(TEST_INSTANCE_DIR, ".vellum", "plugins");
+
+/**
+ * Write a plugin directory with a `register.ts` (TypeScript source, so bun
+ * can import it at test time without a build step) that executes the given
+ * body. The body has access to `registerPlugin` via a relative import back
+ * into the repo's registry module.
+ *
+ * `relativeRegistryImport` points from the synthetic plugin file at
+ * `<TEST_INSTANCE_DIR>/.vellum/plugins/<name>/register.ts` to the real
+ * registry source at `<repo>/assistant/src/plugins/registry.ts`. Using a
+ * relative path (rather than a project-root alias) keeps the test hermetic
+ * and matches how an on-disk user plugin would actually import the
+ * registry's public API in a real install.
+ */
+function writePlugin(name: string, body: string): void {
+  const pluginDir = join(PLUGINS_DIR, name);
+  mkdirSync(pluginDir, { recursive: true });
+  // Resolve the absolute path to the registry module so the synthetic
+  // register.ts can import it. bun happily resolves `.ts` files at runtime
+  // when the test suite itself is running in source mode.
+  const registryPath = join(import.meta.dir, "..", "plugins", "registry.ts");
+  const registerSource = `
+import { registerPlugin } from ${JSON.stringify(registryPath)};
+${body}
+`;
+  writeFileSync(join(pluginDir, "register.ts"), registerSource);
+}
+
+function clearPluginsDir(): void {
+  rmSync(TEST_INSTANCE_DIR, { recursive: true, force: true });
+}
+
+describe("user plugin loader", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    clearPluginsDir();
+  });
+
+  test("loads a valid plugin whose register.ts calls registerPlugin()", async () => {
+    writePlugin(
+      "my-plugin",
+      `
+registerPlugin({
+  manifest: {
+    name: "my-plugin",
+    version: "0.0.1",
+    requires: { pluginRuntime: "v1" },
+  },
+});
+`,
+    );
+
+    await loadUserPlugins();
+
+    const registered = getRegisteredPlugins();
+    expect(registered).toHaveLength(1);
+    expect(registered[0]?.manifest.name).toBe("my-plugin");
+  });
+
+  test("per-plugin failure is isolated: other plugins still load", async () => {
+    // Plugin A throws at import time. The loader must log and move on so
+    // Plugin B still ends up registered — one bad user plugin cannot brick
+    // the entire user-plugin surface or crash the daemon.
+    writePlugin(
+      "broken-plugin",
+      `
+throw new Error("boom at import time");
+`,
+    );
+    writePlugin(
+      "good-plugin",
+      `
+registerPlugin({
+  manifest: {
+    name: "good-plugin",
+    version: "0.0.1",
+    requires: { pluginRuntime: "v1" },
+  },
+});
+`,
+    );
+
+    await loadUserPlugins();
+
+    const registered = getRegisteredPlugins();
+    const names = registered.map((p) => p.manifest.name);
+    // Order is not guaranteed (filesystem-dependent) — assert membership.
+    expect(names).toContain("good-plugin");
+    expect(names).not.toContain("broken-plugin");
+  });
+
+  test("missing plugins/ directory is a no-op", async () => {
+    // clearPluginsDir() in beforeEach has already removed TEST_INSTANCE_DIR
+    // entirely, so vellumRoot()/plugins/ does not exist. The loader must
+    // complete without throwing and without registering anything.
+    await loadUserPlugins();
+    expect(getRegisteredPlugins()).toHaveLength(0);
+  });
+
+  test("plugin with hanging top-level await is timed out and skipped", async () => {
+    // A plugin whose module evaluation never resolves (hanging top-level
+    // await) would otherwise block daemon startup indefinitely. The loader
+    // must bound the import with a timeout so the hang is isolated the same
+    // way a thrown error would be. A neighboring well-behaved plugin must
+    // still load.
+    writePlugin(
+      "hanging-plugin",
+      `
+await new Promise(() => {
+  // Intentionally never resolves — simulates a plugin whose top-level
+  // await blocks forever.
+});
+registerPlugin({
+  manifest: {
+    name: "hanging-plugin",
+    version: "0.0.1",
+    requires: { pluginRuntime: "v1" },
+  },
+});
+`,
+    );
+    writePlugin(
+      "healthy-plugin",
+      `
+registerPlugin({
+  manifest: {
+    name: "healthy-plugin",
+    version: "0.0.1",
+    requires: { pluginRuntime: "v1" },
+  },
+});
+`,
+    );
+
+    // Use a short test-only timeout so the suite does not wait the full
+    // production 10s for the hung-plugin path.
+    await loadUserPlugins({ importTimeoutMs: 250 });
+
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).toContain("healthy-plugin");
+    expect(names).not.toContain("hanging-plugin");
+  });
+
+  test("subdirectory without register.{ts,js} is silently skipped", async () => {
+    // Populate a directory that looks like a plugin but lacks a register
+    // file. The loader must skip it without throwing.
+    const stubDir = join(PLUGINS_DIR, "not-a-plugin");
+    mkdirSync(stubDir, { recursive: true });
+    writeFileSync(join(stubDir, "README.md"), "# not actually a plugin\n");
+
+    await loadUserPlugins();
+    expect(getRegisteredPlugins()).toHaveLength(0);
+  });
+});

package/src/__tests__/workspace-migration-046-seed-conversation-starters-callsite.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 { seedConversationStartersCallsiteMigration } from "../workspace/migrations/046-seed-conversation-starters-callsite.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-046-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: 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 configPath(): string {
+  return join(workspaceDir, "config.json");
+}
+
+beforeEach(() => {
+  freshWorkspace();
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+});
+
+afterEach(() => {
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("046-seed-conversation-starters-callsite migration", () => {
+  test("has correct migration id", () => {
+    expect(seedConversationStartersCallsiteMigration.id).toBe(
+      "046-seed-conversation-starters-callsite",
+    );
+  });
+
+  test("seeds haiku callsite entry on Anthropic workspace without override", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-opus-4-7" },
+        callSites: {
+          interactionClassifier: { model: "claude-haiku-4-5-20251001" },
+        },
+      },
+    });
+
+    seedConversationStartersCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.conversationStarters).toEqual({
+      model: "claude-haiku-4-5-20251001",
+      effort: "low",
+      thinking: { enabled: false },
+    });
+    // Does not clobber unrelated entries.
+    expect(config.llm.callSites.interactionClassifier).toEqual({
+      model: "claude-haiku-4-5-20251001",
+    });
+  });
+
+  test("seeds openrouter-shaped model ID on openrouter workspace", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "openrouter", model: "anthropic/claude-opus-4.7" },
+      },
+    });
+
+    seedConversationStartersCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.conversationStarters).toEqual({
+      model: "anthropic/claude-haiku-4.5",
+      effort: "low",
+      thinking: { enabled: false },
+    });
+  });
+
+  test("skips when conversationStarters already has an explicit override", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          conversationStarters: {
+            model: "claude-opus-4-7",
+            effort: "high",
+          },
+        },
+      },
+    });
+
+    seedConversationStartersCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.conversationStarters).toEqual({
+      model: "claude-opus-4-7",
+      effort: "high",
+    });
+  });
+
+  test("skips entirely when non-Anthropic, non-OpenRouter provider is configured", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "openai", model: "gpt-5.4" },
+      },
+    });
+
+    seedConversationStartersCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, unknown> };
+    };
+    // No callSites object created at all.
+    expect(config.llm.callSites).toBeUndefined();
+  });
+
+  test("skips when VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH is set", () => {
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = "/tmp/overlay.json";
+    writeConfig({
+      llm: { default: { provider: "anthropic" } },
+    });
+
+    seedConversationStartersCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, unknown> };
+    };
+    expect(config.llm.callSites).toBeUndefined();
+  });
+
+  test("runs on fresh install (no config.json) and writes starter config", () => {
+    expect(existsSync(configPath())).toBe(false);
+
+    seedConversationStartersCallsiteMigration.run(workspaceDir);
+
+    expect(existsSync(configPath())).toBe(true);
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.conversationStarters).toEqual({
+      model: "claude-haiku-4-5-20251001",
+      effort: "low",
+      thinking: { enabled: false },
+    });
+  });
+
+  test("is idempotent — a second run is a no-op", () => {
+    writeConfig({
+      llm: { default: { provider: "anthropic" } },
+    });
+
+    seedConversationStartersCallsiteMigration.run(workspaceDir);
+    const afterFirst = readFileSync(configPath(), "utf-8");
+    seedConversationStartersCallsiteMigration.run(workspaceDir);
+    const afterSecond = readFileSync(configPath(), "utf-8");
+
+    expect(afterSecond).toBe(afterFirst);
+  });
+});

package/src/__tests__/workspace-migration-049-release-notes-default-sonnet.test.ts

@@ -0,0 +1,100 @@
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "bun:test";
+
+import { releaseNotesDefaultSonnetMigration } from "../workspace/migrations/049-release-notes-default-sonnet.js";
+
+const MIGRATION_ID = "049-release-notes-default-sonnet";
+const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+let testRoot: string;
+let workspaceDir: string;
+
+beforeAll(() => {
+  testRoot = mkdtempSync(join(tmpdir(), "migration-047-test-"));
+});
+
+afterAll(() => {
+  rmSync(testRoot, { recursive: true, force: true });
+});
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(testRoot, "ws-"));
+});
+
+afterEach(() => {
+  rmSync(workspaceDir, { recursive: true, force: true });
+});
+
+function updatesPath(): string {
+  return join(workspaceDir, "UPDATES.md");
+}
+
+describe("workspace migration 047-release-notes-default-sonnet", () => {
+  test("has the correct id", () => {
+    expect(releaseNotesDefaultSonnetMigration.id).toBe(MIGRATION_ID);
+  });
+
+  test("creates UPDATES.md with marker and key copy when file is absent", () => {
+    expect(existsSync(updatesPath())).toBe(false);
+
+    releaseNotesDefaultSonnetMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content).toContain(MARKER);
+    expect(content).toContain("Claude Sonnet 4.6");
+    expect(content).toContain("main agent");
+    expect(content).toContain("claude-opus-4-7");
+    expect(content.startsWith(MARKER)).toBe(true);
+  });
+
+  test("is a no-op when marker is already present", () => {
+    const seeded = `## Prior\n\n${MARKER}\nSomething.\n`;
+    writeFileSync(updatesPath(), seeded, "utf-8");
+
+    releaseNotesDefaultSonnetMigration.run(workspaceDir);
+    const first = readFileSync(updatesPath(), "utf-8");
+    expect(first).toBe(seeded);
+
+    releaseNotesDefaultSonnetMigration.run(workspaceDir);
+    const second = readFileSync(updatesPath(), "utf-8");
+    expect(second).toBe(seeded);
+    expect(second.split(MARKER).length - 1).toBe(1);
+  });
+
+  test("appends to existing UPDATES.md when marker is absent", () => {
+    const prior = "## Earlier note\n\nBody.\n";
+    writeFileSync(updatesPath(), prior, "utf-8");
+
+    releaseNotesDefaultSonnetMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content.startsWith(prior)).toBe(true);
+    expect(content).toContain(MARKER);
+    expect(content).not.toContain("\n\n\n");
+  });
+
+  test("down() is a no-op", () => {
+    writeFileSync(updatesPath(), `${MARKER}\nBody.\n`, "utf-8");
+    const before = readFileSync(updatesPath(), "utf-8");
+
+    releaseNotesDefaultSonnetMigration.down(workspaceDir);
+
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(before);
+  });
+});