@vellumai/assistant 0.7.1 → 0.7.3

package/src/config/loader.ts

@@ -7,6 +7,7 @@ import {
 } from "node:fs";
 import { basename, dirname, join } from "node:path";
 
+import { safeStatSync } from "../util/fs.js";
 import { getLogger } from "../util/logger.js";
 import {
   ensureDataDir,
@@ -22,8 +23,22 @@ export { API_KEY_PROVIDERS } from "../providers/provider-secret-catalog.js";
 const log = getLogger("config");
 
 let cached: AssistantConfig | null = null;
+let cachedFileSignature: ConfigFileSignature | null = null;
 let loading = false;
 
+type ConfigFileSignature =
+  | {
+      path: string;
+      exists: true;
+      size: number;
+      mtimeMs: number;
+      ctimeMs: number;
+    }
+  | {
+      path: string;
+      exists: false;
+    };
+
 function getConfigPath(): string {
   return getWorkspaceConfigPath();
 }
@@ -32,6 +47,48 @@ function ensureMigratedDataDir(): void {
   ensureDataDir();
 }
 
+function readConfigFileSignature(configPath: string): ConfigFileSignature {
+  const stats = safeStatSync(configPath);
+  if (!stats) {
+    return {
+      path: configPath,
+      exists: false,
+    };
+  }
+
+  return {
+    path: configPath,
+    exists: true,
+    size: stats.size,
+    mtimeMs: stats.mtimeMs,
+    ctimeMs: stats.ctimeMs,
+  };
+}
+
+function configFileSignaturesEqual(
+  a: ConfigFileSignature,
+  b: ConfigFileSignature,
+): boolean {
+  if (a.path !== b.path || a.exists !== b.exists) return false;
+  if (!a.exists || !b.exists) return true;
+  return (
+    a.size === b.size && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs
+  );
+}
+
+function getCachedConfigIfFresh(): AssistantConfig | null {
+  if (!cached || !cachedFileSignature) return null;
+
+  const currentSignature = readConfigFileSignature(getConfigPath());
+  if (configFileSignaturesEqual(cachedFileSignature, currentSignature)) {
+    return cached;
+  }
+
+  cached = null;
+  cachedFileSignature = null;
+  return null;
+}
+
 /**
  * Parse a raw config through the Zod schema, applying all nested defaults.
  *
@@ -49,6 +106,38 @@ function cloneDefaultConfig(): AssistantConfig {
   return applyNestedDefaults({});
 }
 
+/**
+ * Returns deployment-context-aware config defaults that override schema
+ * defaults for platform-managed assistants. Only applied when initializing
+ * a fresh config (config.json does not yet exist).
+ *
+ * IS_PLATFORM is set by the Vellum platform launcher for all hosted
+ * assistant deployments. Local, Docker, and bare-metal assistants are
+ * unaffected.
+ */
+function getDeploymentContextDefaults(): Record<string, unknown> {
+  if (process.env.IS_PLATFORM !== "true" && process.env.IS_PLATFORM !== "1") {
+    return {};
+  }
+  const managed = { mode: "managed" as const };
+  return {
+    services: {
+      inference: managed,
+      "image-generation": managed,
+      "web-search": managed,
+      "google-oauth": managed,
+      "outlook-oauth": managed,
+      "linear-oauth": managed,
+      "github-oauth": managed,
+      "notion-oauth": managed,
+      "asana-oauth": managed,
+      "todoist-oauth": managed,
+      "discord-oauth": managed,
+      "hubspot-oauth": managed,
+    },
+  };
+}
+
 /**
  * Build a filesystem-safe ISO-8601 timestamp for use in quarantine filenames.
  * Replaces `:` (invalid on Windows, confusing on macOS Finder) with `-` so the
@@ -237,6 +326,11 @@ const DEPRECATED_FIELDS: Record<string, string> = {
   "permissions.autoApproveUpTo":
     "permissions.autoApproveUpTo has been removed. The gateway now controls all " +
     "auto-approve thresholds. The field will be removed from your config file.",
+  "memory.jobs.batchSize":
+    "memory.jobs.batchSize has been removed. The memory job worker now uses " +
+    "per-lane concurrency caps (slowLlmConcurrency, fastConcurrency, " +
+    "embedConcurrency) instead of a single batch size. " +
+    "The field will be removed from your config file.",
 };
 
 /**
@@ -289,42 +383,6 @@ function deleteNestedKeyByDotPath(
   deleteNestedKey(obj, keys);
 }
 
-/**
- * Deep-merge missing keys from `defaults` into `target`.
- * Only adds keys that do not already exist in `target`; never overwrites.
- * Returns true if any key was added.
- */
-export function deepMergeMissing(
-  target: Record<string, unknown>,
-  defaults: Record<string, unknown>,
-): boolean {
-  let changed = false;
-  for (const key of Object.keys(defaults)) {
-    if (!(key in target)) {
-      target[key] = defaults[key];
-      changed = true;
-    } else if (
-      defaults[key] != null &&
-      typeof defaults[key] === "object" &&
-      !Array.isArray(defaults[key]) &&
-      target[key] != null &&
-      typeof target[key] === "object" &&
-      !Array.isArray(target[key])
-    ) {
-      // Recurse into nested objects
-      if (
-        deepMergeMissing(
-          target[key] as Record<string, unknown>,
-          defaults[key] as Record<string, unknown>,
-        )
-      ) {
-        changed = true;
-      }
-    }
-  }
-  return changed;
-}
-
 /**
  * Recursively strip `null` leaves from a plain-object value, returning a
  * deep clone with all `null`-valued keys removed at every nesting level.
@@ -346,6 +404,13 @@ function stripNullLeaves(value: unknown): unknown {
   return out;
 }
 
+function readPlainObject(value: unknown): Record<string, unknown> | null {
+  if (value == null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
 /**
  * Deep-merge `overrides` into `target`, overwriting leaf values.
  * Recursively merges nested objects; scalars and arrays from `overrides`
@@ -409,51 +474,32 @@ export function deepMergeOverwrite(
   }
 }
 
-/**
- * Read the existing config.json from disk, merge any missing schema-default
- * keys, and rewrite only when there is an effective change.
- */
-function backfillConfigDefaults(
-  configPath: string,
-  fullDefaults: Record<string, unknown>,
-): void {
-  let raw: unknown;
-  try {
-    raw = JSON.parse(readFileSync(configPath, "utf-8"));
-  } catch {
-    return; // Unreadable file — skip backfill
-  }
-
-  // Only backfill into plain objects (not arrays, strings, etc.)
-  if (raw == null || typeof raw !== "object" || Array.isArray(raw)) {
-    return;
-  }
+export type DefaultWorkspaceConfigMergeResult = {
+  providedLlmProfileNames: Set<string>;
+  providedLlmActiveProfile: boolean;
+};
 
-  deepMergeMissing(raw as Record<string, unknown>, fullDefaults);
-  // Compare serialized JSON to decide whether a write is needed.
-  // deepMergeMissing can report false-positive mutations (e.g. setting a key
-  // to a value identical to what was already there), so comparing the final
-  // JSON avoids a hot-loop where writing triggers the config-watcher which
-  // reloads and backfills again endlessly.
-  const newJson = JSON.stringify(raw, null, 2) + "\n";
-  const existingJson = readFileSync(configPath, "utf-8");
-  if (newJson !== existingJson) {
-    writeFileSync(configPath, newJson);
-    log.info("Backfilled missing config defaults in %s", configPath);
-  }
+function emptyDefaultWorkspaceConfigMergeResult(): DefaultWorkspaceConfigMergeResult {
+  return {
+    providedLlmProfileNames: new Set(),
+    providedLlmActiveProfile: false,
+  };
 }
 
 /**
  * Merge default workspace config from the file referenced by
  * VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH into the workspace config on disk.
  *
- * Called once at daemon startup (before the first loadConfig()) so the
- * defaults are persisted to the workspace config file alongside any
- * schema-level defaults that loadConfig() backfills.
+ * Called once at daemon startup (before the first loadConfig()) so platform
+ * overrides are persisted to disk before the daemon's first config read.
+ * Schema defaults are no longer materialized into the file on load — the
+ * in-memory `loadConfig()` cache applies them at access time instead.
  */
-export function mergeDefaultWorkspaceConfig(): void {
+export function mergeDefaultWorkspaceConfig(): DefaultWorkspaceConfigMergeResult {
   const defaultConfigPath = process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
-  if (!defaultConfigPath || !existsSync(defaultConfigPath)) return;
+  if (!defaultConfigPath || !existsSync(defaultConfigPath)) {
+    return emptyDefaultWorkspaceConfigMergeResult();
+  }
 
   let defaults: unknown;
   try {
@@ -464,7 +510,7 @@ export function mergeDefaultWorkspaceConfig(): void {
       "Failed to read default workspace config from %s",
       defaultConfigPath,
     );
-    return;
+    return emptyDefaultWorkspaceConfigMergeResult();
   }
 
   if (
@@ -472,16 +518,44 @@ export function mergeDefaultWorkspaceConfig(): void {
     typeof defaults !== "object" ||
     Array.isArray(defaults)
   ) {
-    return;
+    return emptyDefaultWorkspaceConfigMergeResult();
   }
 
+  const llmDefaults = readPlainObject(
+    (defaults as Record<string, unknown>).llm,
+  );
+  const providedProfiles = readPlainObject(llmDefaults?.profiles);
+  const mergeResult: DefaultWorkspaceConfigMergeResult = {
+    providedLlmProfileNames: new Set(
+      providedProfiles ? Object.keys(providedProfiles) : [],
+    ),
+    providedLlmActiveProfile:
+      llmDefaults != null &&
+      Object.prototype.hasOwnProperty.call(llmDefaults, "activeProfile"),
+  };
+
   const configPath = getConfigPath();
   let existing: Record<string, unknown> = {};
   if (existsSync(configPath)) {
     try {
       existing = JSON.parse(readFileSync(configPath, "utf-8"));
-    } catch {
-      // If existing config is corrupt, start fresh
+    } catch (err) {
+      quarantineCorruptConfig(configPath, err);
+      // After preserving the corrupt file, start fresh so the default overlay
+      // can still initialize a valid config for this startup.
+    }
+  }
+
+  if (mergeResult.providedLlmProfileNames.size > 0) {
+    // Default-config profile entries are authoritative fragments. Remove any
+    // old same-name profile first so recursive merge does not leave stale
+    // provider-specific leaves behind.
+    const existingLlm = readPlainObject(existing.llm);
+    const existingProfiles = readPlainObject(existingLlm?.profiles);
+    if (existingProfiles) {
+      for (const name of mergeResult.providedLlmProfileNames) {
+        delete existingProfiles[name];
+      }
     }
   }
 
@@ -492,6 +566,7 @@ export function mergeDefaultWorkspaceConfig(): void {
     mkdirSync(dir, { recursive: true });
   }
   writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n");
+  invalidateConfigCache();
 
   // Move the temp file into the workspace directory as a permanent record.
   // This prevents re-application on daemon restart (the env var still points
@@ -507,10 +582,13 @@ export function mergeDefaultWorkspaceConfig(): void {
   } catch {
     log.info("Merged default workspace config from %s", defaultConfigPath);
   }
+
+  return mergeResult;
 }
 
 export function loadConfig(): AssistantConfig {
-  if (cached) return cached;
+  const freshCached = getCachedConfigIfFresh();
+  if (freshCached) return freshCached;
 
   // Re-entrancy guard: log calls during loading (e.g. file-mode warning)
   // can trigger loadConfig again. Return defaults to break the cycle
@@ -587,35 +665,56 @@ export function loadConfig(): AssistantConfig {
       }
     }
 
-    // If the config file didn't exist, write the full defaults to disk so
-    // users can discover and edit all available options.
-    // If it existed, backfill any missing schema keys from defaults without
-    // overwriting existing user values.
-    try {
-      const dir = dirname(configPath);
-      if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-      }
-      // Strip dataDir (runtime-derived) from the persisted config
-      const { dataDir: _, ...persistable } = config;
-
-      if (!configFileExisted) {
+    // First-launch seed only: when config.json does not exist, write the full
+    // schema defaults to disk so users can discover and edit all available
+    // options. When the file already exists, leave it alone — disk represents
+    // user intent, while the in-memory `cached: AssistantConfig` (above) has
+    // all schema defaults applied via `applyNestedDefaults`/`validateWithSchema`,
+    // so consumers calling `getConfig().memory.v2.bm25_b` continue to receive
+    // the schema default whenever the field is absent on disk.
+    //
+    // The previous behavior — eagerly merging missing keys back into the file
+    // on every load — silently baked stale defaults into existing users'
+    // config.json. Once a default landed in the file, future schema-default
+    // changes were inert because the merge only filled absent keys and never
+    // reconciled existing values. Contract: disk = user intent, in-memory
+    // cache = effective values.
+    if (!configFileExisted) {
+      try {
+        const dir = dirname(configPath);
+        if (!existsSync(dir)) {
+          mkdirSync(dir, { recursive: true });
+        }
+        // Strip dataDir (runtime-derived) from the persisted config
+        const { dataDir: _, ...persistable } = config;
+
+        // Layer deployment context defaults on top of schema defaults.
+        // These are overrides the daemon derives from its environment (e.g.
+        // IS_PLATFORM → all service modes = "managed"). Schema defaults
+        // remain the fallback for non-platform deployments.
+        const contextDefaults = getDeploymentContextDefaults();
+        if (Object.keys(contextDefaults).length > 0) {
+          deepMergeOverwrite(
+            persistable as Record<string, unknown>,
+            contextDefaults,
+          );
+        }
         writeFileSync(configPath, JSON.stringify(persistable, null, 2) + "\n");
         log.info("Wrote default config to %s", configPath);
-      } else {
-        backfillConfigDefaults(configPath, persistable);
+      } catch (err) {
+        log.warn({ err }, "Failed to write default config file");
       }
-    } catch (err) {
-      log.warn({ err }, "Failed to write/backfill config file");
     }
 
     cached = config;
+    cachedFileSignature = readConfigFileSignature(configPath);
 
     loading = false;
     return config;
   } catch (err) {
     // Loading failed — clear cached so the next call retries
     cached = null;
+    cachedFileSignature = null;
     loading = false;
     throw err;
   }
@@ -636,15 +735,6 @@ function isManagedGeminiFFEnabled(config: AssistantConfig): boolean {
   }
 }
 
-export function saveConfig(config: AssistantConfig): void {
-  ensureMigratedDataDir();
-  const configPath = getConfigPath();
-
-  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-
-  cached = config;
-}
-
 export function getConfig(): AssistantConfig {
   return loadConfig();
 }
@@ -658,7 +748,8 @@ export function getConfig(): AssistantConfig {
  * workspace-existence check runs.
  */
 export function getConfigReadOnly(): AssistantConfig {
-  if (cached) return cached;
+  const freshCached = getCachedConfigIfFresh();
+  if (freshCached) return freshCached;
 
   const configPath = getConfigPath();
   let fileConfig: Record<string, unknown> = {};
@@ -675,6 +766,7 @@ export function getConfigReadOnly(): AssistantConfig {
 
 export function invalidateConfigCache(): void {
   cached = null;
+  cachedFileSignature = null;
   loading = false;
 }
 
@@ -712,6 +804,7 @@ export function saveRawConfig(config: Record<string, unknown>): void {
   writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
 
   cached = null; // invalidate cache
+  cachedFileSignature = null;
 }
 
 export function getNestedValue(

package/src/config/sanitize-for-transfer.ts

@@ -5,6 +5,7 @@
  * Fields removed or reset:
  * - `ingress.publicBaseUrl` → set to `""`
  * - `ingress.enabled` → deleted
+ * - `ingress.publicBaseUrlManagedBy` → deleted
  * - `daemon` → deleted entirely
  * - `skills.load.extraDirs` → set to `[]`
  * - `hostBrowser.cdpInspect.desktopAuto` → deleted **only when the source
@@ -41,6 +42,7 @@ export function sanitizeConfigForTransfer(configJson: string): string {
     const ingress = config.ingress as Record<string, unknown>;
     ingress.publicBaseUrl = "";
     delete ingress.enabled;
+    delete ingress.publicBaseUrlManagedBy;
   }
 
   // Strip daemon entirely

package/src/config/schemas/__tests__/memory-lifecycle.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, test } from "bun:test";
+
+import { MemoryJobsConfigSchema } from "../memory-lifecycle.js";
+
+describe("MemoryJobsConfigSchema", () => {
+  test("parses an empty object to documented defaults", () => {
+    const parsed = MemoryJobsConfigSchema.parse({});
+    expect(parsed).toEqual({
+      workerConcurrency: 2,
+      stalledJobTimeoutMs: 30 * 60 * 1000,
+      slowLlmConcurrency: 1,
+      fastConcurrency: 2,
+      embedConcurrency: 2,
+    });
+  });
+
+  test("derives lane caps from workerConcurrency when only it is set", () => {
+    const parsed = MemoryJobsConfigSchema.parse({ workerConcurrency: 4 });
+    expect(parsed.workerConcurrency).toBe(4);
+    expect(parsed.slowLlmConcurrency).toBe(2);
+    expect(parsed.fastConcurrency).toBe(4);
+    expect(parsed.embedConcurrency).toBe(4);
+  });
+
+  test("floors and clamps slowLlmConcurrency to at least 1 when deriving", () => {
+    const parsed = MemoryJobsConfigSchema.parse({ workerConcurrency: 1 });
+    expect(parsed.slowLlmConcurrency).toBe(1);
+    expect(parsed.fastConcurrency).toBe(1);
+    expect(parsed.embedConcurrency).toBe(1);
+  });
+
+  test("explicit lane cap overrides the derivation", () => {
+    const parsed = MemoryJobsConfigSchema.parse({
+      workerConcurrency: 4,
+      slowLlmConcurrency: 1,
+    });
+    expect(parsed.slowLlmConcurrency).toBe(1);
+    expect(parsed.fastConcurrency).toBe(4);
+    expect(parsed.embedConcurrency).toBe(4);
+  });
+
+  test("explicit lane caps without workerConcurrency keep workerConcurrency default", () => {
+    const parsed = MemoryJobsConfigSchema.parse({
+      slowLlmConcurrency: 3,
+      fastConcurrency: 5,
+      embedConcurrency: 7,
+    });
+    expect(parsed.workerConcurrency).toBe(2);
+    expect(parsed.slowLlmConcurrency).toBe(3);
+    expect(parsed.fastConcurrency).toBe(5);
+    expect(parsed.embedConcurrency).toBe(7);
+  });
+
+  test.each([
+    "slowLlmConcurrency",
+    "fastConcurrency",
+    "embedConcurrency",
+    "workerConcurrency",
+  ] as const)("rejects %s = 0", (field) => {
+    expect(() => MemoryJobsConfigSchema.parse({ [field]: 0 })).toThrow();
+  });
+
+  test.each([
+    "slowLlmConcurrency",
+    "fastConcurrency",
+    "embedConcurrency",
+    "workerConcurrency",
+  ] as const)("rejects negative %s", (field) => {
+    expect(() => MemoryJobsConfigSchema.parse({ [field]: -1 })).toThrow();
+  });
+
+  test.each([
+    "slowLlmConcurrency",
+    "fastConcurrency",
+    "embedConcurrency",
+    "workerConcurrency",
+  ] as const)("rejects non-integer %s", (field) => {
+    expect(() => MemoryJobsConfigSchema.parse({ [field]: 1.5 })).toThrow();
+  });
+});

package/src/config/schemas/__tests__/memory-v2.test.ts

@@ -7,7 +7,7 @@ describe("MemoryV2ConfigSchema", () => {
   test("parses an empty object to documented defaults", () => {
     const parsed = MemoryV2ConfigSchema.parse({});
     expect(parsed).toEqual({
-      enabled: false,
+      enabled: true,
       sweep_enabled: false,
       d: 0.3,
       c_user: 0.3,
@@ -15,14 +15,23 @@ describe("MemoryV2ConfigSchema", () => {
       c_now: 0.2,
       k: 0.5,
       hops: 2,
-      top_k: 20,
-      top_k_skills: 5,
+      top_k: 25,
+      ann_candidate_limit: null,
       epsilon: 0.01,
-      dense_weight: 0.7,
-      sparse_weight: 0.3,
+      dense_weight: 0.85,
+      sparse_weight: 0.15,
+      bm25_k1: 1.2,
+      bm25_b: 0.4,
       consolidation_interval_hours: 4,
       max_page_chars: 5000,
       consolidation_prompt_path: null,
+      rerank: {
+        enabled: false,
+        top_k: 50,
+        alpha: 0.3,
+        model: "Alibaba-NLP/gte-reranker-modernbert-base",
+        dtype: "q8",
+      },
     });
   });
 
@@ -152,12 +161,11 @@ describe("MemoryConfigSchema integration with v2 block", () => {
   test("parses an empty memory config and includes a v2 block with defaults", () => {
     const parsed = MemoryConfigSchema.parse({});
     expect(parsed.v2).toBeDefined();
-    expect(parsed.v2.enabled).toBe(false);
+    expect(parsed.v2.enabled).toBe(true);
     expect(parsed.v2.sweep_enabled).toBe(false);
     expect(parsed.v2.d).toBe(0.3);
-    expect(parsed.v2.dense_weight).toBe(0.7);
-    expect(parsed.v2.sparse_weight).toBe(0.3);
-    expect(parsed.v2.top_k_skills).toBe(5);
+    expect(parsed.v2.dense_weight).toBe(0.85);
+    expect(parsed.v2.sparse_weight).toBe(0.15);
     expect(parsed.v2.consolidation_interval_hours).toBe(4);
     expect(parsed.v2.max_page_chars).toBe(5000);
   });

package/src/config/schemas/call-site-catalog.ts

@@ -264,6 +264,20 @@ const CATALOG_RECORD: CatalogRecord = {
     description: "General-purpose LLM inference call site for skill use.",
     domain: "skills",
   },
+  proactiveArtifactDecision: {
+    id: "proactiveArtifactDecision",
+    displayName: "Proactive Artifact Decision",
+    description:
+      "Decides what personalized artifact to build for new users based on conversation context.",
+    domain: "agentLoop",
+  },
+  proactiveArtifactBuild: {
+    id: "proactiveArtifactBuild",
+    displayName: "Proactive Artifact Build",
+    description:
+      "Builds the personalized artifact in a background conversation with tool access.",
+    domain: "agentLoop",
+  },
 };
 
 // Source of truth for call-site display metadata. API responses and usage

package/src/config/schemas/calls.ts

@@ -232,12 +232,3 @@ export const CallsConfigSchema = z
   .describe(
     "Phone call configuration — controls telephony, voice, safety, and call behavior",
   );
-
-export type CallsConfig = z.infer<typeof CallsConfigSchema>;
-export type CallsDisclosureConfig = z.infer<typeof CallsDisclosureConfigSchema>;
-export type CallsSafetyConfig = z.infer<typeof CallsSafetyConfigSchema>;
-export type CallsVoiceConfig = z.infer<typeof CallsVoiceConfigSchema>;
-export type CallerIdentityConfig = z.infer<typeof CallerIdentityConfigSchema>;
-export type CallsVerificationConfig = z.infer<
-  typeof CallsVerificationConfigSchema
->;

package/src/config/schemas/channels.ts

@@ -121,8 +121,3 @@ export const SlackConfigSchema = z
       .describe("Slack bot display name"),
   })
   .describe("Slack channel configuration");
-
-export type TwilioConfig = z.infer<typeof TwilioConfigSchema>;
-export type WhatsAppConfig = z.infer<typeof WhatsAppConfigSchema>;
-export type TelegramConfig = z.infer<typeof TelegramConfigSchema>;
-export type SlackConfig = z.infer<typeof SlackConfigSchema>;