@vellumai/assistant 0.8.11 → 0.8.12-staging.2

package/src/__tests__/workspace-migration-100-upgrade-quality-profile-to-fable-5.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 { upgradeQualityProfileToFable5Migration } from "../workspace/migrations/100-upgrade-quality-profile-to-fable-5.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-100-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("100-upgrade-quality-profile-to-fable-5 migration", () => {
+  test("no-op when config.json does not exist", () => {
+    upgradeQualityProfileToFable5Migration.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);
+    upgradeQualityProfileToFable5Migration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("gracefully handles invalid JSON", () => {
+    writeFileSync(join(workspaceDir, "config.json"), "not-valid-json");
+    upgradeQualityProfileToFable5Migration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      "not-valid-json",
+    );
+  });
+
+  test("upgrades quality-optimized from claude-opus-4-7", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            provider: "anthropic",
+            model: "claude-opus-4-7",
+            label: "Quality",
+          },
+        },
+      },
+    });
+    upgradeQualityProfileToFable5Migration.run(workspaceDir);
+    const profile = readProfiles()["quality-optimized"]!;
+    expect(profile.model).toBe("claude-fable-5");
+    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-opus-4-8",
+          },
+          "custom-quality-optimized": {
+            provider: "anthropic",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    });
+    upgradeQualityProfileToFable5Migration.run(workspaceDir);
+    const profiles = readProfiles();
+    expect(profiles["quality-optimized"]!.model).toBe("claude-fable-5");
+    expect(profiles["custom-quality-optimized"]!.model).toBe("claude-opus-4-8");
+  });
+
+  test("upgrades OpenRouter-prefixed model ids", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            provider: "openrouter",
+            model: "anthropic/claude-opus-4.8",
+          },
+        },
+      },
+    });
+    upgradeQualityProfileToFable5Migration.run(workspaceDir);
+    expect(readProfiles()["quality-optimized"]!.model).toBe(
+      "anthropic/claude-fable-5",
+    );
+  });
+
+  test("leaves user-customized models untouched", () => {
+    const original = {
+      llm: {
+        profiles: {
+          "quality-optimized": { provider: "openai", model: "gpt-5.4" },
+        },
+      },
+    };
+    writeConfig(original);
+    upgradeQualityProfileToFable5Migration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("leaves non-quality profiles untouched", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: { provider: "anthropic", model: "claude-opus-4-8" },
+          "quality-optimized": {
+            provider: "anthropic",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    });
+    upgradeQualityProfileToFable5Migration.run(workspaceDir);
+    const profiles = readProfiles();
+    expect(profiles["balanced"]!.model).toBe("claude-opus-4-8");
+    expect(profiles["quality-optimized"]!.model).toBe("claude-fable-5");
+  });
+
+  test("idempotency: no-op on already-upgraded config (no writes)", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            provider: "anthropic",
+            model: "claude-fable-5",
+          },
+        },
+      },
+    });
+    const beforeContent = readFileSync(
+      join(workspaceDir, "config.json"),
+      "utf-8",
+    );
+    upgradeQualityProfileToFable5Migration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      beforeContent,
+    );
+  });
+});

package/src/__tests__/workspace-migration-101-upgrade-balanced-economy-to-minimax-m3.test.ts

