@vellumai/assistant 0.9.0 → 0.10.0-staging.2

package/src/__tests__/weak-open-model.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test";
+
+import { isWeakOpenModel } from "../providers/weak-open-model.js";
+
+describe("isWeakOpenModel", () => {
+  test("matches weak open models across provider naming conventions", () => {
+    for (const model of [
+      "accounts/fireworks/models/minimax-m3",
+      "minimax/minimax-m3",
+      "moonshotai/kimi-k2.6",
+      "accounts/fireworks/models/kimi-k2p6",
+      "deepseek/deepseek-chat",
+      "accounts/fireworks/models/glm-5p2",
+    ]) {
+      expect(isWeakOpenModel(model)).toBe(true);
+    }
+  });
+
+  test("does not match capable models", () => {
+    for (const model of ["claude-opus-4-8", "claude-sonnet-4-6", "gpt-5.5"]) {
+      expect(isWeakOpenModel(model)).toBe(false);
+    }
+  });
+
+  test("is false for null/undefined/empty", () => {
+    expect(isWeakOpenModel(null)).toBe(false);
+    expect(isWeakOpenModel(undefined)).toBe(false);
+    expect(isWeakOpenModel("")).toBe(false);
+  });
+});

package/src/__tests__/web-search-catalog-parity.test.ts

@@ -8,20 +8,15 @@ import {
 } from "../providers/search-provider-catalog.js";
 
 /**
- * Parity guard: daemon TS catalog vs the two generated JSON copies.
+ * Parity guard: daemon TS catalog vs the generated JSON copy.
  *
  * The daemon maintains its canonical search-provider catalog in
  * `assistant/src/providers/search-provider-catalog.ts`.
- * `assistant/scripts/sync-web-search-catalog.ts` writes two byte-identical
- * artifacts:
- *   - `meta/web-search-provider-catalog.json` — primary cross-package artifact.
- *   - `clients/shared/Resources/web-search-provider-catalog.json` — SwiftPM
- *     resource bundled into `VellumAssistantShared` (Swift cannot reach
- *     files outside a target's source directory).
+ * `assistant/scripts/sync-web-search-catalog.ts` writes
+ * `meta/web-search-provider-catalog.json` — the primary cross-package artifact.
  *
  * These tests enforce structural equality between the TS catalog and the
- * meta/ copy, plus byte equality between the meta/ copy and the SwiftPM
- * mirror. CI fails when any of the three drift.
+ * meta/ copy. CI fails when they drift.
  */
 
 interface JsonCatalogEntry {
@@ -46,11 +41,6 @@ const META_JSON_PATH = join(
   "..",
   "meta/web-search-provider-catalog.json",
 );
-const SWIFTPM_MIRROR_PATH = join(
-  process.cwd(),
-  "..",
-  "clients/shared/Resources/web-search-provider-catalog.json",
-);
 
 function loadJsonCatalog(): JsonCatalog {
   return JSON.parse(readFileSync(META_JSON_PATH, "utf-8"));
@@ -73,7 +63,8 @@ function entryToPlain(
   if (entry.apiKeyPrefix !== undefined) out.apiKeyPrefix = entry.apiKeyPrefix;
   if (entry.envVar !== undefined) out.envVar = entry.envVar;
   if (entry.secretKey !== undefined) out.secretKey = entry.secretKey;
-  if (entry.fallbackOrder !== undefined) out.fallbackOrder = entry.fallbackOrder;
+  if (entry.fallbackOrder !== undefined)
+    out.fallbackOrder = entry.fallbackOrder;
   if (entry.privacyPolicyUrl !== undefined) {
     out.privacyPolicyUrl = entry.privacyPolicyUrl;
   }
@@ -95,14 +86,4 @@ describe("web-search catalog parity (TS canonical vs meta/ JSON)", () => {
       SEARCH_PROVIDER_CATALOG.map((p) => p.id),
     );
   });
-
-  test("SwiftPM mirror is byte-identical to meta/ copy", () => {
-    // The generator writes both files from the same serializer; this guard
-    // catches any case where one copy is regenerated without the other.
-    // Byte equality is required because SwiftPM bundles the resource verbatim
-    // and the meta/ JSON is consumed as a cross-package artifact.
-    const metaBytes = readFileSync(META_JSON_PATH);
-    const swiftPmBytes = readFileSync(SWIFTPM_MIRROR_PATH);
-    expect(swiftPmBytes.equals(metaBytes)).toBe(true);
-  });
 });

