@vellumai/assistant 0.11.3 → 0.11.4-staging.1

package/src/workspace/migrations/145-collapse-profile-bindings-to-entries.ts

@@ -0,0 +1,328 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+
+import { getLogger } from "../../util/logger.js";
+import type { WorkspaceMigration } from "./types.js";
+
+const log = getLogger("migrations/145-collapse-profile-bindings-to-entries");
+
+// Fold each profile's `provider_connection` into its `provider` as a
+// connection entry name. Under the entries model the provider field holds
+// the entry name and the row's own provider (its kind) drives dispatch, so
+// an explicit binding needs no second field.
+//
+// Rules per `llm.profiles.<key>`:
+// - Routing-identity providers ("vellum"/"chatgpt") carry no binding by
+//   definition: a stray `provider_connection` is deleted verbatim.
+// - A binding whose row EXISTS and whose kind AGREES with the profile's
+//   declared provider becomes the provider value (the entry name), and the
+//   binding field is deleted. Kind agreement, with the identity kinds
+//   mapped the way dispatch maps them: a row of the same provider, a
+//   "chatgpt" row for a declared "openai", or a "vellum" row for a declared
+//   managed-routable provider.
+// - A dangling binding (row deleted) or a kind-disagreeing binding keeps
+//   the declared provider and deletes only the binding, with a structured
+//   warn: dispatch's auto-resolution then behaves the way it always has
+//   for an unbound vendor profile, and a rewrite would either strand the
+//   profile on a nonexistent entry or silently change vendors.
+// - A binding equal to the declared provider (conventional shapes older
+//   migrations kept) is a plain delete: the bare vendor value already
+//   means the default entry of that kind.
+//
+// Call-site fragments and `llm.defaultProvider.connectionName` are NOT
+// touched: call-site overrides become model-only together with the
+// resolver's tweak blocks (one coherent change, later), and the default
+// provider keeps its closed vendor enum, so its binding needs its own
+// design before it can collapse.
+//
+// The identity mapping and managed-routable set are frozen snapshots
+// (migrations are self-contained): openai/anthropic/gemini/fireworks/
+// together as of 2026-08-10. A provider outside the snapshot takes the
+// conservative keep-provider path.
+
+const ROUTING_IDENTITIES = new Set(["vellum", "chatgpt"]);
+const MANAGED_ROUTABLE = new Set([
+  "openai",
+  "anthropic",
+  "gemini",
+  "fireworks",
+  "together",
+]);
+
+// A binding literally named "vellum" or "chatgpt" folds into the ROUTING
+// IDENTITY value, whose model the read-path schema validates (an unroutable
+// pair strips the whole profile on read). Folding is therefore gated on the
+// model being servable by that identity, judged against frozen snapshots of
+// the routing tables as of 2026-08-10; a model outside the snapshot leaves
+// the profile untouched (dispatch keeps honoring the legacy binding).
+const VELLUM_ROUTABLE_MODELS = new Set([
+  "claude-fable-5",
+  "claude-opus-5",
+  "claude-opus-4-8",
+  "claude-opus-4-7",
+  "claude-opus-4-6",
+  "claude-sonnet-5",
+  "claude-sonnet-4-6",
+  "claude-sonnet-4-5-20250929",
+  "claude-opus-4-5-20251101",
+  "claude-haiku-4-5-20251001",
+  "gpt-5.6-sol",
+  "gpt-5.6-terra",
+  "gpt-5.6-luna",
+  "gpt-5.5",
+  "gpt-5.5-pro",
+  "gpt-5.4",
+  "gpt-5.2",
+  "gpt-5.4-mini",
+  "gpt-5.4-nano",
+  "gemini-3.6-flash",
+  "gemini-3.5-flash",
+  "gemini-3.5-flash-lite",
+  "gemini-3.1-pro-preview",
+  "gemini-3.1-pro-preview-customtools",
+  "gemini-3-flash-preview",
+  "gemini-3.1-flash-lite-preview",
+  "gemini-3.1-flash-lite",
+  "gemini-2.5-flash",
+  "gemini-2.5-flash-lite",
+  "gemini-2.5-pro",
+  "accounts/fireworks/models/kimi-k3",
+  "accounts/fireworks/models/kimi-k2p6",
+  "accounts/fireworks/models/glm-5p2",
+  "accounts/fireworks/models/minimax-m3",
+  "accounts/fireworks/models/minimax-m2p7",
+  "accounts/fireworks/models/deepseek-v4-pro",
+  "accounts/fireworks/models/deepseek-v4-flash",
+  "MiniMaxAI/MiniMax-M3",
+]);
+const CODEX_MODELS = new Set([
+  "gpt-5.6-sol",
+  "gpt-5.6-terra",
+  "gpt-5.6-luna",
+  "gpt-5.5",
+  "gpt-5.4",
+  "gpt-5.4-mini",
+]);
+
+function identitySafeModel(identity: string, model: unknown): boolean {
+  if (typeof model !== "string") {
+    return false;
+  }
+  return identity === "vellum"
+    ? VELLUM_ROUTABLE_MODELS.has(model)
+    : CODEX_MODELS.has(model);
+}
+
+export const collapseProfileBindingsToEntriesMigration: WorkspaceMigration = {
+  id: "145-collapse-profile-bindings-to-entries",
+  description:
+    "Fold llm.profiles.*.provider_connection into provider as connection entry names",
+  retryFailedCheckpoint: true,
+  run(workspaceDir: string): void {
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) {
+      return;
+    }
+
+    let config: Record<string, unknown>;
+    try {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return;
+      }
+      config = raw as Record<string, unknown>;
+    } catch {
+      return;
+    }
+
+    const llm = asObject(config.llm);
+    const profiles = llm === null ? null : asObject(llm.profiles);
+    if (profiles === null) {
+      return;
+    }
+
+    const bindings = Object.values(profiles).some((value) => {
+      const entry = asObject(value);
+      return (
+        entry !== null &&
+        typeof entry.provider_connection === "string" &&
+        entry.provider_connection.length > 0
+      );
+    });
+    if (!bindings) {
+      return;
+    }
+
+    // Bindings exist, so the rewrite needs the rows. An ABSENT DB file is a
+    // real state (a config restored into a fresh workspace has no rows, so
+    // every binding is genuinely dangling); an unreadable or unqueryable DB
+    // must instead fail the run (retried next boot) rather than checkpoint
+    // a pass that would take the destructive dangling path for every
+    // binding.
+    const rows = readConnectionRows(workspaceDir);
+    if (rows === null) {
+      throw new Error(
+        "provider_connections is not readable; retrying the binding collapse on the next run",
+      );
+    }
+
+    let changed = false;
+    for (const [key, value] of Object.entries(profiles)) {
+      const entry = asObject(value);
+      if (entry === null) {
+        continue;
+      }
+      const binding = entry.provider_connection;
+      if (typeof binding !== "string" || binding.length === 0) {
+        continue;
+      }
+      const provider =
+        typeof entry.provider === "string" ? entry.provider : undefined;
+
+      if (provider !== undefined && ROUTING_IDENTITIES.has(provider)) {
+        delete entry.provider_connection;
+        changed = true;
+        log.info(
+          { profile: key, provider, binding },
+          "Deleted stray binding on a routing-identity profile",
+        );
+        continue;
+      }
+
+      if (binding === provider) {
+        // A row named exactly like its vendor was an explicit pin under the
+        // old create route; with several rows of that kind, the bare vendor
+        // would auto-resolve differently, so the pin stays until the entry
+        // picker can express it. Without such a row the field is a plain
+        // conventional shape and the bare vendor already means the default.
+        if (rows.has(binding)) {
+          log.info(
+            { profile: key, provider },
+            "Kept self-named binding (an explicit pin among possible siblings)",
+          );
+          continue;
+        }
+        delete entry.provider_connection;
+        changed = true;
+        log.info(
+          { profile: key, provider },
+          "Deleted self-referential binding (bare vendor means the default entry)",
+        );
+        continue;
+      }
+
+      if (ROUTING_IDENTITIES.has(binding)) {
+        // Folding writes the identity VALUE itself; gate on the model the
+        // identity can serve, or the read-path schema would strip the
+        // profile. An unservable model leaves the profile untouched.
+        if (identitySafeModel(binding, entry.model)) {
+          entry.provider = binding;
+          delete entry.provider_connection;
+          changed = true;
+          log.info(
+            { profile: key, previousProvider: provider, identity: binding },
+            "Folded canonical binding into the routing identity",
+          );
+        } else {
+          log.warn(
+            { profile: key, provider, binding, reason: "model_not_servable" },
+            "Left canonical binding in place; the identity cannot serve this model",
+          );
+        }
+        continue;
+      }
+
+      const rowKind = rows.get(binding);
+      if (rowKind === undefined) {
+        delete entry.provider_connection;
+        changed = true;
+        log.warn(
+          { profile: key, provider, binding, reason: "row_missing" },
+          "Deleted dangling binding; profile keeps its declared provider",
+        );
+        continue;
+      }
+
+      if (!kindAgrees(rowKind, provider)) {
+        delete entry.provider_connection;
+        changed = true;
+        log.warn(
+          { profile: key, provider, binding, rowKind, reason: "kind_mismatch" },
+          "Deleted kind-disagreeing binding; profile keeps its declared provider",
+        );
+        continue;
+      }
+
+      entry.provider = binding;
+      delete entry.provider_connection;
+      changed = true;
+      log.info(
+        { profile: key, previousProvider: provider, entry: binding },
+        "Folded profile binding into provider as an entry name",
+      );
+    }
+
+    if (changed) {
+      writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    }
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only.
+  },
+};
+
+function asObject(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+/**
+ * Whether a row of `rowKind` can serve a profile declaring `provider`,
+ * mirroring dispatch's identity mapping. An undeclared provider agrees with
+ * any row: the entry alone defines the route.
+ */
+function kindAgrees(rowKind: string, provider: string | undefined): boolean {
+  if (provider === undefined) {
+    return true;
+  }
+  if (rowKind === provider) {
+    return true;
+  }
+  if (rowKind === "chatgpt") {
+    return provider === "openai";
+  }
+  if (rowKind === "vellum") {
+    return MANAGED_ROUTABLE.has(provider);
+  }
+  return false;
+}
+
+/**
+ * Connection name -> provider kind, or null when the DB or table is not
+ * readable. The caller fails the run on null: bindings must be judged
+ * against real rows, never guessed.
+ */
+function readConnectionRows(workspaceDir: string): Map<string, string> | null {
+  const dbPath = join(workspaceDir, "data", "db", "assistant.db");
+  if (!existsSync(dbPath)) {
+    return new Map();
+  }
+  let db: Database;
+  try {
+    db = new Database(dbPath);
+  } catch {
+    return null;
+  }
+  try {
+    const rows = db
+      .query(`SELECT name, provider FROM provider_connections`)
+      .all() as Array<{ name: string; provider: string }>;
+    return new Map(rows.map((r) => [r.name, r.provider]));
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}

package/src/workspace/migrations/__tests__/141-stt-english-default-to-multilingual.test.ts

@@ -10,7 +10,6 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { sttEnglishDefaultToMultilingualMigration as MIG } from "../141-stt-english-default-to-multilingual.js";
-import { WORKSPACE_MIGRATIONS } from "../registry.js";
 
 let workspaceDir: string;
 let configPath: string;
@@ -37,15 +36,6 @@ afterEach(() => {
 });
 
 describe("141-stt-english-default-to-multilingual", () => {
-  test("is registered last, so it defines the registry ceiling", () => {
-    // getLastWorkspaceMigrationId() reads the final entry, and the runner
-    // executes the array in order, so a new migration belongs at the end.
-    expect(MIG.id).toBe("141-stt-english-default-to-multilingual");
-    expect(WORKSPACE_MIGRATIONS[WORKSPACE_MIGRATIONS.length - 1]?.id).toBe(
-      MIG.id,
-    );
-  });
-
   test("moves an accepted English default to multilingual on deepgram", () => {
     write({ provider: "deepgram", language: "en" });
     MIG.run(workspaceDir);

package/src/workspace/migrations/registry.ts

@@ -139,6 +139,10 @@ import { backfillHomeFeedTitlesMigration } from "./138-backfill-home-feed-titles
 import { clearRenamedCostProfileLabelMigration } from "./139-clear-renamed-cost-profile-label.js";
 import { repairSeedPinnedMemoryV3LiveMigration } from "./140-repair-seed-pinned-memory-v3-live.js";
 import { sttEnglishDefaultToMultilingualMigration } from "./141-stt-english-default-to-multilingual.js";
+import { consolidateVoiceFrontDoorMigration } from "./142-consolidate-voice-front-door.js";
+import { repairDeprecatedCodexModelIdMigration } from "./143-repair-deprecated-codex-model-id.js";
+import { convertStrandedSubscriptionOpenaiProfilesMigration } from "./144-convert-stranded-subscription-openai-profiles.js";
+import { collapseProfileBindingsToEntriesMigration } from "./145-collapse-profile-bindings-to-entries.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -293,4 +297,8 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   clearRenamedCostProfileLabelMigration,
   repairSeedPinnedMemoryV3LiveMigration,
   sttEnglishDefaultToMultilingualMigration,
+  consolidateVoiceFrontDoorMigration,
+  repairDeprecatedCodexModelIdMigration,
+  convertStrandedSubscriptionOpenaiProfilesMigration,
+  collapseProfileBindingsToEntriesMigration,
 ];

package/src/workspace/provider-commit-message-generator.ts

@@ -162,13 +162,15 @@ class ProviderCommitMessageGenerator {
     const providerName = resolved.configuredProviderName;
 
     // Step 2b: API key preflight for the configured provider. Skipped for
-    // keyless providers and for routing identities, which authenticate
-    // through their connection row (platform token / ChatGPT OAuth) — no
-    // provider API key exists for them, and resolution already verified the
-    // connection credential.
+    // keyless providers, for routing identities, and for entry-routed
+    // results, since all three authenticate through their connection row
+    // (platform token / ChatGPT OAuth / the row's own credential slot), so
+    // no generic per-vendor key needs to exist, and resolution already
+    // verified the connection credential.
     if (
       !KEYLESS_PROVIDERS.has(providerName) &&
-      !ROUTING_IDENTITY_PROVIDERS.has(providerName)
+      !ROUTING_IDENTITY_PROVIDERS.has(providerName) &&
+      !resolved.entryRouted
     ) {
       const providerApiKey = await getProviderKeyAsync(providerName);
       if (!providerApiKey) {