@vellumai/assistant 0.11.3 → 0.11.4-staging.2

package/src/__tests__/workspace-migration-145-collapse-profile-bindings-to-entries.test.ts

@@ -0,0 +1,325 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { collapseProfileBindingsToEntriesMigration } from "../workspace/migrations/145-collapse-profile-bindings-to-entries.js";
+import { assertNotLiveDb } from "./assert-not-live-db.js";
+
+let workspaceDir: string;
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readProfiles(): Record<string, Record<string, unknown>> {
+  const raw = JSON.parse(
+    readFileSync(join(workspaceDir, "config.json"), "utf-8"),
+  ) as { llm?: { profiles?: Record<string, Record<string, unknown>> } };
+  return raw.llm?.profiles ?? {};
+}
+
+function seedRows(rows: Array<{ name: string; provider: string }>): void {
+  mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+  const db = new Database(join(workspaceDir, "data", "db", "assistant.db"));
+  db.run(`CREATE TABLE IF NOT EXISTS provider_connections (
+    name TEXT PRIMARY KEY,
+    provider TEXT NOT NULL,
+    auth TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  )`);
+  for (const row of rows) {
+    db.query(
+      `INSERT INTO provider_connections (name, provider, auth, created_at, updated_at) VALUES (?, ?, '{"type":"api_key"}', 1, 1)`,
+    ).run(row.name, row.provider);
+  }
+  db.close();
+}
+
+function run(): void {
+  collapseProfileBindingsToEntriesMigration.run(workspaceDir);
+}
+
+beforeEach(() => {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-145-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    assertNotLiveDb(workspaceDir);
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("145-collapse-profile-bindings-to-entries", () => {
+  test("folds a kind-agreeing binding into provider as the entry name", () => {
+    seedRows([{ name: "anthropic-work", provider: "anthropic" }]);
+    writeConfig({
+      llm: {
+        profiles: {
+          work: {
+            provider: "anthropic",
+            provider_connection: "anthropic-work",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    });
+
+    run();
+
+    const work = readProfiles().work;
+    expect(work.provider).toBe("anthropic-work");
+    expect(work).not.toHaveProperty("provider_connection");
+    expect(work.model).toBe("claude-opus-4-8");
+  });
+
+  test("maps identity kinds when judging agreement", () => {
+    seedRows([
+      { name: "team-managed", provider: "vellum" },
+      { name: "chatgpt-subscription", provider: "chatgpt" },
+    ]);
+    writeConfig({
+      llm: {
+        profiles: {
+          managed: {
+            provider: "anthropic",
+            provider_connection: "team-managed",
+            model: "claude-opus-4-8",
+          },
+          codex: {
+            provider: "openai",
+            provider_connection: "chatgpt-subscription",
+            model: "gpt-5.5",
+          },
+        },
+      },
+    });
+
+    run();
+
+    expect(readProfiles().managed.provider).toBe("team-managed");
+    expect(readProfiles().codex.provider).toBe("chatgpt-subscription");
+  });
+
+  test("keeps the vendor and drops a dangling binding with a warn", () => {
+    seedRows([]);
+    writeConfig({
+      llm: {
+        profiles: {
+          stale: {
+            provider: "anthropic",
+            provider_connection: "deleted-row",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    });
+
+    run();
+
+    const stale = readProfiles().stale;
+    expect(stale.provider).toBe("anthropic");
+    expect(stale).not.toHaveProperty("provider_connection");
+  });
+
+  test("keeps the vendor and drops a kind-disagreeing binding", () => {
+    seedRows([{ name: "ollama-local", provider: "ollama" }]);
+    writeConfig({
+      llm: {
+        profiles: {
+          conflicted: {
+            provider: "anthropic",
+            provider_connection: "ollama-local",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    });
+
+    run();
+
+    const conflicted = readProfiles().conflicted;
+    expect(conflicted.provider).toBe("anthropic");
+    expect(conflicted).not.toHaveProperty("provider_connection");
+  });
+
+  test("strips a stray binding from a routing-identity profile", () => {
+    seedRows([{ name: "vellum", provider: "vellum" }]);
+    writeConfig({
+      llm: {
+        profiles: {
+          managed: {
+            provider: "vellum",
+            provider_connection: "vellum",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    });
+
+    run();
+
+    const managed = readProfiles().managed;
+    expect(managed.provider).toBe("vellum");
+    expect(managed).not.toHaveProperty("provider_connection");
+  });
+
+  test("deletes a self-referential binding when no row claims that name", () => {
+    seedRows([{ name: "anthropic-work", provider: "anthropic" }]);
+    writeConfig({
+      llm: {
+        profiles: {
+          plain: {
+            provider: "anthropic",
+            provider_connection: "anthropic",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    });
+
+    run();
+
+    expect(readProfiles().plain.provider).toBe("anthropic");
+    expect(readProfiles().plain).not.toHaveProperty("provider_connection");
+  });
+
+  test("an absent DB file means genuinely dangling bindings (restored config)", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          bound: {
+            provider: "anthropic",
+            provider_connection: "anthropic-work",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    });
+    // No DB at all: a config restored into a fresh workspace has no rows.
+
+    run();
+
+    const bound = readProfiles().bound;
+    expect(bound.provider).toBe("anthropic");
+    expect(bound).not.toHaveProperty("provider_connection");
+  });
+
+  test("throws (for retry) when bindings exist but the DB is unqueryable", () => {
+    writeConfig({
+      llm: {
+        profiles: {
+          bound: {
+            provider: "anthropic",
+            provider_connection: "anthropic-work",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    });
+    // DB file exists but carries no provider_connections table.
+    mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+    new Database(join(workspaceDir, "data", "db", "assistant.db")).close();
+
+    expect(() => run()).toThrow(/not readable/);
+    // Config untouched: no destructive guess was made.
+    expect(readProfiles().bound.provider_connection).toBe("anthropic-work");
+    expect(
+      collapseProfileBindingsToEntriesMigration.retryFailedCheckpoint,
+    ).toBe(true);
+  });
+
+  test("folds a canonical vellum binding only for identity-servable models", () => {
+    seedRows([{ name: "vellum", provider: "vellum" }]);
+    writeConfig({
+      llm: {
+        profiles: {
+          routable: {
+            provider: "anthropic",
+            provider_connection: "vellum",
+            model: "claude-opus-4-8",
+          },
+          stale: {
+            provider: "anthropic",
+            provider_connection: "vellum",
+            model: "claude-ancient-1",
+          },
+        },
+      },
+    });
+
+    run();
+
+    const routable = readProfiles().routable;
+    expect(routable.provider).toBe("vellum");
+    expect(routable).not.toHaveProperty("provider_connection");
+    // An unservable model would be stripped by the read-path schema if
+    // folded to the identity; the profile stays untouched instead.
+    const stale = readProfiles().stale;
+    expect(stale.provider).toBe("anthropic");
+    expect(stale.provider_connection).toBe("vellum");
+  });
+
+  test("keeps a self-named binding when a row by that name exists", () => {
+    seedRows([
+      { name: "anthropic", provider: "anthropic" },
+      { name: "anthropic-2", provider: "anthropic" },
+    ]);
+    writeConfig({
+      llm: {
+        profiles: {
+          pinned: {
+            provider: "anthropic",
+            provider_connection: "anthropic",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    });
+
+    run();
+
+    // The explicit pin survives: with sibling rows, the bare vendor would
+    // auto-resolve differently.
+    expect(readProfiles().pinned.provider_connection).toBe("anthropic");
+  });
+
+  test("no-ops without bindings and is idempotent", () => {
+    seedRows([{ name: "anthropic-work", provider: "anthropic" }]);
+    writeConfig({
+      llm: {
+        profiles: {
+          work: {
+            provider: "anthropic",
+            provider_connection: "anthropic-work",
+            model: "claude-opus-4-8",
+          },
+          unbound: { provider: "vellum", model: "claude-opus-4-8" },
+        },
+      },
+    });
+
+    run();
+    const afterFirst = readProfiles();
+    run();
+
+    expect(readProfiles()).toEqual(afterFirst);
+    expect(afterFirst.unbound.provider).toBe("vellum");
+  });
+});

package/src/__tests__/workspace-migration-146-repair-retired-fireworks-deepseek-flash-model-id.test.ts

@@ -0,0 +1,235 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { repairRetiredFireworksDeepseekFlashModelIdMigration } from "../workspace/migrations/146-repair-retired-fireworks-deepseek-flash-model-id.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+import { assertNotLiveDb } from "./assert-not-live-db.js";
+
+const STALE = "accounts/fireworks/models/deepseek-v4-flash";
+const REPLACEMENT = "accounts/fireworks/models/deepseek-v4-flash-0731";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-146-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 seedRows(rows: Array<{ name: string; provider: string }>): void {
+  mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+  const db = new Database(join(workspaceDir, "data", "db", "assistant.db"));
+  db.run(`CREATE TABLE IF NOT EXISTS provider_connections (
+    name TEXT PRIMARY KEY,
+    provider TEXT NOT NULL,
+    auth TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  )`);
+  for (const row of rows) {
+    db.query(
+      `INSERT INTO provider_connections (name, provider, auth, created_at, updated_at) VALUES (?, ?, '{"type":"api_key"}', 1, 1)`,
+    ).run(row.name, row.provider);
+  }
+  db.close();
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    assertNotLiveDb(workspaceDir);
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("146-repair-retired-fireworks-deepseek-flash-model-id migration", () => {
+  test("has correct migration id and is registered", () => {
+    expect(repairRetiredFireworksDeepseekFlashModelIdMigration.id).toBe(
+      "146-repair-retired-fireworks-deepseek-flash-model-id",
+    );
+    expect(WORKSPACE_MIGRATIONS.map((m) => m.id)).toContain(
+      "146-repair-retired-fireworks-deepseek-flash-model-id",
+    );
+  });
+
+  test("repairs the stale ID in default, call sites, and profiles", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        callSites: {
+          recall: { model: STALE, maxTokens: 4096 },
+          heartbeat: { model: `${STALE}-tuned` },
+          malformed: STALE,
+        },
+        profiles: {
+          "cost-optimized": { provider: "vellum", model: STALE },
+          legacy: { model: STALE },
+        },
+      },
+    });
+
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.default.model).toBe(REPLACEMENT);
+    expect(llm.callSites.recall.model).toBe(REPLACEMENT);
+    expect(llm.callSites.recall.maxTokens).toBe(4096);
+    // Non-exact matches and malformed leaves are untouched. The dated
+    // replacement itself extends the stale ID, so the exact match must not
+    // fire on already-repaired leaves.
+    expect(llm.callSites.heartbeat.model).toBe(`${STALE}-tuned`);
+    expect(llm.callSites.malformed).toBe(STALE);
+    // Managed profiles stamped provider "vellum" carry Fireworks model IDs.
+    expect(llm.profiles["cost-optimized"].model).toBe(REPLACEMENT);
+    expect(llm.profiles.legacy.model).toBe(REPLACEMENT);
+  });
+
+  test("repairs entry-bound fragments whose row kind is fireworks or vellum", () => {
+    seedRows([
+      { name: "my-fireworks", provider: "fireworks" },
+      { name: "managed-alt", provider: "vellum" },
+    ]);
+    writeConfig({
+      llm: {
+        profiles: {
+          bound: { provider: "my-fireworks", model: STALE },
+          managed: { provider: "managed-alt", model: STALE },
+        },
+      },
+    });
+
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.profiles.bound.model).toBe(REPLACEMENT);
+    expect(llm.profiles.managed.model).toBe(REPLACEMENT);
+  });
+
+  test("leaves fragments with an explicit other provider untouched", () => {
+    seedRows([{ name: "byo-compat", provider: "openai-compatible" }]);
+    writeConfig({
+      llm: {
+        default: { provider: "openai-compatible", model: STALE },
+        profiles: {
+          byo: { provider: "openai-compatible", model: STALE },
+          // Entry-bound profile whose row kind is not repairable.
+          compatBound: { provider: "byo-compat", model: STALE },
+          // Entry name with no row: dangling, so nothing proves it is a
+          // fireworks-kind route.
+          dangling: { provider: "ghost", model: STALE },
+        },
+      },
+    });
+
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.default.model).toBe(STALE);
+    expect(llm.profiles.byo.model).toBe(STALE);
+    expect(llm.profiles.compatBound.model).toBe(STALE);
+    expect(llm.profiles.dangling.model).toBe(STALE);
+  });
+
+  test("leaves entry-name providers untouched when no DB file exists", () => {
+    writeConfig({
+      llm: {
+        profiles: { bound: { provider: "my-fireworks", model: STALE } },
+      },
+    });
+
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.profiles.bound.model).toBe(STALE);
+  });
+
+  test("throws when an entry-name provider needs rows and the DB is unreadable", () => {
+    // A DB file without the provider_connections table is unqueryable, so
+    // the run must fail (and retry later) instead of skipping the profile.
+    mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+    writeFileSync(join(workspaceDir, "data", "db", "assistant.db"), "");
+    writeConfig({
+      llm: {
+        profiles: { bound: { provider: "my-fireworks", model: STALE } },
+      },
+    });
+
+    expect(() =>
+      repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir),
+    ).toThrow();
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.profiles.bound.model).toBe(STALE);
+
+    // Vendor and absent providers never need the rows, so the same broken
+    // DB does not block their repair.
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        profiles: { legacy: { model: STALE } },
+      },
+    });
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+    const repaired = readConfig().llm as Record<string, any>;
+    expect(repaired.default.model).toBe(REPLACEMENT);
+    expect(repaired.profiles.legacy.model).toBe(REPLACEMENT);
+  });
+
+  test("is idempotent and a no-op without the stale ID", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        profiles: { fine: { provider: "fireworks", model: REPLACEMENT } },
+      },
+    });
+
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+    const first = readConfig();
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+    expect(readConfig()).toEqual(first);
+
+    const llm = first.llm as Record<string, any>;
+    expect(llm.default.model).toBe(REPLACEMENT);
+    expect(llm.profiles.fine.model).toBe(REPLACEMENT);
+  });
+
+  test("handles missing config, missing llm block, and invalid JSON", () => {
+    // No config.json at all.
+    expect(() =>
+      repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    writeConfig({ theme: "dark" });
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+    expect(readConfig()).toEqual({ theme: "dark" });
+
+    writeFileSync(join(workspaceDir, "config.json"), "{not json");
+    expect(() =>
+      repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir),
+    ).not.toThrow();
+  });
+});

package/src/acp/__tests__/acp-claude-oauth.test.ts

@@ -59,8 +59,11 @@ beforeEach(() => {
 
 describe("CLAUDE_OAUTH_CONFIG", () => {
   test("matches the verified endpoints, client id, and scope", () => {
+    // The single literal pin for the endpoint. Every other test asserts
+    // against CLAUDE_OAUTH_CONFIG.authorizeUrl, so an endpoint change edits
+    // exactly this one value.
     expect(CLAUDE_OAUTH_CONFIG.authorizeUrl).toBe(
-      "https://claude.ai/oauth/authorize",
+      "https://claude.com/cai/oauth/authorize",
     );
     expect(CLAUDE_OAUTH_CONFIG.tokenExchangeUrl).toBe(
       "https://platform.claude.com/v1/oauth/token",
@@ -92,8 +95,10 @@ describe("buildClaudeAuthorizeUrl", () => {
     });
 
     const parsed = new URL(url);
+    // The property under test is that the builder uses the configured
+    // endpoint; the value itself is guarded by the literal pin above.
     expect(`${parsed.origin}${parsed.pathname}`).toBe(
-      "https://claude.ai/oauth/authorize",
+      CLAUDE_OAUTH_CONFIG.authorizeUrl,
     );
 
     const params = parsed.searchParams;
@@ -106,6 +111,9 @@ describe("buildClaudeAuthorizeUrl", () => {
     expect(params.get("state")).toBe("state-abc");
     expect(params.get("code_challenge")).toBe("challenge-123");
     expect(params.get("code_challenge_method")).toBe("S256");
+    // The manual flow's defining param: tells Claude to render `code#state`
+    // on the callback page. Claude rejects a manual-redirect grant without it.
+    expect(params.get("code")).toBe("true");
   });
 
   test("works with the manual redirect URI too", () => {