@vellumai/assistant 0.7.3 → 0.8.1

package/src/workspace/migrations/072-seed-reply-suggestion-callsite.ts

@@ -0,0 +1,104 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Seed a latency-optimized default for the `replySuggestion` LLM call site.
+ *
+ * `replySuggestion` drives the tab-to-accept ghost-text reply hint rendered in
+ * the chat composer after every assistant turn (`GET /v1/suggestion`). It was
+ * split out of `conversationStarters` so the empty-state chip generator and
+ * the inline reply hint can be tuned independently. Without this seed the
+ * call site falls through to `llm.default` — on workspaces with a
+ * high-effort / extended-thinking default, every turn would kick off an
+ * expensive reasoning call and reject the assistant prefill.
+ *
+ * Mirrors `046-seed-conversation-starters-callsite`:
+ *   - Skip entirely when `VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH` is set
+ *     (platform overlay owns call-site seeds).
+ *   - Skip when the resolved provider is not Anthropic or OpenRouter (the
+ *     seeded model IDs are Anthropic-shaped, so mixing with another
+ *     provider would guarantee invalid-model errors).
+ *   - No-op when `llm.callSites.replySuggestion` is already set.
+ *
+ * Idempotent, append-only — existing entries are untouched.
+ */
+export const seedReplySuggestionCallsiteMigration: WorkspaceMigration = {
+  id: "072-seed-reply-suggestion-callsite",
+  description:
+    "Seed latency-optimized default for replySuggestion LLM call site",
+  run(workspaceDir: string): void {
+    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);
+
+    const explicitProvider = readString(defaultBlock?.provider);
+    if (
+      explicitProvider !== undefined &&
+      explicitProvider !== "anthropic" &&
+      explicitProvider !== "openrouter"
+    ) {
+      return;
+    }
+    const provider = explicitProvider ?? "anthropic";
+    const fastModel = resolveLatencyModel(provider);
+    if (fastModel === undefined) return;
+
+    const callSites = readObject(llm.callSites) ?? {};
+    if (readObject(callSites.replySuggestion) !== null) return;
+
+    callSites.replySuggestion = {
+      model: fastModel,
+      effort: "low",
+      thinking: { enabled: false },
+    };
+
+    llm.callSites = callSites;
+    config.llm = llm;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only: removing the seeded default would reintroduce the
+    // cost/latency regression that this migration fixes.
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Helpers — self-contained per workspace migrations AGENTS.md
+// ---------------------------------------------------------------------------
+
+const PROVIDER_LATENCY_MODELS: Record<string, string> = {
+  anthropic: "claude-haiku-4-5-20251001",
+  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/073-repair-recall-callsite-empty-profile.ts

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Repair `llm.callSites.recall` entries that point at an empty
+ * `cost-optimized` profile.
+ *
+ * Migration 052 seeds empty `{}` profile shells for non-Anthropic workspaces.
+ * The original 054 logic treated any present `cost-optimized` profile as
+ * usable, so it set `callSites.recall.profile = "cost-optimized"` without a
+ * model on those workspaces — which caused the resolver to fall back to
+ * `llm.default.model`, defeating the cost-optimization goal. 054 has since
+ * been corrected, but workspaces that already applied it need a one-time
+ * repair.
+ */
+export const repairRecallCallsiteEmptyProfileMigration: WorkspaceMigration = {
+  id: "073-repair-recall-callsite-empty-profile",
+  description:
+    "Replace recall call-site profile pointer when cost-optimized profile lacks a model",
+  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 = readObject(config.llm);
+    if (llm === null) return;
+
+    const callSites = readObject(llm.callSites);
+    if (callSites === null) return;
+
+    const recall = readObject(callSites.recall);
+    if (recall === null) return;
+    if (recall.profile !== "cost-optimized") return;
+
+    const profiles = readObject(llm.profiles) ?? {};
+    const costOptimized = readObject(profiles["cost-optimized"]);
+    if (
+      costOptimized !== null &&
+      readString(costOptimized.model) !== undefined
+    ) {
+      return;
+    }
+
+    const defaultBlock = readObject(llm.default);
+    const provider = readString(defaultBlock?.provider) ?? "anthropic";
+    const cheapModel = PROVIDER_LATENCY_MODELS[provider];
+    if (cheapModel === undefined) return;
+
+    delete recall.profile;
+    recall.model = cheapModel;
+    callSites.recall = recall;
+    llm.callSites = callSites;
+    config.llm = llm;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only: reverting would reintroduce the broken profile pointer.
+  },
+};
+
+// ---------------------------------------------------------------------------
+// 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-preview",
+  ollama: "llama3.2",
+  fireworks: "accounts/fireworks/models/kimi-k2p5",
+  openrouter: "anthropic/claude-haiku-4.5",
+};
+
+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/074-drop-deprecated-secret-detection-keys.ts

