@vellumai/assistant 0.10.4-staging.1 → 0.10.4

package/src/__tests__/workspace-migration-113-swap-balanced-profile-to-glm-5p2.test.ts

@@ -0,0 +1,241 @@
+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 { swapBalancedProfileToGlm52Migration } from "../workspace/migrations/113-swap-balanced-profile-to-glm-5p2.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>> {
+  return (readConfig().llm as Record<string, unknown>).profiles as Record<
+    string,
+    Record<string, unknown>
+  >;
+}
+
+beforeEach(() => {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-113-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("113-swap-balanced-profile-to-glm-5p2 migration", () => {
+  test("no-op when config.json does not exist", () => {
+    swapBalancedProfileToGlm52Migration.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);
+    swapBalancedProfileToGlm52Migration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("gracefully handles invalid JSON", () => {
+    writeFileSync(join(workspaceDir, "config.json"), "not-valid-json");
+    swapBalancedProfileToGlm52Migration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      "not-valid-json",
+    );
+  });
+
+  test("swaps the managed balanced profile from Together MiniMax to GLM 5.2", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            source: "managed",
+            provider: "together",
+            provider_connection: "together-managed",
+            model: "MiniMaxAI/MiniMax-M3",
+            label: "Balanced",
+            effort: "medium",
+            description: "Good balance of quality, cost, and speed",
+            topP: 0.95,
+          },
+        },
+      },
+    });
+    swapBalancedProfileToGlm52Migration.run(workspaceDir);
+    const profile = readProfiles().balanced!;
+    expect(profile.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(profile.provider).toBe("fireworks");
+    expect(profile.provider_connection).toBe("fireworks-managed");
+    expect(profile.effort).toBe("high");
+    // The seeded default topP (0.95) is dropped — GLM 5.2 carries no topP.
+    expect("topP" in profile).toBe(false);
+    // The slot's own identity (key + label + description) is preserved so pins
+    // keep resolving.
+    expect(profile.label).toBe("Balanced");
+    expect(profile.description).toBe(
+      "Good balance of quality, cost, and speed",
+    );
+  });
+
+  test("swaps a source-less legacy managed balanced profile", () => {
+    // Migration 052 seeded canonical profiles without a `source`; absent source
+    // on this reserved name means legacy managed, so it must still be swapped.
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            provider: "together",
+            provider_connection: "together-managed",
+            model: "MiniMaxAI/MiniMax-M3",
+          },
+        },
+      },
+    });
+    swapBalancedProfileToGlm52Migration.run(workspaceDir);
+    const profile = readProfiles().balanced!;
+    expect(profile.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(profile.provider).toBe("fireworks");
+    expect(profile.provider_connection).toBe("fireworks-managed");
+  });
+
+  test("preserves a user-customized topP override", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            source: "managed",
+            provider: "together",
+            provider_connection: "together-managed",
+            model: "MiniMaxAI/MiniMax-M3",
+            topP: 0.5,
+          },
+        },
+      },
+    });
+    swapBalancedProfileToGlm52Migration.run(workspaceDir);
+    const profile = readProfiles().balanced!;
+    expect(profile.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(profile.topP).toBe(0.5);
+  });
+
+  test("strips a stale seeded topP from a balanced profile already reseeded to GLM", () => {
+    // A failed-DB boot skips the migration runner but still runs the seeder,
+    // which rewrites the model to GLM while carrying the old topP: 0.95 by
+    // key-presence. On the next healthy boot this migration must still strip it.
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            source: "managed",
+            provider: "fireworks",
+            provider_connection: "fireworks-managed",
+            model: "accounts/fireworks/models/glm-5p2",
+            effort: "high",
+            topP: 0.95,
+          },
+        },
+      },
+    });
+    swapBalancedProfileToGlm52Migration.run(workspaceDir);
+    const profile = readProfiles().balanced!;
+    expect(profile.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect("topP" in profile).toBe(false);
+  });
+
+  test("preserves a user-customized topP on a profile already reseeded to GLM", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            source: "managed",
+            provider: "fireworks",
+            provider_connection: "fireworks-managed",
+            model: "accounts/fireworks/models/glm-5p2",
+            topP: 0.5,
+          },
+        },
+      },
+    });
+    swapBalancedProfileToGlm52Migration.run(workspaceDir);
+    expect(readProfiles().balanced!.topP).toBe(0.5);
+  });
+
+  test("leaves a user-owned balanced profile untouched", () => {
+    const original = {
+      llm: {
+        profiles: {
+          balanced: {
+            source: "user",
+            provider: "together",
+            model: "MiniMaxAI/MiniMax-M3",
+          },
+        },
+      },
+    };
+    writeConfig(original);
+    swapBalancedProfileToGlm52Migration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("leaves a user-retargeted managed model untouched", () => {
+    const original = {
+      llm: {
+        profiles: {
+          balanced: {
+            source: "managed",
+            provider: "anthropic",
+            model: "claude-sonnet-4-6",
+          },
+        },
+      },
+    };
+    writeConfig(original);
+    swapBalancedProfileToGlm52Migration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("idempotency: no-op on already-swapped config (no writes)", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            source: "managed",
+            provider: "fireworks",
+            provider_connection: "fireworks-managed",
+            model: "accounts/fireworks/models/glm-5p2",
+          },
+        },
+      },
+    });
+    const beforeContent = readFileSync(
+      join(workspaceDir, "config.json"),
+      "utf-8",
+    );
+    swapBalancedProfileToGlm52Migration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      beforeContent,
+    );
+  });
+});

