@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/tts/provider-catalog.ts

@@ -55,12 +55,21 @@ interface TtsProviderCatalogCapabilities {
   readonly supportedFormats: readonly string[];
 }
 
+/**
+ * Link to a provider's API-key management page, shown in settings UI.
+ */
+interface TtsCredentialsGuide {
+  readonly description: string;
+  readonly url: string;
+  readonly linkLabel: string;
+}
+
 /**
  * A single entry in the TTS provider catalog.
  *
  * Captures everything the system needs to know about a provider at a
  * metadata level — identity, display name, telephony call mode,
- * capabilities, and secret requirements.
+ * capabilities, secret requirements, and client-facing display metadata.
  */
 interface TtsProviderCatalogEntry {
   /** Unique provider identifier matching {@link TtsProviderId}. */
@@ -69,6 +78,18 @@ interface TtsProviderCatalogEntry {
   /** Human-readable name for display in settings UI and logs. */
   readonly displayName: string;
 
+  /** Short description shown beneath the provider name in settings UI. */
+  readonly subtitle: string;
+
+  /** Whether the provider supports user-chosen voice IDs. */
+  readonly supportsVoiceSelection: boolean;
+
+  /** Placeholder text for the API-key input in settings UI. */
+  readonly apiKeyPlaceholder: string;
+
+  /** Link to the provider's API-key management page. */
+  readonly credentialsGuide: TtsCredentialsGuide;
+
   /** How this provider integrates with the telephony call path. */
   readonly callMode: TtsCallMode;
 
@@ -106,6 +127,16 @@ const CATALOG: readonly TtsProviderCatalogEntry[] = [
   {
     id: "elevenlabs",
     displayName: "ElevenLabs",
+    subtitle:
+      "High-quality voice synthesis for conversations and read-aloud. Requires an ElevenLabs API key.",
+    supportsVoiceSelection: true,
+    apiKeyPlaceholder: "sk_…",
+    credentialsGuide: {
+      description:
+        "Sign in to ElevenLabs, go to your Profile, and copy your API key.",
+      url: "https://elevenlabs.io/app/settings/api-keys",
+      linkLabel: "Open ElevenLabs API Keys",
+    },
     callMode: "native-twilio",
     allowNativeFallback: true,
     capabilities: {
@@ -124,6 +155,16 @@ const CATALOG: readonly TtsProviderCatalogEntry[] = [
   {
     id: "fish-audio",
     displayName: "Fish Audio",
+    subtitle:
+      "Natural-sounding voice synthesis with custom voice cloning. Requires a Fish Audio API key and voice reference ID.",
+    supportsVoiceSelection: true,
+    apiKeyPlaceholder: "Enter your Fish Audio API key",
+    credentialsGuide: {
+      description:
+        "Sign in to Fish Audio, navigate to API Keys in your dashboard, and create a new key.",
+      url: "https://fish.audio/app/api-keys/",
+      linkLabel: "Open Fish Audio API Keys",
+    },
     callMode: "synthesized-play",
     allowNativeFallback: true,
     capabilities: {
@@ -142,6 +183,16 @@ const CATALOG: readonly TtsProviderCatalogEntry[] = [
   {
     id: "deepgram",
     displayName: "Deepgram",
+    subtitle:
+      "Fast, accurate text-to-speech synthesis. Uses the same API key as Deepgram speech-to-text.",
+    supportsVoiceSelection: false,
+    apiKeyPlaceholder: "Enter your Deepgram API key",
+    credentialsGuide: {
+      description:
+        "Sign in to Deepgram, navigate to your API Keys page, and create or copy an existing key. This is the same key used for speech-to-text.",
+      url: "https://console.deepgram.com/",
+      linkLabel: "Open Deepgram Console",
+    },
     callMode: "synthesized-play",
     allowNativeFallback: false,
     capabilities: {
@@ -159,6 +210,16 @@ const CATALOG: readonly TtsProviderCatalogEntry[] = [
   {
     id: "xai",
     displayName: "xAI",
+    subtitle:
+      "Text-to-speech from xAI with expressive voices (eve, ara, rex, sal, leo). Requires an xAI API key.",
+    supportsVoiceSelection: false,
+    apiKeyPlaceholder: "Enter your xAI API key",
+    credentialsGuide: {
+      description:
+        "Sign in to the xAI console, navigate to API Keys, and create a new key.",
+      url: "https://console.x.ai/",
+      linkLabel: "Open xAI Console",
+    },
     callMode: "synthesized-play",
     allowNativeFallback: false,
     capabilities: {
@@ -199,6 +260,20 @@ export function listCatalogProviderIds(): TtsProviderId[] {
   return CATALOG.map((entry) => entry.id);
 }
 
+/**
+ * List all catalog providers projected to client-facing display fields only.
+ */
+export function listCatalogProvidersForDisplay() {
+  return CATALOG.map((e) => ({
+    id: e.id,
+    displayName: e.displayName,
+    subtitle: e.subtitle,
+    supportsVoiceSelection: e.supportsVoiceSelection,
+    apiKeyPlaceholder: e.apiKeyPlaceholder,
+    credentialsGuide: e.credentialsGuide,
+  }));
+}
+
 /**
  * Look up a catalog entry by provider ID.
  *

package/src/util/mutex.ts

@@ -0,0 +1,47 @@
+/**
+ * Async mutex for serializing access to a shared resource.
+ *
+ * Callers wait in FIFO order. `withLock(fn)` is the primary API —
+ * it acquires the lock, runs `fn`, and releases the lock when `fn`
+ * settles (even on throw).
+ *
+ * Used by git-service (per-workspace repo operations) and
+ * conversation-title-service (serial LLM calls) to prevent
+ * concurrent access to resources that cannot safely overlap.
+ */
+export class Mutex {
+  private locked = false;
+  private waitQueue: Array<() => void> = [];
+
+  async acquire(): Promise<void> {
+    if (!this.locked) {
+      this.locked = true;
+      return;
+    }
+    await new Promise<void>((resolve) => {
+      this.waitQueue.push(resolve);
+    });
+  }
+
+  release(): void {
+    const next = this.waitQueue.shift();
+    if (next) {
+      next();
+    } else {
+      this.locked = false;
+    }
+  }
+
+  /**
+   * Execute `fn` while holding the lock.
+   * Automatically releases the lock when done, even if `fn` throws.
+   */
+  async withLock<T>(fn: () => Promise<T>): Promise<T> {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+}

package/src/workspace/git-service.ts

@@ -12,6 +12,7 @@ import { promisify } from "node:util";
 
 import { getConfig } from "../config/loader.js";
 import { getLogger } from "../util/logger.js";
+import { Mutex } from "../util/mutex.js";
 import { PromiseGuard } from "../util/promise-guard.js";
 
 const execFileAsync = promisify(execFile);
@@ -119,48 +120,6 @@ interface ExecError extends Error {
   code?: string | number;
 }
 
-/**
- * Simple mutex implementation for per-workspace git operation serialization.
- * Prevents concurrent git operations from corrupting the repository state.
- */
-class Mutex {
-  private locked = false;
-  private waitQueue: Array<() => void> = [];
-
-  async acquire(): Promise<void> {
-    if (!this.locked) {
-      this.locked = true;
-      return;
-    }
-    // Wait for the lock to be released
-    await new Promise<void>((resolve) => {
-      this.waitQueue.push(resolve);
-    });
-  }
-
-  release(): void {
-    const next = this.waitQueue.shift();
-    if (next) {
-      next();
-    } else {
-      this.locked = false;
-    }
-  }
-
-  /**
-   * Execute a function while holding the lock.
-   * Automatically releases the lock when done, even if the function throws.
-   */
-  async withLock<T>(fn: () => Promise<T>): Promise<T> {
-    await this.acquire();
-    try {
-      return await fn();
-    } finally {
-      this.release();
-    }
-  }
-}
-
 interface GitCommitMetadata {
   /** Optional metadata to include in the commit message or as git notes */
   [key: string]: unknown;

package/src/workspace/migrations/051-seed-conversation-summarization-callsite.ts

@@ -9,10 +9,9 @@ import type { WorkspaceMigration } from "./types.js";
  * `conversationSummarization` is invoked from `ContextWindowManager.
  * updateSummary()` during mid-loop compaction. Without a call-site entry it
  * falls through to `llm.default` (opus + `effort: "max"` + `thinking:
- * { enabled: true }` + `maxTokens: 64000`), which is far too expensive for
- * summarizing a ~150k-token transcript inside the agent-loop plugin
- * pipeline's 30s budget — we were hitting `PluginTimeoutError` and hard-
- * failing the turn.
+ * { enabled: true }` + `maxTokens: 64000`), which is far too expensive and
+ * slow for summarizing a ~150k-token transcript inside the agent loop —
+ * the summary call would stall the turn.
  *
  * This migration seeds `effort: "low"` and `thinking: { enabled: false }`
  * (and opus-4.7 as the model when absent) so the summary call runs cheaply
@@ -99,7 +98,7 @@ export const seedConversationSummarizationCallsiteMigration: WorkspaceMigration
     },
     down(_workspaceDir: string): void {
       // Forward-only: removing the seeded defaults would reintroduce the
-      // 30s pipeline-budget timeout this migration fixes.
+      // expensive, slow summary call this migration fixes.
     },
   };
 

package/src/workspace/migrations/095-bump-heartbeat-interval-30m-to-60m.ts

@@ -0,0 +1,51 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+const THIRTY_MINUTES_MS = 30 * 60 * 1000;
+const SIXTY_MINUTES_MS = 60 * 60 * 1000;
+
+/**
+ * Bump persisted heartbeat default from 30 minutes to 60 minutes.
+ *
+ * Migration 065 moved legacy 3h/6h defaults to 30 minutes. The schema default
+ * has since been raised to 60 minutes, but existing users whose config.json
+ * already has 1800000 persisted won't pick up the new default. This migration
+ * idempotently updates those configs.
+ */
+export const bumpHeartbeatInterval30mTo60mMigration: WorkspaceMigration = {
+  id: "095-bump-heartbeat-interval-30m-to-60m",
+  description:
+    "Bump persisted heartbeat.intervalMs from 30 minutes to 60 minutes",
+  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 heartbeat = config.heartbeat;
+    if (!heartbeat || typeof heartbeat !== "object" || Array.isArray(heartbeat))
+      return;
+
+    const heartbeatConfig = heartbeat as Record<string, unknown>;
+    const intervalMs = heartbeatConfig.intervalMs;
+    if (typeof intervalMs !== "number" || intervalMs !== THIRTY_MINUTES_MS) {
+      return;
+    }
+
+    heartbeatConfig.intervalMs = SIXTY_MINUTES_MS;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only: cannot distinguish users who explicitly chose 60 minutes
+    // from those migrated by this migration.
+  },
+};

package/src/workspace/migrations/096-reduce-quality-profile-effort.ts

@@ -0,0 +1,72 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+// Reduce effort from "max" to "high" on the quality-optimized profile.
+//
+// With adaptive thinking enabled, the effort parameter acts as a nudge for
+// how much thinking the model does. "max" means "always think with no
+// constraints on thinking depth", which defeats adaptive thinking's ability
+// to skip or minimize thinking for simple queries. "high" (the API default)
+// means "almost always thinks, deep reasoning on complex tasks" — letting
+// adaptive thinking decide when full-depth reasoning is actually needed.
+//
+// This migration patches both managed and user quality-optimized profiles
+// that still have effort: "max". It only downgrades "max" → "high"; any
+// other effort value is preserved.
+
+const TARGET_PROFILES = ["quality-optimized", "custom-quality-optimized"];
+
+export const reduceQualityProfileEffortMigration: WorkspaceMigration = {
+  id: "096-reduce-quality-profile-effort",
+  description:
+    'Reduce effort from "max" to "high" on quality-optimized profiles to let adaptive thinking work',
+  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 profiles = readObject(llm.profiles);
+    if (profiles === null) return;
+
+    let changed = false;
+
+    for (const name of TARGET_PROFILES) {
+      const profile = readObject(profiles[name]);
+      if (profile === null) continue;
+      if (profile.effort !== "max") continue;
+
+      profile.effort = "high";
+      profiles[name] = profile;
+      changed = true;
+    }
+
+    if (changed) {
+      llm.profiles = profiles;
+      config.llm = llm;
+      writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    }
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only.
+  },
+};
+
+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/097-enable-adaptive-thinking-managed-profiles.ts

@@ -0,0 +1,117 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+// Enable adaptive thinking on the managed "balanced" and "quality-optimized"
+// profiles for existing platform instances.
+//
+// The assistant-side seed defaults (MANAGED_PROFILE_TEMPLATES in
+// seed-inference-profiles.ts) already ship thinking: { enabled: true,
+// streamThinking: true } for both profiles, which normalizes to
+// { type: "adaptive" } on the wire. Off-platform (BYOK) instances pick this
+// up on every boot because the seeder overwrites managed profiles. On-platform
+// instances preserve existing profiles (the platform overlay is authoritative),
+// so instances that were hatched before thinking was enabled in the templates
+// are stuck with thinking disabled or absent.
+//
+// This migration patches the on-disk config for both profiles, adding
+// thinking: { enabled: true, streamThinking: true } where it's missing or
+// explicitly disabled. It skips profiles that:
+//   - Don't exist (no profile to patch)
+//   - Already have thinking enabled (idempotent)
+//   - Are source: "user" (user-created profiles are untouched)
+//   - Have a non-managed, non-absent source (unknown origin)
+//   - Use a non-Anthropic provider (adaptive thinking is Anthropic-specific)
+
+const ADAPTIVE_THINKING = { enabled: true, streamThinking: true } as const;
+const TARGET_PROFILES = ["balanced", "quality-optimized"] as const;
+
+/**
+ * Patch managed Anthropic profiles that are missing adaptive thinking.
+ *
+ * Exported so lifecycle.ts can re-run the repair after mergeDefaultWorkspaceConfig()
+ * and seedInferenceProfiles(). On-platform instances with a config overlay have their
+ * profiles overwritten by the overlay merge (which runs after workspace migrations),
+ * so the migration alone is insufficient — the post-overlay call ensures the repair
+ * sticks even when the overlay supplies profiles without thinking enabled.
+ *
+ * The function is idempotent: profiles that already have thinking enabled are skipped.
+ */
+export function repairAdaptiveThinkingOnManagedProfiles(
+  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 profiles = readObject(llm.profiles);
+  if (profiles === null) return;
+
+  let changed = false;
+
+  for (const name of TARGET_PROFILES) {
+    const profile = readObject(profiles[name]);
+    if (profile === null) continue;
+
+    // Only patch managed Anthropic profiles.
+    // Legacy profiles created before the `source` metadata field was introduced
+    // have source=undefined. Treat these as managed when the profile name is one
+    // of the canonical managed names (which TARGET_PROFILES already guarantees)
+    // and the provider is Anthropic (or absent). Explicit `source: "user"`
+    // profiles are always skipped.
+    if (profile.source === "user") continue;
+    if (profile.source !== undefined && profile.source !== "managed") continue;
+    if (
+      typeof profile.provider === "string" &&
+      profile.provider !== "anthropic"
+    ) {
+      continue;
+    }
+
+    // Skip if thinking is already enabled.
+    const thinking = readObject(profile.thinking);
+    if (thinking !== null && thinking.enabled === true) continue;
+
+    profile.thinking = { ...ADAPTIVE_THINKING };
+    profiles[name] = profile;
+    changed = true;
+  }
+
+  if (changed) {
+    llm.profiles = profiles;
+    config.llm = llm;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  }
+}
+
+export const enableAdaptiveThinkingManagedProfilesMigration: WorkspaceMigration =
+  {
+    id: "097-enable-adaptive-thinking-managed-profiles",
+    description:
+      "Enable adaptive thinking on managed balanced and quality-optimized profiles",
+    run(workspaceDir: string): void {
+      repairAdaptiveThinkingOnManagedProfiles(workspaceDir);
+    },
+    down(_workspaceDir: string): void {
+      // Forward-only.
+    },
+  };
+
+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/registry.ts

@@ -92,6 +92,9 @@ import { retightenMigrationOnboardingThreadMigration } from "./091-retighten-mig
 import { backfillV3LeavesMigration } from "./092-backfill-v3-leaves.js";
 import { backfillLeafIdsMigration } from "./093-backfill-leaf-ids.js";
 import { seedAvatarManifestMigration } from "./094-seed-avatar-manifest.js";
+import { bumpHeartbeatInterval30mTo60mMigration } from "./095-bump-heartbeat-interval-30m-to-60m.js";
+import { reduceQualityProfileEffortMigration } from "./096-reduce-quality-profile-effort.js";
+import { enableAdaptiveThinkingManagedProfilesMigration } from "./097-enable-adaptive-thinking-managed-profiles.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -195,4 +198,7 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   backfillV3LeavesMigration,
   backfillLeafIdsMigration,
   seedAvatarManifestMigration,
+  bumpHeartbeatInterval30mTo60mMigration,
+  reduceQualityProfileEffortMigration,
+  enableAdaptiveThinkingManagedProfilesMigration,
 ];