@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/__tests__/workspace-migration-028-recover-conversations-from-disk-view.test.ts

@@ -37,7 +37,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { conversations, messages } from "../memory/schema.js";
 import { recoverConversationsFromDiskViewMigration } from "../workspace/migrations/028-recover-conversations-from-disk-view.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -60,12 +60,17 @@ function createDiskViewDir(
   messagesJsonl?: string,
 ): string {
   const createdAt =
-    typeof meta.createdAt === "string" ? meta.createdAt : new Date().toISOString();
+    typeof meta.createdAt === "string"
+      ? meta.createdAt
+      : new Date().toISOString();
   const timestamp = createdAt.replace(/:/g, "-");
   const dirName = `${timestamp}_${id}`;
   const dirPath = join(conversationsDir, dirName);
   mkdirSync(dirPath, { recursive: true });
-  writeFileSync(join(dirPath, "meta.json"), JSON.stringify(meta, null, 2) + "\n");
+  writeFileSync(
+    join(dirPath, "meta.json"),
+    JSON.stringify(meta, null, 2) + "\n",
+  );
   if (messagesJsonl !== undefined) {
     writeFileSync(join(dirPath, "messages.jsonl"), messagesJsonl);
   }
@@ -100,7 +105,14 @@ describe("028-recover-conversations-from-disk-view migration", () => {
 
     createDiskViewDir(
       id,
-      { id, title: "Basic Recovery", type: "standard", channel: "desktop", createdAt, updatedAt },
+      {
+        id,
+        title: "Basic Recovery",
+        type: "standard",
+        channel: "desktop",
+        createdAt,
+        updatedAt,
+      },
       userLine + "\n" + assistantLine + "\n",
     );
 
@@ -148,7 +160,13 @@ describe("028-recover-conversations-from-disk-view migration", () => {
 
     createDiskViewDir(
       id,
-      { id, title: "Tool Test", type: "standard", createdAt, updatedAt: createdAt },
+      {
+        id,
+        title: "Tool Test",
+        type: "standard",
+        createdAt,
+        updatedAt: createdAt,
+      },
       toolCallLine + "\n" + toolResultLine + "\n",
     );
 
@@ -188,7 +206,13 @@ describe("028-recover-conversations-from-disk-view migration", () => {
 
     createDiskViewDir(
       id,
-      { id, title: "Mixed Test", type: "standard", createdAt, updatedAt: createdAt },
+      {
+        id,
+        title: "Mixed Test",
+        type: "standard",
+        createdAt,
+        updatedAt: createdAt,
+      },
       mixedLine + "\n",
     );
 
@@ -235,8 +259,18 @@ describe("028-recover-conversations-from-disk-view migration", () => {
     // Create matching disk-view dir with a message
     createDiskViewDir(
       id,
-      { id, title: "Already Here", type: "standard", createdAt, updatedAt: createdAt },
-      JSON.stringify({ role: "user", ts: createdAt, content: "Should not be imported" }) + "\n",
+      {
+        id,
+        title: "Already Here",
+        type: "standard",
+        createdAt,
+        updatedAt: createdAt,
+      },
+      JSON.stringify({
+        role: "user",
+        ts: createdAt,
+        content: "Should not be imported",
+      }) + "\n",
     );
 
     recoverConversationsFromDiskViewMigration.run(workspaceDir);
@@ -256,9 +290,25 @@ describe("028-recover-conversations-from-disk-view migration", () => {
 
     createDiskViewDir(
       id,
-      { id, title: "Idempotency Test", type: "standard", createdAt, updatedAt: createdAt },
-      JSON.stringify({ role: "user", ts: createdAt, content: "First message" }) + "\n" +
-        JSON.stringify({ role: "assistant", ts: "2026-03-18T17:01:00.000Z", content: "Reply" }) + "\n",
+      {
+        id,
+        title: "Idempotency Test",
+        type: "standard",
+        createdAt,
+        updatedAt: createdAt,
+      },
+      JSON.stringify({
+        role: "user",
+        ts: createdAt,
+        content: "First message",
+      }) +
+        "\n" +
+        JSON.stringify({
+          role: "assistant",
+          ts: "2026-03-18T17:01:00.000Z",
+          content: "Reply",
+        }) +
+        "\n",
     );
 
     recoverConversationsFromDiskViewMigration.run(workspaceDir);
@@ -283,10 +333,13 @@ describe("028-recover-conversations-from-disk-view migration", () => {
     const createdAt = "2026-03-18T18:00:00.000Z";
 
     // Create dir with only meta.json — no messages.jsonl
-    createDiskViewDir(
+    createDiskViewDir(id, {
       id,
-      { id, title: "No Messages", type: "standard", createdAt, updatedAt: createdAt },
-    );
+      title: "No Messages",
+      type: "standard",
+      createdAt,
+      updatedAt: createdAt,
+    });
 
     recoverConversationsFromDiskViewMigration.run(workspaceDir);
 
@@ -304,12 +357,22 @@ describe("028-recover-conversations-from-disk-view migration", () => {
     const id = "conv-028-malformed-jsonl";
     const createdAt = "2026-03-18T19:00:00.000Z";
 
-    const validLine = JSON.stringify({ role: "user", ts: createdAt, content: "Valid" });
+    const validLine = JSON.stringify({
+      role: "user",
+      ts: createdAt,
+      content: "Valid",
+    });
     const invalidLine = "{ this is not valid json }}}";
 
     createDiskViewDir(
       id,
-      { id, title: "Malformed JSONL", type: "standard", createdAt, updatedAt: createdAt },
+      {
+        id,
+        title: "Malformed JSONL",
+        type: "standard",
+        createdAt,
+        updatedAt: createdAt,
+      },
       validLine + "\n" + invalidLine + "\n",
     );
 
@@ -368,8 +431,15 @@ describe("028-recover-conversations-from-disk-view migration", () => {
       const ts = new Date(baseTime + i * 60_000).toISOString();
       createDiskViewDir(
         ids[i],
-        { id: ids[i], title: `Multi ${i + 1}`, type: "standard", createdAt: ts, updatedAt: ts },
-        JSON.stringify({ role: "user", ts, content: `Message ${i + 1}` }) + "\n",
+        {
+          id: ids[i],
+          title: `Multi ${i + 1}`,
+          type: "standard",
+          createdAt: ts,
+          updatedAt: ts,
+        },
+        JSON.stringify({ role: "user", ts, content: `Message ${i + 1}` }) +
+          "\n",
       );
     }
 

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

@@ -94,7 +94,7 @@ describe("108-drop-balanced-economy-profile migration", () => {
           balanced: { ...managedBalanced },
           "balanced-economy": { ...managedEconomy },
         },
-        profileOrder: ["auto", "balanced", "balanced-economy"],
+        profileOrder: ["balanced", "balanced-economy"],
         activeProfile: "balanced",
       },
     });
@@ -104,7 +104,7 @@ describe("108-drop-balanced-economy-profile migration", () => {
     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"]);
+    expect(readLlm().profileOrder).toEqual(["balanced"]);
   });
 
   test("repoints activeProfile from balanced-economy to balanced", () => {
@@ -234,7 +234,7 @@ describe("108-drop-balanced-economy-profile migration", () => {
             source: "user",
           },
         },
-        profileOrder: ["auto", "balanced", "balanced-economy"],
+        profileOrder: ["balanced", "balanced-economy"],
         callSites: { memoryRouter: { profile: "balanced-economy" } },
         activeProfile: "balanced-economy",
         advisorProfile: "balanced-economy",
@@ -249,7 +249,7 @@ describe("108-drop-balanced-economy-profile migration", () => {
     writeConfig({
       llm: {
         profiles: { balanced: { ...managedBalanced } },
-        profileOrder: ["auto", "balanced", "balanced-economy"],
+        profileOrder: ["balanced", "balanced-economy"],
         callSites: { memoryRouter: { profile: "balanced-economy" } },
         activeProfile: "balanced-economy",
       },
@@ -257,7 +257,7 @@ describe("108-drop-balanced-economy-profile migration", () => {
     dropBalancedEconomyProfileMigration.run(workspaceDir);
 
     const llm = readLlm();
-    expect(llm.profileOrder).toEqual(["auto", "balanced"]);
+    expect(llm.profileOrder).toEqual(["balanced"]);
     expect(llm.activeProfile).toBe("balanced");
     expect(
       (llm.callSites as Record<string, Record<string, unknown>>).memoryRouter!
@@ -269,7 +269,7 @@ describe("108-drop-balanced-economy-profile migration", () => {
     writeConfig({
       llm: {
         profiles: { balanced: { ...managedBalanced } },
-        profileOrder: ["auto", "balanced"],
+        profileOrder: ["balanced"],
         activeProfile: "balanced",
       },
     });

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

@@ -0,0 +1,281 @@
+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 { swapQualityProfileToGlm52Migration } from "../workspace/migrations/109-swap-quality-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 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>>;
+}
+
+beforeEach(() => {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-109-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("109-swap-quality-profile-to-glm-5p2 migration", () => {
+  test("no-op when config.json does not exist", () => {
+    swapQualityProfileToGlm52Migration.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);
+    swapQualityProfileToGlm52Migration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("gracefully handles invalid JSON", () => {
+    writeFileSync(join(workspaceDir, "config.json"), "not-valid-json");
+    swapQualityProfileToGlm52Migration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      "not-valid-json",
+    );
+  });
+
+  test("swaps managed quality-optimized from Opus 4.8 to GLM 5.2", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            source: "managed",
+            provider: "anthropic",
+            provider_connection: "anthropic-managed",
+            model: "claude-opus-4-8",
+            label: "Quality",
+            advisorEnabled: false,
+          },
+        },
+      },
+    });
+    swapQualityProfileToGlm52Migration.run(workspaceDir);
+    const profile = readProfiles()["quality-optimized"]!;
+    expect(profile.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(profile.provider).toBe("fireworks");
+    expect(profile.provider_connection).toBe("fireworks-managed");
+    expect(profile.label).toBe("Quality");
+    // `advisorEnabled` is left as persisted — deleting it could reverse an
+    // explicit user preference (the old seeded default was also `false`).
+    expect(profile.advisorEnabled).toBe(false);
+  });
+
+  test("swaps OpenRouter-prefixed Opus model ids", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            source: "managed",
+            provider: "openrouter",
+            model: "anthropic/claude-opus-4.8",
+          },
+        },
+      },
+    });
+    swapQualityProfileToGlm52Migration.run(workspaceDir);
+    const profile = readProfiles()["quality-optimized"]!;
+    expect(profile.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(profile.provider).toBe("fireworks");
+    expect(profile.provider_connection).toBe("fireworks-managed");
+  });
+
+  test("swaps a source-less legacy managed quality-optimized", () => {
+    // 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: {
+          "quality-optimized": {
+            provider: "anthropic",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    });
+    swapQualityProfileToGlm52Migration.run(workspaceDir);
+    const profile = readProfiles()["quality-optimized"]!;
+    expect(profile.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(profile.provider).toBe("fireworks");
+  });
+
+  test("leaves a user-owned quality-optimized copy untouched", () => {
+    const original = {
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            source: "user",
+            provider: "anthropic",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    };
+    writeConfig(original);
+    swapQualityProfileToGlm52Migration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("leaves a user-customized managed model untouched", () => {
+    const original = {
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            source: "managed",
+            provider: "openai",
+            model: "gpt-5.4",
+          },
+        },
+      },
+    };
+    writeConfig(original);
+    swapQualityProfileToGlm52Migration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("preserves a user-toggled advisorEnabled override", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          "quality-optimized": {
+            source: "managed",
+            provider: "anthropic",
+            model: "claude-opus-4-8",
+            advisorEnabled: true,
+          },
+        },
+      },
+    });
+    swapQualityProfileToGlm52Migration.run(workspaceDir);
+    expect(readProfiles()["quality-optimized"]!.advisorEnabled).toBe(true);
+  });
+
+  test("repoints the default advisor from quality-optimized to frontier", () => {
+    writeConfig({
+      llm: {
+        advisorProfile: "quality-optimized",
+        profiles: {
+          "quality-optimized": {
+            source: "managed",
+            provider: "anthropic",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    });
+    swapQualityProfileToGlm52Migration.run(workspaceDir);
+    expect(readLlm().advisorProfile).toBe("frontier");
+  });
+
+  test("does not repoint the advisor when a user owns a frontier profile", () => {
+    writeConfig({
+      llm: {
+        advisorProfile: "quality-optimized",
+        profiles: {
+          "quality-optimized": {
+            source: "managed",
+            provider: "anthropic",
+            model: "claude-opus-4-8",
+          },
+          frontier: { source: "user", provider: "openai", model: "gpt-5.4" },
+        },
+      },
+    });
+    swapQualityProfileToGlm52Migration.run(workspaceDir);
+    // The seeder leaves the user's `frontier` in place rather than creating the
+    // managed Opus one, so the advisor stays on managed GLM 5.2 (quality).
+    expect(readLlm().advisorProfile).toBe("quality-optimized");
+  });
+
+  test("does not repoint the advisor when a source-less frontier exists", () => {
+    // Custom profiles from the settings UI are saved without a `source`.
+    writeConfig({
+      llm: {
+        advisorProfile: "quality-optimized",
+        profiles: {
+          "quality-optimized": {
+            source: "managed",
+            provider: "anthropic",
+            model: "claude-opus-4-8",
+          },
+          frontier: { provider: "openai", model: "gpt-5.4" },
+        },
+      },
+    });
+    swapQualityProfileToGlm52Migration.run(workspaceDir);
+    expect(readLlm().advisorProfile).toBe("quality-optimized");
+  });
+
+  test("leaves a custom advisor profile untouched", () => {
+    writeConfig({
+      llm: {
+        advisorProfile: "balanced",
+        profiles: {
+          "quality-optimized": {
+            source: "managed",
+            provider: "anthropic",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    });
+    swapQualityProfileToGlm52Migration.run(workspaceDir);
+    expect(readLlm().advisorProfile).toBe("balanced");
+  });
+
+  test("idempotency: no-op on already-swapped config (no writes)", () => {
+    writeConfig({
+      llm: {
+        advisorProfile: "frontier",
+        profiles: {
+          "quality-optimized": {
+            source: "managed",
+            provider: "fireworks",
+            provider_connection: "fireworks-managed",
+            model: "accounts/fireworks/models/glm-5p2",
+          },
+        },
+      },
+    });
+    const beforeContent = readFileSync(
+      join(workspaceDir, "config.json"),
+      "utf-8",
+    );
+    swapQualityProfileToGlm52Migration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      beforeContent,
+    );
+  });
+});

package/src/__tests__/workspace-migration-110-flip-balanced-profile-to-together.test.ts

@@ -0,0 +1,167 @@
+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 { flipBalancedProfileToTogetherMigration } from "../workspace/migrations/110-flip-balanced-profile-to-together.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-110-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("110-flip-balanced-profile-to-together migration", () => {
+  test("no-op when config.json does not exist", () => {
+    flipBalancedProfileToTogetherMigration.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);
+    flipBalancedProfileToTogetherMigration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("gracefully handles invalid JSON", () => {
+    writeFileSync(join(workspaceDir, "config.json"), "not-valid-json");
+    flipBalancedProfileToTogetherMigration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      "not-valid-json",
+    );
+  });
+
+  test("flips the managed balanced profile from Fireworks to Together", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            source: "managed",
+            provider: "fireworks",
+            provider_connection: "fireworks-managed",
+            model: "accounts/fireworks/models/minimax-m3",
+            label: "Balanced",
+          },
+        },
+      },
+    });
+    flipBalancedProfileToTogetherMigration.run(workspaceDir);
+    const profile = readProfiles().balanced!;
+    expect(profile.model).toBe("MiniMaxAI/MiniMax-M3");
+    expect(profile.provider).toBe("together");
+    expect(profile.provider_connection).toBe("together-managed");
+    expect(profile.label).toBe("Balanced");
+  });
+
+  test("flips 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 flipped.
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            provider: "fireworks",
+            model: "accounts/fireworks/models/minimax-m3",
+          },
+        },
+      },
+    });
+    flipBalancedProfileToTogetherMigration.run(workspaceDir);
+    const profile = readProfiles().balanced!;
+    expect(profile.model).toBe("MiniMaxAI/MiniMax-M3");
+    expect(profile.provider).toBe("together");
+    expect(profile.provider_connection).toBe("together-managed");
+  });
+
+  test("leaves a user-owned balanced profile untouched", () => {
+    const original = {
+      llm: {
+        profiles: {
+          balanced: {
+            source: "user",
+            provider: "fireworks",
+            model: "accounts/fireworks/models/minimax-m3",
+          },
+        },
+      },
+    };
+    writeConfig(original);
+    flipBalancedProfileToTogetherMigration.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);
+    flipBalancedProfileToTogetherMigration.run(workspaceDir);
+    expect(readConfig()).toEqual(original);
+  });
+
+  test("idempotency: no-op on already-flipped config (no writes)", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            source: "managed",
+            provider: "together",
+            provider_connection: "together-managed",
+            model: "MiniMaxAI/MiniMax-M3",
+          },
+        },
+      },
+    });
+    const beforeContent = readFileSync(
+      join(workspaceDir, "config.json"),
+      "utf-8",
+    );
+    flipBalancedProfileToTogetherMigration.run(workspaceDir);
+    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
+      beforeContent,
+    );
+  });
+});