package/src/__tests__/workspace-greetings.test.ts

@@ -0,0 +1,152 @@
+/**
+ * Unit tests for workspace-authored greeting parsing.
+ */
+
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+const workspaceFiles: Record<string, string> = {};
+
+mock.module("node:fs", () => ({
+  existsSync: (path: string) => {
+    const name = path.split("/").pop() ?? "";
+    return name in workspaceFiles;
+  },
+  readFileSync: (path: string, _encoding: string) => {
+    const name = path.split("/").pop() ?? "";
+    if (name in workspaceFiles) return workspaceFiles[name];
+    throw new Error(`ENOENT: ${path}`);
+  },
+}));
+
+import {
+  parseGreetingsSection,
+  readWorkspaceGreetings,
+} from "../runtime/routes/workspace-greetings.js";
+
+afterEach(() => {
+  for (const key of Object.keys(workspaceFiles)) {
+    delete workspaceFiles[key];
+  }
+});
+
+describe("parseGreetingsSection", () => {
+  test("parses bullet list from ## Greetings section", () => {
+    const content = [
+      "# Soul",
+      "",
+      "## Greetings",
+      "- Hey there, friend!",
+      "- What's on your mind?",
+      "- Ready to roll!",
+      "",
+      "## Other Section",
+      "Some other content.",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual([
+      "Hey there, friend!",
+      "What's on your mind?",
+      "Ready to roll!",
+    ]);
+  });
+
+  test("handles asterisk bullets", () => {
+    const content = ["## Greetings", "* Hello!", "* Hi there."].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual(["Hello!", "Hi there."]);
+  });
+
+  test("handles plus and numbered bullets", () => {
+    const content = [
+      "## Greetings",
+      "+ Welcome back.",
+      "1. Ready when you are.",
+      "2) What are we building today?",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual([
+      "Welcome back.",
+      "Ready when you are.",
+      "What are we building today?",
+    ]);
+  });
+
+  test("only starts at a level-two Greetings heading", () => {
+    const content = [
+      "# Greetings",
+      "- Not the section contract.",
+      "",
+      "## Greetings",
+      "- The real greeting.",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual(["The real greeting."]);
+  });
+
+  test("returns null when section is missing", () => {
+    const content = ["# Soul", "## Personality", "Be friendly."].join("\n");
+
+    expect(parseGreetingsSection(content)).toBeNull();
+  });
+
+  test("returns null when section is empty", () => {
+    const content = ["## Greetings", "", "## Next Section"].join("\n");
+
+    expect(parseGreetingsSection(content)).toBeNull();
+  });
+
+  test("ignores non-bullet lines in section", () => {
+    const content = [
+      "## Greetings",
+      "Some intro text that's not a bullet",
+      "- Actual greeting",
+      "Another non-bullet line",
+      "- Second greeting",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual([
+      "Actual greeting",
+      "Second greeting",
+    ]);
+  });
+
+  test("allows nested headings and stops at the next same-or-higher heading", () => {
+    const content = [
+      "## Greetings",
+      "- First",
+      "- Second",
+      "### Sub-heading",
+      "- Third",
+      "## Other Section",
+      "- Should not appear",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual([
+      "First",
+      "Second",
+      "Third",
+    ]);
+  });
+});
+
+describe("readWorkspaceGreetings", () => {
+  test("reads greetings from SOUL.md", () => {
+    workspaceFiles["SOUL.md"] = [
+      "# Soul",
+      "## Greetings",
+      "- Hey!",
+      "- What's up?",
+    ].join("\n");
+
+    expect(readWorkspaceGreetings()).toEqual(["Hey!", "What's up?"]);
+  });
+
+  test("returns null when SOUL.md has no greetings section", () => {
+    workspaceFiles["SOUL.md"] = "# Soul\nBe friendly.";
+    expect(readWorkspaceGreetings()).toBeNull();
+  });
+
+  test("returns null when SOUL.md does not exist", () => {
+    expect(readWorkspaceGreetings()).toBeNull();
+  });
+});

package/src/__tests__/workspace-migration-105-enable-memory-v3-live-for-new-workspaces.test.ts

@@ -0,0 +1,149 @@
+/**
+ * Tests for workspace migration `105-enable-memory-v3-live-for-new-workspaces`.
+ *
+ * The schema default for `memory.v3.live` is false so existing assistants stay
+ * on v2. The migration persists `memory.v3.live = true` for FRESH workspaces
+ * only (switching new assistants onto memory-v3 at creation), creating
+ * `config.json` when it does not exist, leaving existing workspaces and
+ * explicit values untouched, and being 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 { MemoryV3ConfigSchema } from "../config/schemas/memory-v3.js";
+import { enableMemoryV3LiveForNewWorkspacesMigration } from "../workspace/migrations/105-enable-memory-v3-live-for-new-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-105-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("105-enable-memory-v3-live-for-new-workspaces migration", () => {
+  test("has correct id and description", () => {
+    expect(enableMemoryV3LiveForNewWorkspacesMigration.id).toBe(
+      "105-enable-memory-v3-live-for-new-workspaces",
+    );
+    expect(enableMemoryV3LiveForNewWorkspacesMigration.description).toContain(
+      "memory.v3.live",
+    );
+  });
+
+  test("schema default is off so existing assistants stay on v2", () => {
+    expect(MemoryV3ConfigSchema.parse({}).live).toBe(false);
+  });
+
+  test("creates config.json with memory.v3.live=true for a fresh workspace", () => {
+    enableMemoryV3LiveForNewWorkspacesMigration.run(
+      workspaceDir,
+      NEW_WORKSPACE_CTX,
+    );
+
+    expect(readConfig()).toEqual({ memory: { v3: { live: true } } });
+  });
+
+  test("adds memory.v3.live to a fresh workspace's existing config, preserving siblings", () => {
+    writeFileSync(
+      configPath,
+      JSON.stringify({ name: "Assistant", memory: { enabled: true } }),
+      "utf-8",
+    );
+
+    enableMemoryV3LiveForNewWorkspacesMigration.run(
+      workspaceDir,
+      NEW_WORKSPACE_CTX,
+    );
+
+    expect(readConfig()).toEqual({
+      name: "Assistant",
+      memory: { enabled: true, v3: { live: true } },
+    });
+  });
+
+  test("skips existing workspaces so they stay on v2 (no config written)", () => {
+    enableMemoryV3LiveForNewWorkspacesMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(existsSync(configPath)).toBe(false);
+  });
+
+  test("treats a missing context as an existing workspace", () => {
+    enableMemoryV3LiveForNewWorkspacesMigration.run(workspaceDir);
+
+    expect(existsSync(configPath)).toBe(false);
+  });
+
+  test("leaves an explicit memory.v3.live value untouched on a fresh workspace", () => {
+    const original = JSON.stringify({ memory: { v3: { live: false } } });
+    writeFileSync(configPath, original, "utf-8");
+
+    enableMemoryV3LiveForNewWorkspacesMigration.run(
+      workspaceDir,
+      NEW_WORKSPACE_CTX,
+    );
+
+    expect(readFileSync(configPath, "utf-8")).toBe(original);
+  });
+
+  test("leaves malformed config.json untouched", () => {
+    writeFileSync(configPath, "{ not json", "utf-8");
+
+    enableMemoryV3LiveForNewWorkspacesMigration.run(
+      workspaceDir,
+      NEW_WORKSPACE_CTX,
+    );
+
+    expect(readFileSync(configPath, "utf-8")).toBe("{ not json");
+  });
+
+  test("is idempotent", () => {
+    enableMemoryV3LiveForNewWorkspacesMigration.run(
+      workspaceDir,
+      NEW_WORKSPACE_CTX,
+    );
+    const afterFirst = readFileSync(configPath, "utf-8");
+
+    enableMemoryV3LiveForNewWorkspacesMigration.run(
+      workspaceDir,
+      NEW_WORKSPACE_CTX,
+    );
+
+    expect(readFileSync(configPath, "utf-8")).toBe(afterFirst);
+  });
+
+  test("down is a no-op", () => {
+    enableMemoryV3LiveForNewWorkspacesMigration.run(
+      workspaceDir,
+      NEW_WORKSPACE_CTX,
+    );
+    const before = readFileSync(configPath, "utf-8");
+
+    enableMemoryV3LiveForNewWorkspacesMigration.down(workspaceDir);
+
+    expect(readFileSync(configPath, "utf-8")).toBe(before);
+  });
+});

package/src/__tests__/workspace-migration-108-drop-balanced-economy-profile.test.ts

@@ -0,0 +1,285 @@
+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 { dropBalancedEconomyProfileMigration } from "../workspace/migrations/108-drop-balanced-economy-profile.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 readLlm(): Record<string, unknown> {
+  return readConfig().llm as Record<string, unknown>;
+}
+
+function readProfiles(): Record<string, Record<string, unknown>> {
+  return readLlm().profiles as Record<string, Record<string, unknown>>;
+}
+
+const managedBalanced = {
+  provider: "fireworks",
+  provider_connection: "fireworks-managed",
+  model: "accounts/fireworks/models/minimax-m3",
+  source: "managed",
+  label: "Balanced",
+  description: "Good balance of quality, cost, and speed",
+  maxTokens: 32000,
+};
+
+const managedEconomy = {
+  provider: "fireworks",
+  provider_connection: "fireworks-managed",
+  model: "accounts/fireworks/models/minimax-m3",
+  source: "managed",
+  label: "Balanced Economy",
+  description: "Strong open model (MiniMax M3) at a lower price point",
+  maxTokens: 32000,
+};
+
+beforeEach(() => {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-107-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("108-drop-balanced-economy-profile migration", () => {
+  test("no-op when config.json does not exist", () => {
+    dropBalancedEconomyProfileMigration.run(workspaceDir);
+    expect(existsSync(join(workspaceDir, "config.json"))).toBe(false);
+  });
+
+  test("no-op when config has no llm", () => {
+    const original = { something: "else" };
+    writeConfig(original);
+    dropBalancedEconomyProfileMigration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("gracefully handles invalid JSON", () => {
+    writeFileSync(join(workspaceDir, "config.json"), "not-valid-json");
+    dropBalancedEconomyProfileMigration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      "not-valid-json",
+    );
+  });
+
+  test("drops balanced-economy, prunes profileOrder, leaves balanced alone", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: { ...managedBalanced },
+          "balanced-economy": { ...managedEconomy },
+        },
+        profileOrder: ["auto", "balanced", "balanced-economy"],
+        activeProfile: "balanced",
+      },
+    });
+    dropBalancedEconomyProfileMigration.run(workspaceDir);
+
+    const profiles = readProfiles();
+    expect("balanced-economy" in profiles).toBe(false);
+    // The seeder owns balanced's content; the migration must not touch it.
+    expect(profiles.balanced).toEqual(managedBalanced);
+    expect(readLlm().profileOrder).toEqual(["auto", "balanced"]);
+  });
+
+  test("repoints activeProfile from balanced-economy to balanced", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: { ...managedBalanced },
+          "balanced-economy": { ...managedEconomy },
+        },
+        activeProfile: "balanced-economy",
+      },
+    });
+    dropBalancedEconomyProfileMigration.run(workspaceDir);
+    expect(readLlm().activeProfile).toBe("balanced");
+  });
+
+  test("repoints advisorProfile from balanced-economy to balanced", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: { ...managedBalanced },
+          "balanced-economy": { ...managedEconomy },
+        },
+        advisorProfile: "balanced-economy",
+      },
+    });
+    dropBalancedEconomyProfileMigration.run(workspaceDir);
+    expect(readLlm().advisorProfile).toBe("balanced");
+  });
+
+  test("re-enables a disabled balanced when it becomes the active selection", () => {
+    // Supported state: user disabled the old balanced profile while actively
+    // using balanced-economy. After consolidation the active selection lands
+    // on balanced, which must be enabled or the user is left with no route.
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: { ...managedBalanced, status: "disabled" },
+          "balanced-economy": { ...managedEconomy },
+        },
+        activeProfile: "balanced-economy",
+      },
+    });
+    dropBalancedEconomyProfileMigration.run(workspaceDir);
+
+    expect(readLlm().activeProfile).toBe("balanced");
+    expect("status" in readProfiles().balanced!).toBe(false);
+  });
+
+  test("leaves a disabled balanced alone when it was not the active selection", () => {
+    // The user deliberately disabled balanced while active on a different
+    // profile — dropping balanced-economy must not silently re-enable it.
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: { ...managedBalanced, status: "disabled" },
+          quality: { source: "managed", provider: "anthropic", status: "ok" },
+          "balanced-economy": { ...managedEconomy },
+        },
+        activeProfile: "quality",
+      },
+    });
+    dropBalancedEconomyProfileMigration.run(workspaceDir);
+
+    expect(readLlm().activeProfile).toBe("quality");
+    expect(readProfiles().balanced!.status).toBe("disabled");
+  });
+
+  test("repoints call-site profile overrides to balanced", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: { ...managedBalanced },
+          "balanced-economy": { ...managedEconomy },
+        },
+        callSites: {
+          memoryRouter: { profile: "balanced-economy" },
+          replySuggestion: { profile: "cost-optimized" },
+        },
+        activeProfile: "balanced",
+      },
+    });
+    dropBalancedEconomyProfileMigration.run(workspaceDir);
+
+    const callSites = readLlm().callSites as Record<
+      string,
+      Record<string, unknown>
+    >;
+    expect(callSites.memoryRouter!.profile).toBe("balanced");
+    expect(callSites.replySuggestion!.profile).toBe("cost-optimized");
+  });
+
+  test("repoints mix-profile arms to balanced", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: { ...managedBalanced },
+          "balanced-economy": { ...managedEconomy },
+          "my-mix": {
+            source: "user",
+            mix: [
+              { profile: "balanced-economy", weight: 1 },
+              { profile: "quality-optimized", weight: 1 },
+            ],
+          },
+        },
+        activeProfile: "my-mix",
+      },
+    });
+    dropBalancedEconomyProfileMigration.run(workspaceDir);
+
+    const mix = readProfiles()["my-mix"]!.mix as Array<Record<string, unknown>>;
+    expect(mix[0]!.profile).toBe("balanced");
+    expect(mix[1]!.profile).toBe("quality-optimized");
+  });
+
+  test("leaves a user-owned balanced-economy profile and its references untouched", () => {
+    // The ownership guard covers references too: a user profile sharing the
+    // name keeps its profileOrder slot, active selection, and call-site pins.
+    const original = {
+      llm: {
+        profiles: {
+          balanced: { ...managedBalanced },
+          "balanced-economy": {
+            provider: "fireworks",
+            model: "accounts/fireworks/models/minimax-m3",
+            source: "user",
+          },
+        },
+        profileOrder: ["auto", "balanced", "balanced-economy"],
+        callSites: { memoryRouter: { profile: "balanced-economy" } },
+        activeProfile: "balanced-economy",
+        advisorProfile: "balanced-economy",
+      },
+    };
+    writeConfig(original);
+    dropBalancedEconomyProfileMigration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("prunes a dangling balanced-economy reference even when the profile is absent", () => {
+    writeConfig({
+      llm: {
+        profiles: { balanced: { ...managedBalanced } },
+        profileOrder: ["auto", "balanced", "balanced-economy"],
+        callSites: { memoryRouter: { profile: "balanced-economy" } },
+        activeProfile: "balanced-economy",
+      },
+    });
+    dropBalancedEconomyProfileMigration.run(workspaceDir);
+
+    const llm = readLlm();
+    expect(llm.profileOrder).toEqual(["auto", "balanced"]);
+    expect(llm.activeProfile).toBe("balanced");
+    expect(
+      (llm.callSites as Record<string, Record<string, unknown>>).memoryRouter!
+        .profile,
+    ).toBe("balanced");
+  });
+
+  test("idempotency: no-op once balanced-economy is gone (no writes)", () => {
+    writeConfig({
+      llm: {
+        profiles: { balanced: { ...managedBalanced } },
+        profileOrder: ["auto", "balanced"],
+        activeProfile: "balanced",
+      },
+    });
+    const beforeContent = readFileSync(
+      join(workspaceDir, "config.json"),
+      "utf-8",
+    );
+    dropBalancedEconomyProfileMigration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      beforeContent,
+    );
+  });
+});

package/src/__tests__/workspace-migration-add-send-diagnostics.test.ts

@@ -49,7 +49,7 @@ describe("005-add-send-diagnostics migration", () => {
   test("runs without error on existing config (no-op)", () => {
     existsSyncFn.mockImplementation(() => true);
     readFileSyncFn.mockImplementation(() =>
-      JSON.stringify({ collectUsageData: true }),
+      JSON.stringify({ sendDiagnostics: true }),
     );
 
     addSendDiagnosticsMigration.run(WORKSPACE_DIR);