@vellumai/assistant 0.6.4 → 0.6.6

package/src/workspace/migrations/039-drop-legacy-llm-keys.ts

@@ -0,0 +1,171 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Strip the now-removed legacy LLM-related keys from existing `config.json`
+ * files. PR 19 of the unify-llm-callsites plan removed these keys from
+ * `AssistantConfigSchema`; Zod silently strips unknown fields when re-parsing,
+ * but the keys would otherwise persist on disk forever and re-appear in any
+ * exported config snapshot. Erasing them keeps `config.json` lean and matches
+ * the schema that the in-memory loader sees.
+ *
+ * Keys removed:
+ *   - Top level: `maxTokens`, `effort`, `speed`, `thinking`, `contextWindow`,
+ *     `pricingOverrides`.
+ *   - `services.inference.{provider, model}` (the `mode` field stays — it
+ *     governs `managed` vs `your-own` routing, which is orthogonal to LLM
+ *     model selection).
+ *   - `heartbeat.speed`, `filing.speed`.
+ *   - `analysis.modelIntent`, `analysis.modelOverride`.
+ *   - `memory.summarization.modelIntent`.
+ *   - `notifications.decisionModelIntent`.
+ *   - `ui.greetingModelIntent`.
+ *   - `calls.model`.
+ *   - `workspaceGit.commitMessageLLM.{maxTokens, temperature,
+ *     useConfiguredProvider, providerFastModelOverrides}`.
+ *
+ * Preconditions: this migration depends on
+ * `038-unify-llm-callsite-configs` having already populated `llm.default` /
+ * `llm.callSites` / `llm.pricingOverrides` from these legacy keys. The
+ * registry guarantees ordering.
+ *
+ * Idempotency: each delete is wrapped in a key-exists check so re-runs are
+ * no-ops. Empty objects are left in place rather than recursively pruned —
+ * that matches Zod's default behavior of treating an absent value the same
+ * as an empty `{}` for nested schemas.
+ */
+export const dropLegacyLlmKeysMigration: WorkspaceMigration = {
+  id: "039-drop-legacy-llm-keys",
+  description:
+    "Strip deprecated scattered LLM-related keys from config.json (post-PR-19 cleanup)",
+  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;
+    }
+
+    let mutated = false;
+
+    for (const key of [
+      "maxTokens",
+      "effort",
+      "speed",
+      "thinking",
+      "contextWindow",
+      "pricingOverrides",
+    ]) {
+      if (key in config) {
+        delete config[key];
+        mutated = true;
+      }
+    }
+
+    const services = readObject(config.services);
+    if (services !== null) {
+      const inference = readObject(services.inference);
+      if (inference !== null) {
+        for (const key of ["provider", "model"]) {
+          if (key in inference) {
+            delete inference[key];
+            mutated = true;
+          }
+        }
+      }
+    }
+
+    const heartbeat = readObject(config.heartbeat);
+    if (heartbeat !== null && "speed" in heartbeat) {
+      delete heartbeat.speed;
+      mutated = true;
+    }
+
+    const filing = readObject(config.filing);
+    if (filing !== null && "speed" in filing) {
+      delete filing.speed;
+      mutated = true;
+    }
+
+    const analysis = readObject(config.analysis);
+    if (analysis !== null) {
+      for (const key of ["modelIntent", "modelOverride"]) {
+        if (key in analysis) {
+          delete analysis[key];
+          mutated = true;
+        }
+      }
+    }
+
+    const memory = readObject(config.memory);
+    if (memory !== null) {
+      const summarization = readObject(memory.summarization);
+      if (summarization !== null && "modelIntent" in summarization) {
+        delete summarization.modelIntent;
+        mutated = true;
+      }
+    }
+
+    const notifications = readObject(config.notifications);
+    if (notifications !== null && "decisionModelIntent" in notifications) {
+      delete notifications.decisionModelIntent;
+      mutated = true;
+    }
+
+    const ui = readObject(config.ui);
+    if (ui !== null && "greetingModelIntent" in ui) {
+      delete ui.greetingModelIntent;
+      mutated = true;
+    }
+
+    const calls = readObject(config.calls);
+    if (calls !== null && "model" in calls) {
+      delete calls.model;
+      mutated = true;
+    }
+
+    const workspaceGit = readObject(config.workspaceGit);
+    if (workspaceGit !== null) {
+      const commitMessageLLM = readObject(workspaceGit.commitMessageLLM);
+      if (commitMessageLLM !== null) {
+        for (const key of [
+          "maxTokens",
+          "temperature",
+          "useConfiguredProvider",
+          "providerFastModelOverrides",
+        ]) {
+          if (key in commitMessageLLM) {
+            delete commitMessageLLM[key];
+            mutated = true;
+          }
+        }
+      }
+    }
+
+    if (!mutated) return;
+
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  /**
+   * Forward-only. Restoring the deleted keys would re-introduce schema-validation
+   * warnings and have no runtime effect — every reader migrated to `llm.default`
+   * / `llm.callSites` in PR 19.
+   */
+  down(_workspaceDir: string): void {
+    // no-op
+  },
+};
+
+function readObject(value: unknown): Record<string, unknown> | null {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}