package/src/__tests__/workspace-migration-114-swap-quality-profile-to-opus.test.ts

@@ -0,0 +1,172 @@
+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 { swapQualityProfileToOpusMigration } from "../workspace/migrations/114-swap-quality-profile-to-opus.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>> {
+  return (readConfig().llm as Record<string, unknown>).profiles as Record<
+    string,
+    Record<string, unknown>
+  >;
+}
+
+beforeEach(() => {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-114-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("114-swap-quality-profile-to-opus migration", () => {
+  test("no-op when config.json does not exist", () => {
+    swapQualityProfileToOpusMigration.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);
+    swapQualityProfileToOpusMigration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("gracefully handles invalid JSON", () => {
+    writeFileSync(join(workspaceDir, "config.json"), "not-valid-json");
+    swapQualityProfileToOpusMigration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      "not-valid-json",
+    );
+  });
+
+  test("swaps the managed quality-optimized profile from GLM 5.2 to Opus", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            source: "managed",
+            provider: "fireworks",
+            provider_connection: "fireworks-managed",
+            model: "accounts/fireworks/models/glm-5p2",
+            label: "Quality",
+            description:
+              "High-quality results with a leading open model (GLM 5.2)",
+          },
+        },
+      },
+    });
+    swapQualityProfileToOpusMigration.run(workspaceDir);
+    const profile = readProfiles()["quality-optimized"]!;
+    expect(profile.model).toBe("claude-opus-4-8");
+    expect(profile.provider).toBe("anthropic");
+    expect(profile.provider_connection).toBe("anthropic-managed");
+    expect(profile.description).toBe(
+      "High-quality results with the most capable model",
+    );
+    // The slot's own identity (key + label) is preserved so pins keep resolving.
+    expect(profile.label).toBe("Quality");
+  });
+
+  test("swaps a source-less legacy managed quality-optimized profile", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            provider: "fireworks",
+            provider_connection: "fireworks-managed",
+            model: "accounts/fireworks/models/glm-5p2",
+          },
+        },
+      },
+    });
+    swapQualityProfileToOpusMigration.run(workspaceDir);
+    const profile = readProfiles()["quality-optimized"]!;
+    expect(profile.model).toBe("claude-opus-4-8");
+    expect(profile.provider).toBe("anthropic");
+    expect(profile.provider_connection).toBe("anthropic-managed");
+  });
+
+  test("leaves a user-owned quality-optimized profile untouched", () => {
+    const original = {
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            source: "user",
+            provider: "fireworks",
+            model: "accounts/fireworks/models/glm-5p2",
+          },
+        },
+      },
+    };
+    writeConfig(original);
+    swapQualityProfileToOpusMigration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("leaves a user-retargeted managed model untouched", () => {
+    const original = {
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            source: "managed",
+            provider: "openai",
+            model: "gpt-5.4",
+          },
+        },
+      },
+    };
+    writeConfig(original);
+    swapQualityProfileToOpusMigration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("idempotency: no-op on already-swapped config (no writes)", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            source: "managed",
+            provider: "anthropic",
+            provider_connection: "anthropic-managed",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    });
+    const beforeContent = readFileSync(
+      join(workspaceDir, "config.json"),
+      "utf-8",
+    );
+    swapQualityProfileToOpusMigration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      beforeContent,
+    );
+  });
+});