@@ -0,0 +1,162 @@
+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 { upgradeBalancedEconomyToMinimaxM3Migration } from "../workspace/migrations/101-upgrade-balanced-economy-to-minimax-m3.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-101-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("101-upgrade-balanced-economy-to-minimax-m3 migration", () => {
+  test("no-op when config.json does not exist", () => {
+    upgradeBalancedEconomyToMinimaxM3Migration.run(workspaceDir);
+    expect(existsSync(join(workspaceDir, "config.json"))).toBe(false);
+  });
+
+  test("no-op when config has no llm.profiles", () => {
+    const original = { llm: { default: { provider: "fireworks" } } };
+    writeConfig(original);
+    upgradeBalancedEconomyToMinimaxM3Migration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("gracefully handles invalid JSON", () => {
+    writeFileSync(join(workspaceDir, "config.json"), "not-valid-json");
+    upgradeBalancedEconomyToMinimaxM3Migration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      "not-valid-json",
+    );
+  });
+
+  test("upgrades balanced-economy from Kimi K2.6 and drops the logit-bias preset", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "balanced-economy": {
+            provider: "fireworks",
+            provider_connection: "fireworks-managed",
+            model: "accounts/fireworks/models/kimi-k2p6",
+            label: "Balanced Economy",
+            description: "Strong open model (Kimi K2.6) at a lower price point",
+            maxTokens: 16000,
+            effort: "high",
+            thinking: { enabled: true, streamThinking: true },
+            contextWindow: { maxInputTokens: 200000 },
+            logitBias: "suppress-cjk",
+          },
+        },
+      },
+    });
+    upgradeBalancedEconomyToMinimaxM3Migration.run(workspaceDir);
+    const profile = readProfiles()["balanced-economy"]!;
+    expect(profile.model).toBe("accounts/fireworks/models/minimax-m3");
+    expect(profile.description).toBe(
+      "Strong open model (MiniMax M3) at a lower price point",
+    );
+    expect(profile.maxTokens).toBe(32000);
+    expect(profile.contextWindow).toEqual({ maxInputTokens: 200000 });
+    expect("logitBias" in profile).toBe(false);
+    expect(profile.label).toBe("Balanced Economy");
+    expect(profile.effort).toBe("high");
+    expect(profile.thinking).toEqual({ enabled: true, streamThinking: true });
+  });
+
+  test("leaves user-customized models untouched", () => {
+    const original = {
+      llm: {
+        profiles: {
+          "balanced-economy": {
+            provider: "fireworks",
+            model: "accounts/fireworks/models/deepseek-v4-pro",
+            logitBias: "suppress-cjk",
+          },
+        },
+      },
+    };
+    writeConfig(original);
+    upgradeBalancedEconomyToMinimaxM3Migration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("leaves other profiles untouched", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "my-kimi": {
+            provider: "fireworks",
+            model: "accounts/fireworks/models/kimi-k2p6",
+          },
+          "balanced-economy": {
+            provider: "fireworks",
+            model: "accounts/fireworks/models/kimi-k2p6",
+          },
+        },
+      },
+    });
+    upgradeBalancedEconomyToMinimaxM3Migration.run(workspaceDir);
+    const profiles = readProfiles();
+    expect(profiles["my-kimi"]!.model).toBe(
+      "accounts/fireworks/models/kimi-k2p6",
+    );
+    expect(profiles["balanced-economy"]!.model).toBe(
+      "accounts/fireworks/models/minimax-m3",
+    );
+  });
+
+  test("idempotency: no-op on already-upgraded config (no writes)", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "balanced-economy": {
+            provider: "fireworks",
+            model: "accounts/fireworks/models/minimax-m3",
+          },
+        },
+      },
+    });
+    const beforeContent = readFileSync(
+      join(workspaceDir, "config.json"),
+      "utf-8",
+    );
+    upgradeBalancedEconomyToMinimaxM3Migration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      beforeContent,
+    );
+  });
+});

package/src/__tests__/workspace-release-notes-feature-flag-guard.test.ts