@@ -0,0 +1,117 @@
+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-074-drop-deprecated-secret-detection-keys",
+);
+
+const MIGRATION_ID = "074-drop-deprecated-secret-detection-keys";
+const NOTICE_MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+function buildNotice(previousAction: string): string {
+  return `${NOTICE_MARKER}
+## Heads-up: tool-output secret scanning was retired
+
+Your previous \`secretDetection.action\` setting was \`"${previousAction}"\`,
+which used to gate or redact tool output containing high-entropy strings or
+matches against custom regex patterns. That post-execution scanning layer has
+been removed because it was false-positive prone and prevented the assistant
+from acting on values it had legitimately fetched.
+
+Prefix-based ingress detection on user messages is still active
+(\`secretDetection.enabled\` / \`secretDetection.blockIngress\`), and the
+\`secretDetection.entropyThreshold\` and \`secretDetection.customPatterns\`
+fields have been removed from your config. If you relied on the old behavior,
+please reach out so we can find a better solution for your use case.
+`;
+}
+
+export const dropDeprecatedSecretDetectionKeysMigration: WorkspaceMigration = {
+  id: MIGRATION_ID,
+  description:
+    "Strip removed secretDetection.action / entropyThreshold / customPatterns keys; notify users who had a non-default action policy",
+
+  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 secretDetection = readObject(config.secretDetection);
+    if (secretDetection === null) return;
+
+    const previousAction =
+      typeof secretDetection.action === "string"
+        ? secretDetection.action
+        : null;
+
+    let mutated = false;
+    for (const key of ["action", "entropyThreshold", "customPatterns"]) {
+      if (key in secretDetection) {
+        delete secretDetection[key];
+        mutated = true;
+      }
+    }
+
+    if (mutated) {
+      writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    }
+
+    if (previousAction === "block" || previousAction === "prompt") {
+      appendNotice(workspaceDir, previousAction);
+    }
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: restoring the deleted keys would re-introduce schema
+    // warnings without changing runtime behavior — the post-execution scanner
+    // they used to drive no longer exists.
+  },
+};
+
+function appendNotice(workspaceDir: string, previousAction: string): void {
+  const updatesPath = join(workspaceDir, "UPDATES.md");
+  const notice = buildNotice(previousAction);
+
+  try {
+    if (existsSync(updatesPath)) {
+      const existing = readFileSync(updatesPath, "utf-8");
+      if (existing.includes(NOTICE_MARKER)) return;
+      const prefix = existing.endsWith("\n") ? "\n" : "\n\n";
+      appendFileSync(updatesPath, `${prefix}${notice}`, "utf-8");
+    } else {
+      writeFileSync(updatesPath, notice, "utf-8");
+    }
+    log.info(
+      { path: updatesPath, previousAction },
+      "Appended secret-detection retirement notice",
+    );
+  } catch (err) {
+    log.warn(
+      { err, path: updatesPath, previousAction },
+      "Failed to append secret-detection retirement notice to UPDATES.md",
+    );
+  }
+}
+
+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/075-memory-v2-bm25-b-default-reembed.ts

@@ -0,0 +1,61 @@
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Enqueue a one-shot `memory_v2_reembed` job so existing concept pages pick
+ * up the new `memory.v2.bm25_b` default (0.4, lowered from 0.75 in PR
+ * #29345). `embed_concept_page` bakes `bm25_b` into the stored sparse
+ * vectors at write time, so without this nudge workspaces that never pinned
+ * the field would silently mix old and new length normalization until a
+ * manual reembed.
+ */
+export const memoryV2Bm25BDefaultReembedMigration: WorkspaceMigration = {
+  id: "075-memory-v2-bm25-b-default-reembed",
+  description:
+    "Enqueue memory_v2_reembed so existing concept pages pick up the new bm25_b=0.4 default",
+
+  run(workspaceDir: string): void {
+    const dbPath = join(workspaceDir, "data", "db", "assistant.db");
+    if (!existsSync(dbPath)) return; // Fresh install — pages will embed at the new default.
+
+    let db: Database;
+    try {
+      db = new Database(dbPath);
+    } catch {
+      return;
+    }
+
+    try {
+      const tableRow = db
+        .query(
+          `SELECT name FROM sqlite_master WHERE type='table' AND name='memory_jobs'`,
+        )
+        .get();
+      if (!tableRow) return;
+
+      const existing = db
+        .query(
+          `SELECT id FROM memory_jobs WHERE type='memory_v2_reembed' AND status IN ('pending','running') LIMIT 1`,
+        )
+        .get();
+      if (existing) return;
+
+      const now = Date.now();
+      db.query(
+        `INSERT INTO memory_jobs
+           (id, type, payload, status, attempts, deferrals, run_after, last_error, created_at, updated_at)
+         VALUES (?, 'memory_v2_reembed', '{}', 'pending', 0, 0, ?, NULL, ?, ?)`,
+      ).run(randomUUID(), now, now, now);
+    } finally {
+      db.close();
+    }
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: the reembed is a one-shot data refresh.
+  },
+};

package/src/workspace/migrations/076-drop-services-inference-mode.ts

@@ -0,0 +1,62 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Strip the now-removed `services.inference.mode` field from existing
+ * `config.json` files. The field governed the global `managed` vs `your-own`
+ * routing toggle that was superseded by the `provider_connections` table. Auth
+ * routing is now per-profile via the `provider_connection` reference; there is
+ * no longer a schema-level field to store here.
+ *
+ * If `services.inference` becomes an empty object after stripping, it is left
+ * as `{}` — the schema still expects the key to be present (other code walks
+ * `config.services.inference`).
+ *
+ * Idempotent: re-running when `mode` is already absent is a no-op.
+ */
+export const dropServicesInferenceModeMigration: WorkspaceMigration = {
+  id: "076-drop-services-inference-mode",
+  description:
+    "Strip services.inference.mode from config.json (mode field removed from schema)",
+  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 services = config.services;
+    if (
+      services === null ||
+      typeof services !== "object" ||
+      Array.isArray(services)
+    )
+      return;
+
+    const inference = (services as Record<string, unknown>).inference;
+    if (
+      inference === null ||
+      typeof inference !== "object" ||
+      Array.isArray(inference)
+    )
+      return;
+
+    const inferenceObj = inference as Record<string, unknown>;
+    if (!("mode" in inferenceObj)) return;
+
+    delete inferenceObj.mode;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only: re-adding mode would reintroduce a field the schema no
+    // longer recognizes.
+  },
+};

