@vellumai/assistant 0.11.6 → 0.11.7-staging.1

package/src/workspace/migrations/149-repoint-backup-profile-selections.ts

@@ -0,0 +1,204 @@
+/**
+ * Workspace migration `149-repoint-backup-profile-selections`.
+ *
+ * Managed backup profiles are internal failover routes. Earlier builds let
+ * users select those names directly, so existing workspaces can retain them
+ * in active, advisor, call-site, mix, conversation, or schedule references.
+ * Repoint those direct selections to their corresponding primary profile
+ * before the user-facing catalog hides the backups. Automatic fallback
+ * metadata is preserved: a primary's `fallbackProfile` still names its
+ * internal backup route.
+ */
+
+import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+
+import { FALLBACK_PROFILE_BY_KEY } from "../../config/default-profile-names.js";
+import { getLogger } from "../../util/logger.js";
+import type { WorkspaceMigration } from "./types.js";
+
+const log = getLogger(
+  "workspace-migration-149-repoint-backup-profile-selections",
+);
+
+/** Mapping of every managed backup to its direct-selectable primary. */
+const BACKUP_TO_PRIMARY: Record<string, string> = Object.fromEntries(
+  Object.entries(FALLBACK_PROFILE_BY_KEY).map(([primary, backup]) => [
+    backup,
+    primary,
+  ]),
+);
+
+const PROFILE_PIN_TABLES = ["conversations", "cron_jobs"] as const;
+const DB_ATTEMPTS = 4;
+const DB_RETRY_BASE_DELAY_MS = 50;
+
+export const repointBackupProfileSelectionsMigration: WorkspaceMigration = {
+  id: "149-repoint-backup-profile-selections",
+  description:
+    "Repoint direct selections of managed backup profiles to their primaries",
+  retryFailedCheckpoint: true,
+
+  async run(workspaceDir: string): Promise<void> {
+    const configPath = join(workspaceDir, "config.json");
+    const config = readConfig(configPath);
+    const llm = config === null ? null : asObject(config.llm);
+    const configChanged = llm !== null && rewriteConfigReferences(llm);
+
+    // Rewrite database pins before config.json. If the database cannot be
+    // updated, leaving config untouched lets the next boot retry the same
+    // migration without stranding a direct selection.
+    await rewriteDbReferences(workspaceDir);
+
+    if (config !== null && configChanged) {
+      const tempPath = `${configPath}.tmp`;
+      writeFileSync(tempPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      renameSync(tempPath, configPath);
+      log.info("Repointed direct backup-profile selections to primaries");
+    }
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: restoring a backup selection would make it unreachable
+    // from the user-facing profile catalog.
+  },
+};
+
+function readConfig(path: string): Record<string, unknown> | null {
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(path, "utf-8"));
+    return isPlainObject(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Rewrite config references that represent direct user profile choices. */
+function rewriteConfigReferences(llm: Record<string, unknown>): boolean {
+  let changed = false;
+
+  for (const field of ["activeProfile", "advisorProfile"] as const) {
+    const current = llm[field];
+    const replacement = remapProfileName(current);
+    if (replacement !== current) {
+      llm[field] = replacement;
+      changed = true;
+    }
+  }
+
+  const callSites = asObject(llm.callSites);
+  if (callSites !== null) {
+    for (const value of Object.values(callSites)) {
+      const site = asObject(value);
+      if (site === null) {
+        continue;
+      }
+      const replacement = remapProfileName(site.profile);
+      if (replacement !== site.profile) {
+        site.profile = replacement;
+        changed = true;
+      }
+    }
+  }
+
+  const profiles = asObject(llm.profiles);
+  if (profiles === null) {
+    return changed;
+  }
+  for (const value of Object.values(profiles)) {
+    const entry = asObject(value);
+    if (entry === null || !Array.isArray(entry.mix)) {
+      continue;
+    }
+    for (const armValue of entry.mix as unknown[]) {
+      const arm = asObject(armValue);
+      if (arm === null) {
+        continue;
+      }
+      const replacement = remapProfileName(arm.profile);
+      if (replacement !== arm.profile) {
+        arm.profile = replacement;
+        changed = true;
+      }
+    }
+  }
+
+  return changed;
+}
+
+function remapProfileName(value: unknown): unknown {
+  if (typeof value !== "string") {
+    return value;
+  }
+  return BACKUP_TO_PRIMARY[value] ?? value;
+}
+
+/** Rewrite conversation and schedule pins, retrying transient DB contention. */
+async function rewriteDbReferences(workspaceDir: string): Promise<void> {
+  const path = join(workspaceDir, "data", "db", "assistant.db");
+  if (!existsSync(path)) {
+    return;
+  }
+
+  await withDbRetry(() => {
+    const db = new Database(path);
+    try {
+      for (const table of PROFILE_PIN_TABLES) {
+        if (!tableHasColumn(db, table, "inference_profile")) {
+          continue;
+        }
+        for (const [backup, primary] of Object.entries(BACKUP_TO_PRIMARY)) {
+          db.query(
+            `UPDATE ${table} SET inference_profile = ? WHERE inference_profile = ?`,
+          ).run(primary, backup);
+        }
+      }
+    } finally {
+      db.close();
+    }
+  });
+}
+
+function tableHasColumn(
+  db: Database,
+  table: (typeof PROFILE_PIN_TABLES)[number],
+  column: string,
+): boolean {
+  const rows = db.query(`PRAGMA table_info(${table})`).all() as Array<{
+    name?: unknown;
+  }>;
+  return rows.some((row) => row.name === column);
+}
+
+async function withDbRetry(attempt: () => void): Promise<void> {
+  for (let index = 0; ; index += 1) {
+    try {
+      attempt();
+      return;
+    } catch (err) {
+      if (index >= DB_ATTEMPTS - 1) {
+        throw new Error(
+          `Could not repoint backup-profile selections after ${DB_ATTEMPTS} attempts`,
+          { cause: err },
+        );
+      }
+      log.warn(
+        { err, attempt: index },
+        "Could not repoint backup-profile selections; retrying",
+      );
+      await Bun.sleep(DB_RETRY_BASE_DELAY_MS * 2 ** index);
+    }
+  }
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function asObject(value: unknown): Record<string, unknown> | null {
+  return isPlainObject(value) ? value : null;
+}

package/src/workspace/migrations/150-stt-flux-provider-to-model-family.ts

@@ -0,0 +1,139 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Fold the Flux provider ids back into their parent plus a model family.
+ *
+ * Flux shipped as its own `services.stt.provider` value, which made a model
+ * choice look like a provider choice. That cost an entry in the provider
+ * enum, a row in every settings picker, and a place in each
+ * managed-versus-BYOK predicate for a backend that shares its parent's
+ * credential and account. Model families now live where the rest of a
+ * provider's settings do:
+ *
+ *   provider: "deepgram-flux"  ->  provider: "deepgram"
+ *                                  providers.deepgram.model: "flux"
+ *
+ * The same rewrite applies to the managed pair. Any other provider value is
+ * left untouched, and an existing `providers.<parent>` entry keeps every key
+ * it already had.
+ *
+ * The same pass drops any `providers.<id>.model` a known provider cannot
+ * serve. That key was free-form before this change and read by nothing, so
+ * existing values carry no meaning, but the schema validates it now: leaving
+ * a stale one behind would fail the parse and drop the workspace onto the
+ * loader's salvage path, which resets the entire `services` section and takes
+ * unrelated STT and TTS settings with it.
+ *
+ * Idempotent: a config already naming a parent provider has nothing to
+ * rewrite, and a model key already naming a family it can serve is left
+ * alone.
+ */
+const FLUX_PROVIDER_PARENTS: Record<string, string> = {
+  "deepgram-flux": "deepgram",
+  "vellum-flux": "vellum",
+};
+
+/**
+ * The model families each provider served when this migration was written,
+ * inlined rather than read from the provider catalog.
+ *
+ * A published migration has to behave identically every time it runs, and it
+ * reruns on newly initialized workspaces and after an interrupted checkpoint.
+ * Reading the live catalog would let a later change to it alter what this
+ * migration deletes from configs it has already seen.
+ */
+const KNOWN_MODEL_FAMILIES: Record<string, readonly string[]> = {
+  deepgram: ["nova-3", "flux"],
+  vellum: ["nova-3", "flux"],
+};
+
+export const sttFluxProviderToModelFamilyMigration: WorkspaceMigration = {
+  id: "150-stt-flux-provider-to-model-family",
+  description:
+    "Rewrite services.stt.provider Flux ids to the parent provider plus providers.<id>.model",
+  run(workspaceDir: string): void {
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) {
+      return;
+    }
+
+    let config: Record<string, unknown>;
+    try {
+      config = JSON.parse(readFileSync(configPath, "utf8")) as Record<
+        string,
+        unknown
+      >;
+    } catch {
+      // A config that does not parse is the loader's problem to report, not
+      // this migration's to guess at.
+      return;
+    }
+
+    const services = asRecord(config.services);
+    const stt = asRecord(services?.stt);
+    if (!stt || typeof stt.provider !== "string") {
+      return;
+    }
+
+    const providers = asRecord(stt.providers) ?? {};
+    let changed = dropUnservableModels(providers);
+
+    const parent = FLUX_PROVIDER_PARENTS[stt.provider];
+    if (parent !== undefined) {
+      stt.provider = parent;
+      const parentSettings = asRecord(providers[parent]) ?? {};
+      parentSettings.model = "flux";
+      providers[parent] = parentSettings;
+      changed = true;
+    }
+
+    if (!changed) {
+      return;
+    }
+
+    stt.providers = providers;
+    writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: the Flux provider ids are gone from the config enum, so
+    // restoring one would produce a config the schema rejects.
+  },
+};
+
+/**
+ * Remove `model` values a provider known at the time of writing cannot serve.
+ * Entries for any other provider are left untouched: that map is deliberately
+ * open to ids from future builds, and the schema does not validate them
+ * either.
+ */
+function dropUnservableModels(providers: Record<string, unknown>): boolean {
+  let changed = false;
+  for (const [providerId, value] of Object.entries(providers)) {
+    const settings = asRecord(value);
+    if (!settings || settings.model === undefined) {
+      continue;
+    }
+    const families = KNOWN_MODEL_FAMILIES[providerId];
+    if (families === undefined) {
+      continue;
+    }
+    if (
+      typeof settings.model !== "string" ||
+      !families.includes(settings.model)
+    ) {
+      delete settings.model;
+      changed = true;
+    }
+  }
+  return changed;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}

package/src/workspace/migrations/__tests__/150-stt-flux-provider-to-model-family.test.ts

@@ -0,0 +1,160 @@
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { sttFluxProviderToModelFamilyMigration } from "../150-stt-flux-provider-to-model-family.js";
+import { WORKSPACE_MIGRATIONS } from "../registry.js";
+
+function workspaceWith(config: unknown): string {
+  const dir = mkdtempSync(join(tmpdir(), "stt-flux-migration-"));
+  writeFileSync(join(dir, "config.json"), JSON.stringify(config, null, 2));
+  return dir;
+}
+
+function readConfig(dir: string): any {
+  return JSON.parse(readFileSync(join(dir, "config.json"), "utf8"));
+}
+
+describe("150-stt-flux-provider-to-model-family", () => {
+  test("is registered as the newest migration", () => {
+    expect(sttFluxProviderToModelFamilyMigration.id).toBe(
+      "150-stt-flux-provider-to-model-family",
+    );
+    expect(WORKSPACE_MIGRATIONS.at(-1)?.id).toBe(
+      "150-stt-flux-provider-to-model-family",
+    );
+  });
+
+  test("rewrites a Flux provider id to its parent plus a model family", () => {
+    const dir = workspaceWith({
+      services: { stt: { provider: "deepgram-flux", providers: {} } },
+    });
+
+    sttFluxProviderToModelFamilyMigration.run(dir);
+
+    expect(readConfig(dir).services.stt).toEqual({
+      provider: "deepgram",
+      providers: { deepgram: { model: "flux" } },
+    });
+  });
+
+  test("rewrites the managed pair the same way", () => {
+    const dir = workspaceWith({
+      services: { stt: { provider: "vellum-flux", providers: {} } },
+    });
+
+    sttFluxProviderToModelFamilyMigration.run(dir);
+
+    expect(readConfig(dir).services.stt.provider).toBe("vellum");
+    expect(readConfig(dir).services.stt.providers.vellum.model).toBe("flux");
+  });
+
+  test("keeps existing settings on the parent's entry", () => {
+    const dir = workspaceWith({
+      services: {
+        stt: {
+          provider: "deepgram-flux",
+          providers: { deepgram: { someExistingKey: 1 } },
+        },
+      },
+    });
+
+    sttFluxProviderToModelFamilyMigration.run(dir);
+
+    expect(readConfig(dir).services.stt.providers.deepgram).toEqual({
+      someExistingKey: 1,
+      model: "flux",
+    });
+  });
+
+  test("drops a model a known provider cannot serve", () => {
+    // That key was free-form and read by nothing before this change, so an
+    // existing value is meaningless -- but the schema validates it now, and
+    // leaving one behind drops the workspace onto the loader's salvage path,
+    // which resets the whole services section.
+    const dir = workspaceWith({
+      services: {
+        stt: {
+          provider: "deepgram",
+          providers: { deepgram: { model: "nova-2", keepMe: true } },
+        },
+      },
+    });
+
+    sttFluxProviderToModelFamilyMigration.run(dir);
+
+    expect(readConfig(dir).services.stt.providers.deepgram).toEqual({
+      keepMe: true,
+    });
+  });
+
+  test("keeps a model the provider can serve", () => {
+    const dir = workspaceWith({
+      services: {
+        stt: {
+          provider: "deepgram",
+          providers: { deepgram: { model: "flux" } },
+        },
+      },
+    });
+
+    sttFluxProviderToModelFamilyMigration.run(dir);
+
+    expect(readConfig(dir).services.stt.providers.deepgram.model).toBe("flux");
+  });
+
+  test("leaves entries for providers the catalog does not know", () => {
+    // The map is deliberately open to ids from future builds, and the schema
+    // does not validate those either.
+    const before = {
+      services: {
+        stt: {
+          provider: "deepgram",
+          providers: { "future-provider": { model: "next-gen" } },
+        },
+      },
+    };
+    const dir = workspaceWith(before);
+
+    sttFluxProviderToModelFamilyMigration.run(dir);
+
+    expect(readConfig(dir)).toEqual(before);
+  });
+
+  test("leaves a non-Flux provider untouched", () => {
+    const before = {
+      services: { stt: { provider: "deepgram", providers: {} } },
+    };
+    const dir = workspaceWith(before);
+
+    sttFluxProviderToModelFamilyMigration.run(dir);
+
+    expect(readConfig(dir)).toEqual(before);
+  });
+
+  test("is idempotent", () => {
+    const dir = workspaceWith({
+      services: { stt: { provider: "deepgram-flux", providers: {} } },
+    });
+
+    sttFluxProviderToModelFamilyMigration.run(dir);
+    const once = readConfig(dir);
+    sttFluxProviderToModelFamilyMigration.run(dir);
+
+    expect(readConfig(dir)).toEqual(once);
+  });
+
+  test("does nothing without a config file, or with an unparseable one", () => {
+    const empty = mkdtempSync(join(tmpdir(), "stt-flux-migration-"));
+    expect(() =>
+      sttFluxProviderToModelFamilyMigration.run(empty),
+    ).not.toThrow();
+
+    const broken = mkdtempSync(join(tmpdir(), "stt-flux-migration-"));
+    writeFileSync(join(broken, "config.json"), "{not json");
+    expect(() =>
+      sttFluxProviderToModelFamilyMigration.run(broken),
+    ).not.toThrow();
+  });
+});

package/src/workspace/migrations/registry.ts

@@ -144,6 +144,10 @@ import { repairDeprecatedCodexModelIdMigration } from "./143-repair-deprecated-c
 import { convertStrandedSubscriptionOpenaiProfilesMigration } from "./144-convert-stranded-subscription-openai-profiles.js";
 import { collapseProfileBindingsToEntriesMigration } from "./145-collapse-profile-bindings-to-entries.js";
 import { repairRetiredFireworksDeepseekFlashModelIdMigration } from "./146-repair-retired-fireworks-deepseek-flash-model-id.js";
+import { renameCollidingBackupProfileNamesMigration } from "./147-rename-colliding-backup-profile-names.js";
+import { stripUnsupportedFallbackProfilesMigration } from "./148-strip-unsupported-fallback-profiles.js";
+import { repointBackupProfileSelectionsMigration } from "./149-repoint-backup-profile-selections.js";
+import { sttFluxProviderToModelFamilyMigration } from "./150-stt-flux-provider-to-model-family.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -303,4 +307,8 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   convertStrandedSubscriptionOpenaiProfilesMigration,
   collapseProfileBindingsToEntriesMigration,
   repairRetiredFireworksDeepseekFlashModelIdMigration,
+  renameCollidingBackupProfileNamesMigration,
+  stripUnsupportedFallbackProfilesMigration,
+  repointBackupProfileSelectionsMigration,
+  sttFluxProviderToModelFamilyMigration,
 ];

package/src/__tests__/permission-types.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { isAllowDecision } from "../permissions/types.js";
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("isAllowDecision", () => {
-  test("returns true for 'allow'", () => {
-    expect(isAllowDecision("allow")).toBe(true);
-  });
-
-  test("returns false for 'deny'", () => {
-    expect(isAllowDecision("deny")).toBe(false);
-  });
-});

package/src/channels/gateway-discord-admission.ts

@@ -1,32 +0,0 @@
-/**
- * Daemon-side reader for how much Discord admits.
- *
- * The gateway owns the allow-list and the drop decision it feeds; the
- * readiness surface that reports channel setup to the user lives here. This is
- * the relay between them, and it exists for the same reason the socket-health
- * relay does: the fact lives on one side of the boundary and is reported from
- * the other.
- */
-
-import {
-  type DiscordAdmissionIpcResponse,
-  DiscordAdmissionIpcResponseSchema,
-} from "@vellumai/gateway-client/gateway-ipc-contracts";
-
-import { ipcCallPersistentValidated } from "../ipc/gateway-validated-call.js";
-
-/**
- * Ask the gateway how many channels Discord's allow-list admits.
- *
- * Throws on transport failure rather than reporting zero: an unreachable
- * gateway is a fact about the gateway, and answering zero would tell an
- * operator their allow-list is empty when nobody looked. Callers treat a throw
- * as indeterminate.
- */
-export async function readDiscordAdmission(): Promise<DiscordAdmissionIpcResponse> {
-  return ipcCallPersistentValidated(
-    "discord_admission",
-    {},
-    DiscordAdmissionIpcResponseSchema,
-  );
-}