@@ -1,37 +1,29 @@
-import { readdirSync, readFileSync } from "node:fs";
+import { readdirSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
-type Registry = {
-  flags: Array<{
-    key: string;
-    scope: string;
-    defaultEnabled: boolean;
-  }>;
-};
-
-const LEGACY_FLAGGED_RELEASE_NOTE_ALLOWLIST = new Map<string, string>([
-  [
-    "045-release-notes-meet-avatar.ts",
-    "Historical bulletin that already shipped before this guard existed.",
-  ],
-]);
-
-const FLAGGED_FEATURE_LANGUAGE_PATTERNS: Array<{
-  label: string;
-  pattern: RegExp;
-}> = [
-  { label: "feature flag", pattern: /\bfeature[- ]flag(?:ged)?\b/i },
-  { label: "rollout flag", pattern: /\brollout flag\b/i },
-  { label: "behind ... flag", pattern: /\bbehind\b[^\n.]{0,120}\bflag\b/i },
-  { label: "gated on", pattern: /\bgated on\b/i },
-  { label: "when enabled", pattern: /\bwhen enabled\b/i },
+/**
+ * The historical release-note workspace migrations. These appended bulletins
+ * to `<workspace>/UPDATES.md`, which a background job processed at daemon
+ * startup. That job has been removed — nothing consumes UPDATES.md release
+ * notes anymore — so the set below is frozen. Migration files themselves are
+ * append-only and must never be deleted (see the migrations AGENTS.md), but
+ * no new ones of this shape may be added.
+ */
+const FROZEN_RELEASE_NOTE_MIGRATIONS = [
+  "043-release-notes-latex-rendering.ts",
+  "045-release-notes-meet-avatar.ts",
+  "049-release-notes-default-sonnet.ts",
+  "053-release-notes-acp-codex.ts",
+  "055-release-notes-agentic-recall.ts",
+  "056-release-notes-inference-profile-reordering.ts",
+  "058-release-notes-acp-sessions-ui.ts",
+  "063-release-notes-dynamic-model-context.ts",
+  "067-release-notes-safe-storage-limits.ts",
+  "068-release-notes-local-timezone.ts",
+  "078-release-notes-tavily-web-search.ts",
 ];
 
-function getRepoRoot(): string {
-  return join(process.cwd(), "..");
-}
-
 function getReleaseNoteMigrationFiles(): string[] {
   const migrationsDir = join(process.cwd(), "src", "workspace", "migrations");
   return readdirSync(migrationsDir)
@@ -39,77 +31,35 @@ function getReleaseNoteMigrationFiles(): string[] {
     .sort();
 }
 
-function loadDefaultDisabledAssistantFlagKeys(): string[] {
-  const registryPath = join(
-    getRepoRoot(),
-    "meta",
-    "feature-flags",
-    "feature-flag-registry.json",
-  );
-  const registry = JSON.parse(readFileSync(registryPath, "utf-8")) as Registry;
-  return registry.flags
-    .filter((flag) => flag.scope === "assistant" && !flag.defaultEnabled)
-    .map((flag) => flag.key)
-    .sort();
-}
-
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function featureFlagKeyPattern(key: string): RegExp {
-  const escaped = escapeRegExp(key);
-  if (key.includes("-")) {
-    return new RegExp(`(?:^|[^a-z0-9-])${escaped}(?:$|[^a-z0-9-])`, "i");
-  }
-
-  return new RegExp("[`'\"]" + escaped + "[`'\"]", "i");
-}
+describe("workspace release-note migrations guard", () => {
+  test("no new release-note migrations are added", () => {
+    const found = getReleaseNoteMigrationFiles();
+    const newMigrations = found.filter(
+      (fileName) => !FROZEN_RELEASE_NOTE_MIGRATIONS.includes(fileName),
+    );
 
-describe("workspace release-note migrations feature flag guard", () => {
-  test("new release-note migrations do not announce default-disabled feature-flagged work", () => {
-    const migrationsDir = join(process.cwd(), "src", "workspace", "migrations");
-    const defaultDisabledFlagKeys = loadDefaultDisabledAssistantFlagKeys();
-    const violations: string[] = [];
-
-    for (const fileName of getReleaseNoteMigrationFiles()) {
-      if (LEGACY_FLAGGED_RELEASE_NOTE_ALLOWLIST.has(fileName)) {
-        continue;
-      }
-
-      const content = readFileSync(join(migrationsDir, fileName), "utf-8");
-
-      for (const { label, pattern } of FLAGGED_FEATURE_LANGUAGE_PATTERNS) {
-        if (pattern.test(content)) {
-          violations.push(
-            `${fileName}: contains flagged-feature language "${label}"`,
-          );
-        }
-      }
-
-      for (const key of defaultDisabledFlagKeys) {
-        if (featureFlagKeyPattern(key).test(content)) {
-          violations.push(
-            `${fileName}: references default-disabled assistant feature flag "${key}"`,
-          );
-        }
-      }
-    }
-
-    if (violations.length > 0) {
+    if (newMigrations.length > 0) {
       const message = [
-        "Release-note migrations write to UPDATES.md, which is processed without checking feature flags.",
-        "Do not announce features that are still behind default-disabled assistant flags or rollout flags.",
-        "Wait until GA and add a new append-only release-note migration with a new marker.",
-        "",
-        "Violations:",
-        ...violations.map((violation) => `  - ${violation}`),
+        "Release-note migrations append to <workspace>/UPDATES.md, but the",
+        "background job that processed that file has been removed — nothing",
+        "consumes release notes written there. Do not add new release-note",
+        "migrations until a replacement surfacing mechanism is designed.",
         "",
-        "If this is an already-shipped historical bulletin, add a narrow entry to",
-        "LEGACY_FLAGGED_RELEASE_NOTE_ALLOWLIST in workspace-release-notes-feature-flag-guard.test.ts.",
+        "New release-note migrations found:",
+        ...newMigrations.map((fileName) => `  - ${fileName}`),
       ].join("\n");
 
-      expect(violations, message).toEqual([]);
+      expect(newMigrations, message).toEqual([]);
+    }
+  });
+
+  test("frozen release-note migrations are never deleted", () => {
+    // Migrations are append-only: even though their bulletins are no longer
+    // processed, deleting an entry breaks the sequential migration chain on
+    // existing installs.
+    const found = getReleaseNoteMigrationFiles();
+    for (const fileName of FROZEN_RELEASE_NOTE_MIGRATIONS) {
+      expect(found).toContain(fileName);
     }
   });
 });