package/src/workspace/migrations/040-seed-latency-callsite-defaults.ts

@@ -0,0 +1,154 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Seed latency-optimized call-site defaults for background LLM tasks.
+ *
+ * Migration 038 consolidated scattered LLM config keys but only wrote
+ * per-call-site entries when the legacy config had *explicit* overrides.
+ * Call sites that relied on runtime `modelIntent: "latency-optimized"`
+ * (guardian copy, classifier, notifications, etc.) were left without
+ * entries, causing them to fall through to `llm.default` (opus with max
+ * effort) — a significant cost and latency regression.
+ *
+ * Seeds the missing entries with the appropriate fast model for the
+ * workspace's configured provider. Runs in two modes:
+ *
+ *   1. **Existing workspace** (config.json present): read provider from
+ *      `llm.default.provider`, merge seeds into `llm.callSites` without
+ *      overwriting any user-defined overrides.
+ *   2. **Fresh install** (config.json absent): write a minimal starter
+ *      config with just the callSite seeds, using the default provider
+ *      (anthropic — same as the schema default). `loadConfig()` runs
+ *      after migrations and backfills the remaining schema defaults via
+ *      `deepMergeMissing`, which preserves our seeded callSites.
+ *
+ * Without the fresh-install branch, new users permanently fall through
+ * to `llm.default` (opus + max effort) because `LLMSchema.callSites`
+ * defaults to `{}` and nothing else seeds the latency-optimized entries.
+ *
+ * **Provider gating.** `mergeDefaultWorkspaceConfig()` applies
+ * `VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH` *after* migrations run, so a
+ * platform-provided override that sets `llm.default.provider = openai`
+ * (or any non-Anthropic provider) without also setting `llm.callSites`
+ * would otherwise leave the workspace with OpenAI as the default but
+ * Anthropic model IDs in the seeded call sites — guaranteed
+ * invalid-model errors. Skip seeding when:
+ *   - `VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH` is set (defer to that
+ *     config to own the call-site seeds), or
+ *   - `llm.default.provider` is explicitly set to a non-Anthropic value.
+ */
+export const seedLatencyCallSiteDefaultsMigration: WorkspaceMigration = {
+  id: "040-seed-latency-callsite-defaults",
+  description:
+    "Seed latency-optimized call-site defaults for background LLM tasks",
+  run(workspaceDir: string): void {
+    // If a platform default-config overlay is in play, it runs after
+    // migrations and is the authoritative source for both provider and
+    // call-site seeds. Skip to avoid mismatched provider/model pairs.
+    if (process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH) return;
+
+    const configPath = join(workspaceDir, "config.json");
+    const configExisted = existsSync(configPath);
+
+    let config: Record<string, unknown> = {};
+    if (configExisted) {
+      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 = readObject(config.llm) ?? {};
+    const defaultBlock = readObject(llm.default);
+
+    // Only seed when the resolved provider is Anthropic. If the user has
+    // explicitly configured a different provider, skip — their config
+    // (or the provider's own defaults) should own the call-site seeds.
+    const explicitProvider = readString(defaultBlock?.provider);
+    if (explicitProvider !== undefined && explicitProvider !== "anthropic") {
+      return;
+    }
+    const provider = explicitProvider ?? "anthropic";
+    const fastModel = resolveLatencyModel(provider);
+    if (fastModel === undefined) return;
+
+    const callSites = readObject(llm.callSites) ?? {};
+
+    const LATENCY_SITES = [
+      "guardianQuestionCopy",
+      "watchCommentary",
+      "interactionClassifier",
+      "skillCategoryInference",
+      "inviteInstructionGenerator",
+      "notificationDecision",
+      "preferenceExtraction",
+    ];
+
+    let changed = false;
+
+    for (const site of LATENCY_SITES) {
+      if (readObject(callSites[site]) !== null) continue;
+      callSites[site] = {
+        model: fastModel,
+        effort: "low",
+        thinking: { enabled: false },
+      };
+      changed = true;
+    }
+
+    if (readObject(callSites.commitMessage) === null) {
+      callSites.commitMessage = {
+        model: fastModel,
+        maxTokens: 120,
+        temperature: 0.2,
+        effort: "low",
+        thinking: { enabled: false },
+      };
+      changed = true;
+    }
+
+    if (!changed) return;
+
+    llm.callSites = callSites;
+    config.llm = llm;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only: removing the seeded defaults would reintroduce the
+    // cost/latency regression this migration fixes.
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Helpers — self-contained per workspace migrations AGENTS.md
+// ---------------------------------------------------------------------------
+
+const PROVIDER_LATENCY_MODELS: Record<string, string> = {
+  anthropic: "claude-haiku-4-5-20251001",
+  openai: "gpt-5.4-nano",
+  gemini: "gemini-3-flash",
+  ollama: "llama3.2",
+  fireworks: "accounts/fireworks/models/kimi-k2p5",
+  openrouter: "anthropic/claude-haiku-4.5",
+};
+
+function resolveLatencyModel(provider: string): string | undefined {
+  return PROVIDER_LATENCY_MODELS[provider];
+}
+
+function readObject(value: unknown): Record<string, unknown> | null {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}

package/src/workspace/migrations/041-backfill-google-gmail-settings-scope.ts

@@ -0,0 +1,56 @@
+import { rawGet, rawRun } from "../../memory/raw-query.js";
+import type { WorkspaceMigration } from "./types.js";
+
+const GMAIL_SETTINGS_BASIC_SCOPE =
+  "https://www.googleapis.com/auth/gmail.settings.basic";
+
+/**
+ * Backfill the `gmail.settings.basic` scope for existing Google provider rows.
+ *
+ * The scope was added to PROVIDER_SEED_DATA in #25970. This migration ensures
+ * existing workspace rows that were created before the seed update also include
+ * the scope.
+ *
+ * This migration reads the current `defaultScopes` JSON array for the `google`
+ * provider and appends the scope if it is not already present.
+ */
+export const backfillGoogleGmailSettingsScopeMigration: WorkspaceMigration = {
+  id: "041-backfill-google-gmail-settings-scope",
+  description:
+    "Backfill gmail.settings.basic scope for existing Google provider rows",
+  run(_workspaceDir: string): void {
+    let row: { defaultScopes: string } | null;
+    try {
+      row = rawGet<{ defaultScopes: string }>(
+        `SELECT defaultScopes FROM oauth_providers WHERE provider = 'google'`,
+      );
+    } catch {
+      // DB not initialized yet — nothing to backfill.
+      return;
+    }
+
+    if (!row) return; // No google provider row — seed will create it fresh.
+
+    let scopes: string[];
+    try {
+      const parsed = JSON.parse(row.defaultScopes);
+      scopes = Array.isArray(parsed) ? parsed : [];
+    } catch {
+      scopes = [];
+    }
+
+    if (scopes.includes(GMAIL_SETTINGS_BASIC_SCOPE)) return; // Already present.
+
+    scopes.push(GMAIL_SETTINGS_BASIC_SCOPE);
+
+    rawRun(
+      `UPDATE oauth_providers SET defaultScopes = ?, updatedAt = ? WHERE provider = 'google'`,
+      JSON.stringify(scopes),
+      new Date().toISOString(),
+    );
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only: removing the scope would break Gmail settings functionality
+    // for users who have already started using it.
+  },
+};

package/src/workspace/migrations/042-fix-backfill-google-gmail-settings-scope.ts

@@ -0,0 +1,70 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+
+import type { WorkspaceMigration } from "./types.js";
+
+const GMAIL_SETTINGS_BASIC_SCOPE =
+  "https://www.googleapis.com/auth/gmail.settings.basic";
+
+/**
+ * Re-run the gmail.settings.basic scope backfill with correct SQLite column names.
+ *
+ * Migration 041 used Drizzle property names (`defaultScopes`, `provider`,
+ * `updatedAt`) instead of the actual SQLite column names (`default_scopes`,
+ * `provider_key`, `updated_at`). The SQL silently failed because the catch
+ * block swallowed the error, and the migration was marked complete without
+ * actually backfilling the scope.
+ *
+ * This migration performs the same backfill with the correct column names.
+ */
+export const fixBackfillGoogleGmailSettingsScopeMigration: WorkspaceMigration =
+  {
+    id: "042-fix-backfill-google-gmail-settings-scope",
+    description:
+      "Re-run gmail.settings.basic scope backfill with correct SQLite column names",
+    run(workspaceDir: string): void {
+      const dbPath = join(workspaceDir, "data", "db", "assistant.db");
+      if (!existsSync(dbPath)) return; // DB not created yet — nothing to backfill.
+
+      let db: Database;
+      try {
+        db = new Database(dbPath);
+      } catch {
+        // Cannot open DB — nothing to backfill.
+        return;
+      }
+
+      try {
+        const row = db
+          .query(
+            `SELECT default_scopes FROM oauth_providers WHERE provider_key = 'google'`,
+          )
+          .get() as { default_scopes: string } | null;
+
+        if (!row) return; // No google provider row — seed will create it fresh.
+
+        let scopes: string[];
+        try {
+          const parsed = JSON.parse(row.default_scopes);
+          scopes = Array.isArray(parsed) ? parsed : [];
+        } catch {
+          scopes = [];
+        }
+
+        if (scopes.includes(GMAIL_SETTINGS_BASIC_SCOPE)) return; // Already present.
+
+        scopes.push(GMAIL_SETTINGS_BASIC_SCOPE);
+
+        db.query(
+          `UPDATE oauth_providers SET default_scopes = ?, updated_at = ? WHERE provider_key = 'google'`,
+        ).run(JSON.stringify(scopes), Date.now());
+      } finally {
+        db.close();
+      }
+    },
+    down(_workspaceDir: string): void {
+      // Forward-only: removing the scope would break Gmail settings functionality
+      // for users who have already started using it.
+    },
+  };

package/src/workspace/migrations/043-release-notes-latex-rendering.ts

@@ -0,0 +1,75 @@
+import {
+  appendFileSync,
+  existsSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+import { getLogger } from "../../util/logger.js";
+import type { WorkspaceMigration } from "./types.js";
+
+const log = getLogger("workspace-migration-043-release-notes-latex-rendering");
+
+const MIGRATION_ID = "043-release-notes-latex-rendering";
+const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+const RELEASE_NOTE = `${MARKER}
+## LaTeX math rendering in chat
+
+I can now render LaTeX block-math expressions in the macOS chat. Content wrapped in \`$$...$$\` is typeset instead of shown as raw monospace text. Inline \`$...$\` math is planned as a follow-up.
+`;
+
+/**
+ * Release-notes migration for LaTeX block-math rendering in the macOS chat.
+ *
+ * Per AGENTS.md § Release Update Hygiene, user-facing changes ship notes via a
+ * workspace migration that appends to `<workspace>/UPDATES.md`. The in-file
+ * HTML marker guards against duplicate appends if the runner re-executes this
+ * migration after a mid-run crash (between `appendFileSync` and the runner's
+ * checkpoint promotion to `applied`), which the runner's own checkpoint state
+ * does not cover on its own.
+ */
+export const releaseNotesLatexRenderingMigration: WorkspaceMigration = {
+  id: MIGRATION_ID,
+  description:
+    "Append release notes for LaTeX block-math rendering to UPDATES.md",
+
+  run(workspaceDir: string): void {
+    const updatesPath = join(workspaceDir, "UPDATES.md");
+
+    try {
+      if (existsSync(updatesPath)) {
+        const existing = readFileSync(updatesPath, "utf-8");
+        if (existing.includes(MARKER)) {
+          // Marker already present — a prior run of this migration appended
+          // the note. Short-circuit to keep the migration idempotent across
+          // the narrow crash window between append and runner checkpoint.
+          return;
+        }
+        // Ensure separation from prior content.
+        const needsLeadingNewline = !existing.endsWith("\n\n");
+        const prefix = existing.endsWith("\n") ? "\n" : "\n\n";
+        appendFileSync(
+          updatesPath,
+          needsLeadingNewline ? `${prefix}${RELEASE_NOTE}` : RELEASE_NOTE,
+          "utf-8",
+        );
+      } else {
+        writeFileSync(updatesPath, RELEASE_NOTE, "utf-8");
+      }
+      log.info({ path: updatesPath }, "Appended LaTeX rendering release note");
+    } catch (err) {
+      log.warn(
+        { err, path: updatesPath },
+        "Failed to append LaTeX rendering release note to UPDATES.md",
+      );
+    }
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: UPDATES.md is a user-facing bulletin the assistant
+    // processes and deletes on its own. Attempting to reverse a note that may
+    // have already been read/deleted would risk surprising user-visible state.
+  },
+};

package/src/workspace/migrations/044-bump-stale-provider-stream-timeout.ts

@@ -0,0 +1,51 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Bump stale `timeouts.providerStreamTimeoutSec: 300` to 1800.
+ *
+ * The schema default was raised from 300s (5 min) to 1800s (30 min) in
+ * PR #22702, but users whose workspace config was written before that change
+ * still carry an explicit 300 that overrides the new default, causing streams
+ * to abort after 5 minutes with "Anthropic stream timed out after 300s".
+ */
+export const bumpStaleProviderStreamTimeoutMigration: WorkspaceMigration = {
+  id: "044-bump-stale-provider-stream-timeout",
+  description:
+    "Bump legacy timeouts.providerStreamTimeoutSec: 300 to 1800 to match the current schema default",
+  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 timeouts = config.timeouts;
+    if (!timeouts || typeof timeouts !== "object" || Array.isArray(timeouts))
+      return;
+    const timeoutsObj = timeouts as Record<string, unknown>;
+
+    if (timeoutsObj.providerStreamTimeoutSec !== 300) return;
+
+    timeoutsObj.providerStreamTimeoutSec = 1800;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only: the runner marks migrations as applied even when `run()`
+    // was a no-op (e.g. workspaces that already had 1800 from the new schema
+    // default, or that never had the key at all). A `down()` that blindly
+    // rewrote 1800 → 300 would silently downgrade those workspaces and
+    // resurrect the "stream timed out after 300s" bug this migration fixes.
+    // We can't distinguish "this migration set 1800" from "the value was
+    // always 1800" without an extra state marker, so we treat the bump as
+    // irreversible. Users who genuinely want 300s can set it in config.
+  },
+};