package/src/__tests__/workspace-migration-116-rename-memory-plugin-disabled-sentinel.test.ts

@@ -0,0 +1,128 @@
+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 { renameMemoryPluginDisabledSentinelMigration } from "../workspace/migrations/116-rename-memory-plugin-disabled-sentinel.js";
+
+const OLD_RETRIEVAL = "default-memory-retrieval";
+const OLD_V3_SHADOW = "default-memory-v3-shadow";
+const NEW = "default-memory";
+
+let workspaceDir: string;
+let pluginsDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-116-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  pluginsDir = join(workspaceDir, "plugins");
+  mkdirSync(pluginsDir, { recursive: true });
+}
+
+function disable(pluginName: string, content = ""): void {
+  const dir = join(pluginsDir, pluginName);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, ".disabled"), content);
+}
+
+function isDisabled(pluginName: string): boolean {
+  return existsSync(join(pluginsDir, pluginName, ".disabled"));
+}
+
+function pluginDirExists(pluginName: string): boolean {
+  return existsSync(join(pluginsDir, pluginName));
+}
+
+beforeEach(freshWorkspace);
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("116-rename-memory-plugin-disabled-sentinel migration", () => {
+  test("carries the disabled sentinel forward and removes the legacy stub", () => {
+    disable(OLD_RETRIEVAL, "disabled-marker");
+
+    renameMemoryPluginDisabledSentinelMigration.run(workspaceDir);
+
+    expect(isDisabled(NEW)).toBe(true);
+    // The sentinel content is preserved exactly.
+    expect(readFileSync(join(pluginsDir, NEW, ".disabled"), "utf-8")).toBe(
+      "disabled-marker",
+    );
+    // The legacy stub directory is gone (no bogus user-plugin entry).
+    expect(pluginDirExists(OLD_RETRIEVAL)).toBe(false);
+  });
+
+  test("idempotent: running twice keeps the new sentinel and does not throw", () => {
+    disable(OLD_RETRIEVAL);
+
+    renameMemoryPluginDisabledSentinelMigration.run(workspaceDir);
+    expect(() =>
+      renameMemoryPluginDisabledSentinelMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    expect(isDisabled(NEW)).toBe(true);
+    expect(pluginDirExists(OLD_RETRIEVAL)).toBe(false);
+  });
+
+  test("no-op when no legacy sentinels exist — memory stays enabled", () => {
+    renameMemoryPluginDisabledSentinelMigration.run(workspaceDir);
+
+    expect(isDisabled(NEW)).toBe(false);
+  });
+
+  test("does not clobber an existing default-memory sentinel, still clears the stub", () => {
+    disable(OLD_RETRIEVAL, "old");
+    disable(NEW, "new");
+
+    renameMemoryPluginDisabledSentinelMigration.run(workspaceDir);
+
+    expect(readFileSync(join(pluginsDir, NEW, ".disabled"), "utf-8")).toBe(
+      "new",
+    );
+    expect(pluginDirExists(OLD_RETRIEVAL)).toBe(false);
+  });
+
+  test("disabling only memory-v3-shadow keeps memory enabled but clears its stub", () => {
+    // memory-v3-shadow's hooks were no-ops (v3 ran through the retrieval chain),
+    // so disabling it never turned memory off; the combined plugin must stay on,
+    // and its defunct stub must not linger as a bogus user plugin.
+    disable(OLD_V3_SHADOW);
+
+    renameMemoryPluginDisabledSentinelMigration.run(workspaceDir);
+
+    expect(isDisabled(NEW)).toBe(false);
+    expect(pluginDirExists(OLD_V3_SHADOW)).toBe(false);
+  });
+
+  test("both disabled: memory is disabled and both legacy stubs are removed", () => {
+    disable(OLD_RETRIEVAL);
+    disable(OLD_V3_SHADOW);
+
+    renameMemoryPluginDisabledSentinelMigration.run(workspaceDir);
+
+    expect(isDisabled(NEW)).toBe(true);
+    expect(pluginDirExists(OLD_RETRIEVAL)).toBe(false);
+    expect(pluginDirExists(OLD_V3_SHADOW)).toBe(false);
+  });
+
+  test("no-op (no throw) when the plugins directory does not exist", () => {
+    rmSync(pluginsDir, { recursive: true, force: true });
+
+    expect(() =>
+      renameMemoryPluginDisabledSentinelMigration.run(workspaceDir),
+    ).not.toThrow();
+    expect(isDisabled(NEW)).toBe(false);
+  });
+});