package/src/workspace/migrations/077-seed-memory-router-callsite.ts

@@ -0,0 +1,89 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Seed `callSites.memoryRouter = { model: "claude-sonnet-4-6",
+ * contextWindow: { maxInputTokens: 1000000 } }` so the per-turn memory
+ * router runs on Sonnet 4.6 with the 1M context window by default.
+ *
+ * The router builds a numbered page index in the system prompt; a 1M
+ * context window keeps every concept page reachable even on large
+ * workspaces, and Sonnet 4.6 is the cheapest 1M-context Anthropic
+ * model that handles the routing task well. Without this seed the
+ * call site would inherit the workspace default model, which may
+ * cap context at 200k and silently truncate the index for large
+ * workspaces.
+ *
+ * Mirrors {@link seedMainAgentOpusCallsiteMigration} (050):
+ *
+ *   1. Existing workspace (config.json present): merge the seed into
+ *      `llm.callSites` without overwriting a user-defined override.
+ *   2. Fresh install (config.json absent): write a minimal starter
+ *      config carrying just the seed; `loadConfig()` applies schema
+ *      defaults to the in-memory config after migrations run.
+ *
+ * Skipped when:
+ *   - `VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH` is set (platform overlay wins),
+ *   - the user already has `llm.callSites.memoryRouter` (any override stays),
+ *   - the resolved provider is non-Anthropic (those workspaces pick their
+ *     own equivalent — we don't know which OpenAI/Gemini/Ollama model the
+ *     operator wants for the routing role).
+ */
+export const seedMemoryRouterCallsiteMigration: WorkspaceMigration = {
+  id: "077-seed-memory-router-callsite",
+  description:
+    "Seed callSites.memoryRouter to claude-sonnet-4-6 + 1M context for Anthropic",
+  run(workspaceDir: string): void {
+    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);
+
+    const explicitProvider = readString(defaultBlock?.provider);
+    if (explicitProvider !== undefined && explicitProvider !== "anthropic") {
+      return;
+    }
+
+    const callSites = readObject(llm.callSites) ?? {};
+    if (readObject(callSites.memoryRouter) !== null) return;
+
+    callSites.memoryRouter = {
+      model: "claude-sonnet-4-6",
+      contextWindow: { maxInputTokens: 1_000_000 },
+    };
+    llm.callSites = callSites;
+    config.llm = llm;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only: removing the seed would downgrade the router to the
+    // workspace default model on every re-run, defeating the goal.
+  },
+};
+
+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/078-release-notes-tavily-web-search.ts

@@ -0,0 +1,66 @@
+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-078-release-notes-tavily-web-search",
+);
+
+const MIGRATION_ID = "078-release-notes-tavily-web-search";
+const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+const RELEASE_NOTE = `${MARKER}
+## Tavily web search
+
+Tavily is now available as a web search provider. Add your Tavily API key in
+Settings → Models & Services, or run \`assistant keys set tavily <key>\`, then
+select Tavily for Web Search.
+`;
+
+export const releaseNotesTavilyWebSearchMigration: WorkspaceMigration = {
+  id: MIGRATION_ID,
+  description: "Append release notes for Tavily web search 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)) {
+          return;
+        }
+        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 Tavily web search release note",
+      );
+    } catch (err) {
+      log.warn(
+        { err, path: updatesPath },
+        "Failed to append Tavily web search 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.
+  },
+};