@vellumai/assistant 0.6.2 → 0.6.4

package/src/config/loader.ts

@@ -11,22 +11,13 @@ import { dirname, join } from "node:path";
 import { ConfigError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import { ensureDataDir, getWorkspaceConfigPath } from "../util/platform.js";
+import { isAssistantFeatureFlagEnabled } from "./assistant-feature-flags.js";
 import { AssistantConfigSchema } from "./schema.js";
 import type { AssistantConfig } from "./types.js";
 
-const log = getLogger("config");
+export { API_KEY_PROVIDERS } from "../providers/provider-secret-catalog.js";
 
-// Providers that store API keys in secure storage (superset of VALID_PROVIDERS)
-export const API_KEY_PROVIDERS = [
-  "anthropic",
-  "openai",
-  "gemini",
-  "ollama",
-  "fireworks",
-  "openrouter",
-  "brave",
-  "perplexity",
-] as const;
+const log = getLogger("config");
 
 let cached: AssistantConfig | null = null;
 let loading = false;
@@ -385,7 +376,46 @@ export function loadConfig(): AssistantConfig {
     warnAndStripDeprecatedFields(fileConfig, configPath);
 
     // Validate and apply defaults via Zod schema
-    const config = validateWithSchema(fileConfig);
+    let config = validateWithSchema(fileConfig);
+
+    // Managed Gemini embedding defaults migration.
+    // When on a managed platform (IS_PLATFORM=true) with the feature flag
+    // enabled and no explicit embedding provider chosen (provider=auto),
+    // persist Gemini embedding defaults into the raw config file.
+    // Idempotent: once provider=gemini is written, subsequent loads skip this.
+    if (config.memory.embeddings.provider === "auto") {
+      try {
+        if (
+          (process.env.IS_PLATFORM === "true" ||
+            process.env.IS_PLATFORM === "1") &&
+          isManagedGeminiFFEnabled(config)
+        ) {
+          setNestedValue(fileConfig, "memory.embeddings.provider", "gemini");
+          setNestedValue(
+            fileConfig,
+            "memory.embeddings.geminiModel",
+            "gemini-embedding-2-preview",
+          );
+          setNestedValue(
+            fileConfig,
+            "memory.embeddings.geminiDimensions",
+            3072,
+          );
+          setNestedValue(fileConfig, "memory.qdrant.vectorSize", 3072);
+          writeFileSync(configPath, JSON.stringify(fileConfig, null, 2) + "\n");
+          log.info(
+            "Applied managed Gemini embedding defaults (provider=gemini, model=gemini-embedding-2-preview, dimensions=3072, vectorSize=3072)",
+          );
+          // Re-validate so the returned config reflects the migration.
+          config = validateWithSchema(fileConfig);
+        }
+      } catch (err) {
+        log.warn(
+          { err },
+          "Managed Gemini defaults migration failed — continuing with existing config",
+        );
+      }
+    }
 
     // If the config file didn't exist, write the full defaults to disk so
     // users can discover and edit all available options.
@@ -421,6 +451,21 @@ export function loadConfig(): AssistantConfig {
   }
 }
 
+/**
+ * Check whether the managed-gemini-embeddings-enabled feature flag is on.
+ * Wrapped in a try/catch so a flag-resolver failure never breaks config loading.
+ */
+function isManagedGeminiFFEnabled(config: AssistantConfig): boolean {
+  try {
+    return isAssistantFeatureFlagEnabled(
+      "managed-gemini-embeddings-enabled",
+      config,
+    );
+  } catch {
+    return false;
+  }
+}
+
 export function saveConfig(config: AssistantConfig): void {
   ensureMigratedDataDir();
   const configPath = getConfigPath();
@@ -434,6 +479,30 @@ export function getConfig(): AssistantConfig {
   return loadConfig();
 }
 
+/**
+ * Read-only config accessor: returns the current config without creating
+ * directories or writing files. Reads config.json if it exists on disk;
+ * returns schema defaults otherwise. Unlike `getConfig()` / `loadConfig()`,
+ * this never calls `ensureDataDir()` or writes a default config to disk,
+ * making it safe to call during CLI program construction before the
+ * workspace-existence check runs.
+ */
+export function getConfigReadOnly(): AssistantConfig {
+  if (cached) return cached;
+
+  const configPath = getConfigPath();
+  let fileConfig: Record<string, unknown> = {};
+  if (existsSync(configPath)) {
+    try {
+      fileConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+    } catch {
+      return cloneDefaultConfig();
+    }
+  }
+
+  return validateWithSchema(fileConfig);
+}
+
 export function invalidateConfigCache(): void {
   cached = null;
   loading = false;

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

@@ -0,0 +1,47 @@
+/**
+ * Strips environment-specific fields from config JSON before transferring
+ * between local and platform environments (teleport/restore).
+ *
+ * Fields removed or reset:
+ * - `ingress.publicBaseUrl` → set to `""`
+ * - `ingress.enabled` → deleted
+ * - `daemon` → deleted entirely
+ * - `skills.load.extraDirs` → set to `[]`
+ */
+export function sanitizeConfigForTransfer(configJson: string): string {
+  let config: Record<string, unknown>;
+  try {
+    const parsed = JSON.parse(configJson);
+    if (
+      typeof parsed !== "object" ||
+      parsed === null ||
+      Array.isArray(parsed)
+    ) {
+      return configJson;
+    }
+    config = parsed;
+  } catch {
+    return configJson;
+  }
+
+  // Strip ingress environment-specific fields
+  if (config.ingress && typeof config.ingress === "object") {
+    const ingress = config.ingress as Record<string, unknown>;
+    ingress.publicBaseUrl = "";
+    delete ingress.enabled;
+  }
+
+  // Strip daemon entirely
+  delete config.daemon;
+
+  // Strip skills.load.extraDirs
+  if (config.skills && typeof config.skills === "object") {
+    const skills = config.skills as Record<string, unknown>;
+    if (skills.load && typeof skills.load === "object") {
+      const load = skills.load as Record<string, unknown>;
+      load.extraDirs = [];
+    }
+  }
+
+  return JSON.stringify(config, null, 2) + "\n";
+}

package/src/config/schema.ts

@@ -10,6 +10,10 @@ export {
 } from "../permissions/permission-mode.js";
 export type { AcpAgentConfig, AcpConfig } from "./acp-schema.js";
 export { AcpAgentConfigSchema, AcpConfigSchema } from "./acp-schema.js";
+export type { AnalysisConfig } from "./schemas/analysis.js";
+export { AnalysisConfigSchema } from "./schemas/analysis.js";
+export type { BackupConfig, BackupDestination } from "./schemas/backup.js";
+export { BackupConfigSchema } from "./schemas/backup.js";
 export type {
   CallerIdentityConfig,
   CallsConfig,
@@ -39,16 +43,22 @@ export {
   TwilioConfigSchema,
   WhatsAppConfigSchema,
 } from "./schemas/channels.js";
-export type { ElevenLabsConfig } from "./schemas/elevenlabs.js";
 export {
   DEFAULT_ELEVENLABS_VOICE_ID,
-  ElevenLabsConfigSchema,
   VALID_CONVERSATION_TIMEOUTS,
 } from "./schemas/elevenlabs.js";
-export type { FishAudioConfig } from "./schemas/fish-audio.js";
-export { FishAudioConfigSchema } from "./schemas/fish-audio.js";
 export type { HeartbeatConfig } from "./schemas/heartbeat.js";
 export { HeartbeatConfigSchema } from "./schemas/heartbeat.js";
+export type {
+  DesktopAutoCdpInspectConfig,
+  HostBrowserCdpInspectConfig,
+  HostBrowserConfig,
+} from "./schemas/host-browser.js";
+export {
+  DesktopAutoCdpInspectConfigSchema,
+  HostBrowserCdpInspectConfigSchema,
+  HostBrowserConfigSchema,
+} from "./schemas/host-browser.js";
 export type {
   ContextOverflowRecoveryConfig,
   ContextWindowConfig,
@@ -115,6 +125,7 @@ export {
 export type { MemoryRetrievalConfig } from "./schemas/memory-retrieval.js";
 export {
   MemoryDynamicBudgetConfigSchema,
+  MemoryInjectionConfigSchema,
   MemoryRetrievalConfigSchema,
 } from "./schemas/memory-retrieval.js";
 export type {
@@ -139,8 +150,6 @@ export {
   PlatformConfigSchema,
   UiConfigSchema,
 } from "./schemas/platform.js";
-export type { SandboxConfig } from "./schemas/sandbox.js";
-export { SandboxConfigSchema } from "./schemas/sandbox.js";
 export type {
   PermissionsConfig,
   SecretDetectionConfig,
@@ -185,16 +194,41 @@ export {
   SkillsInstallConfigSchema,
   SkillsLoadConfigSchema,
 } from "./schemas/skills.js";
+export type { SttProviders, SttService } from "./schemas/stt.js";
+export {
+  SttProvidersSchema,
+  SttServiceSchema,
+  VALID_STT_PROVIDERS,
+} from "./schemas/stt.js";
 export type { RateLimitConfig, TimeoutConfig } from "./schemas/timeouts.js";
 export {
   RateLimitConfigSchema,
   TimeoutConfigSchema,
 } from "./schemas/timeouts.js";
+export type {
+  TtsDeepgramProviderConfig,
+  TtsElevenLabsProviderConfig,
+  TtsFishAudioProviderConfig,
+  TtsProviders,
+  TtsService,
+} from "./schemas/tts.js";
+export {
+  TtsDeepgramProviderConfigSchema,
+  TtsElevenLabsProviderConfigSchema,
+  TtsFishAudioProviderConfigSchema,
+  TtsProvidersSchema,
+  TtsServiceSchema,
+  VALID_TTS_PROVIDERS as VALID_TTS_SERVICE_PROVIDERS,
+} from "./schemas/tts.js";
+export type { UpdatesConfig } from "./schemas/updates.js";
+export { UpdatesConfigSchema } from "./schemas/updates.js";
 export type { WorkspaceGitConfig } from "./schemas/workspace-git.js";
 export { WorkspaceGitConfigSchema } from "./schemas/workspace-git.js";
 
 // Imports for AssistantConfigSchema composition
 import { AcpConfigSchema } from "./acp-schema.js";
+import { AnalysisConfigSchema } from "./schemas/analysis.js";
+import { BackupConfigSchema } from "./schemas/backup.js";
 import { CallsConfigSchema } from "./schemas/calls.js";
 import {
   SlackConfigSchema,
@@ -202,10 +236,9 @@ import {
   TwilioConfigSchema,
   WhatsAppConfigSchema,
 } from "./schemas/channels.js";
-import { ElevenLabsConfigSchema } from "./schemas/elevenlabs.js";
 import { FilingConfigSchema } from "./schemas/filing.js";
-import { FishAudioConfigSchema } from "./schemas/fish-audio.js";
 import { HeartbeatConfigSchema } from "./schemas/heartbeat.js";
+import { HostBrowserConfigSchema } from "./schemas/host-browser.js";
 import {
   ContextWindowConfigSchema,
   EffortSchema,
@@ -227,7 +260,6 @@ import {
   PlatformConfigSchema,
   UiConfigSchema,
 } from "./schemas/platform.js";
-import { SandboxConfigSchema } from "./schemas/sandbox.js";
 import {
   PermissionsConfigSchema,
   SecretDetectionConfigSchema,
@@ -238,6 +270,7 @@ import {
   RateLimitConfigSchema,
   TimeoutConfigSchema,
 } from "./schemas/timeouts.js";
+import { UpdatesConfigSchema } from "./schemas/updates.js";
 import { WorkspaceGitConfigSchema } from "./schemas/workspace-git.js";
 
 export const AssistantConfigSchema = z
@@ -247,7 +280,7 @@ export const AssistantConfigSchema = z
       .number({ error: "maxTokens must be a number" })
       .int("maxTokens must be an integer")
       .positive("maxTokens must be a positive integer")
-      .default(16000)
+      .default(64000)
       .describe("Maximum number of output tokens per LLM response"),
     effort: EffortSchema,
     speed: SpeedSchema,
@@ -261,7 +294,6 @@ export const AssistantConfigSchema = z
       .default(getDataDir())
       .describe("Directory for storing assistant data (database, logs, etc.)"),
     timeouts: TimeoutConfigSchema.default(TimeoutConfigSchema.parse({})),
-    sandbox: SandboxConfigSchema.default(SandboxConfigSchema.parse({})),
     rateLimit: RateLimitConfigSchema.default(RateLimitConfigSchema.parse({})),
     secretDetection: SecretDetectionConfigSchema.default(
       SecretDetectionConfigSchema.parse({}),
@@ -281,7 +313,13 @@ export const AssistantConfigSchema = z
       ),
     filing: FilingConfigSchema.default(FilingConfigSchema.parse({})),
     heartbeat: HeartbeatConfigSchema.default(HeartbeatConfigSchema.parse({})),
+    updates: UpdatesConfigSchema.default(UpdatesConfigSchema.parse({})),
+    hostBrowser: HostBrowserConfigSchema.default(
+      HostBrowserConfigSchema.parse({}),
+    ),
     journal: JournalConfigSchema.default(JournalConfigSchema.parse({})),
+    analysis: AnalysisConfigSchema.default(AnalysisConfigSchema.parse({})),
+    backup: BackupConfigSchema.default(BackupConfigSchema.parse({})),
     mcp: McpConfigSchema.default(McpConfigSchema.parse({})),
     acp: AcpConfigSchema.default(AcpConfigSchema.parse({})),
     skills: SkillsConfigSchema.default(SkillsConfigSchema.parse({})),
@@ -290,10 +328,6 @@ export const AssistantConfigSchema = z
     ),
     twilio: TwilioConfigSchema.default(TwilioConfigSchema.parse({})),
     calls: CallsConfigSchema.default(CallsConfigSchema.parse({})),
-    elevenlabs: ElevenLabsConfigSchema.default(
-      ElevenLabsConfigSchema.parse({}),
-    ),
-    fishAudio: FishAudioConfigSchema.default(FishAudioConfigSchema.parse({})),
     whatsapp: WhatsAppConfigSchema.default(WhatsAppConfigSchema.parse({})),
     telegram: TelegramConfigSchema.default(TelegramConfigSchema.parse({})),
     slack: SlackConfigSchema.default(SlackConfigSchema.parse({})),
@@ -321,6 +355,13 @@ export const AssistantConfigSchema = z
       .max(200, "maxStepsPerSession must be <= 200")
       .default(50)
       .describe("Maximum number of computer-use steps per session"),
+    systemPromptPrefix: z
+      .string({ error: "systemPromptPrefix must be a string" })
+      .nullable()
+      .default(null)
+      .describe(
+        "Custom text injected at the very beginning of the system prompt. Defaults to null (no injection).",
+      ),
   })
   .superRefine((config, ctx) => {
     if (
@@ -373,6 +414,31 @@ export const AssistantConfigSchema = z
           "memory.retrieval.dynamicBudget.minInjectTokens must be <= memory.retrieval.dynamicBudget.maxInjectTokens",
       });
     }
+    const injection = config.memory?.retrieval?.injection;
+    const ctxLoad = injection?.contextLoad;
+    if (
+      ctxLoad &&
+      ctxLoad.capabilityReserve + ctxLoad.serendipitySlots >= ctxLoad.maxNodes
+    ) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["memory", "retrieval", "injection", "contextLoad"],
+        message:
+          "memory.retrieval.injection.contextLoad.capabilityReserve + serendipitySlots must be less than maxNodes",
+      });
+    }
+    const perTurn = injection?.perTurn;
+    if (
+      perTurn &&
+      perTurn.capabilityReserve + perTurn.serendipitySlots >= perTurn.maxNodes
+    ) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["memory", "retrieval", "injection", "perTurn"],
+        message:
+          "memory.retrieval.injection.perTurn.capabilityReserve + serendipitySlots must be less than maxNodes",
+      });
+    }
   });
 
 export type AssistantConfig = z.infer<typeof AssistantConfigSchema>;

package/src/config/schemas/__tests__/stt.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  SttProvidersSchema,
+  SttServiceSchema,
+  VALID_STT_PROVIDERS,
+} from "../stt.js";
+
+describe("SttProvidersSchema", () => {
+  test("accepts a Deepgram entry with arbitrary fields (generic record)", () => {
+    const parsed = SttProvidersSchema.parse({
+      deepgram: { diarize: true },
+    });
+    expect(parsed).toEqual({ deepgram: { diarize: true } });
+  });
+
+  test("forward-compatible: unknown provider keys still pass validation", () => {
+    const parsed = SttProvidersSchema.parse({
+      "future-provider": { someField: 42 },
+    });
+    expect(parsed).toEqual({ "future-provider": { someField: 42 } });
+  });
+
+  test("empty providers map parses to {}", () => {
+    const parsed = SttProvidersSchema.parse({});
+    expect(parsed).toEqual({});
+  });
+});
+
+describe("SttServiceSchema", () => {
+  test("stt.provider=deepgram with providers.deepgram round-trips", () => {
+    const parsed = SttServiceSchema.parse({
+      provider: "deepgram",
+      providers: { deepgram: { diarize: true } },
+    });
+    expect(parsed.provider).toBe("deepgram");
+    expect(parsed.providers.deepgram).toEqual({ diarize: true });
+  });
+
+  test("VALID_STT_PROVIDERS includes deepgram", () => {
+    expect(VALID_STT_PROVIDERS).toContain("deepgram");
+  });
+});

package/src/config/schemas/analysis.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+
+export const AnalysisConfigSchema = z
+  .object({
+    // Number of new messages in the source conversation that trigger an
+    // analysis enqueue. Defaults to 3× the extraction batch size so analysis
+    // fires less often than extraction.
+    batchSize: z
+      .number({ error: "analysis.batchSize must be a number" })
+      .int("analysis.batchSize must be an integer")
+      .positive("analysis.batchSize must be a positive integer")
+      .default(30)
+      .describe(
+        "Number of new messages in the source conversation that trigger an analysis enqueue",
+      ),
+
+    // Idle window after the last message before the debounced analysis
+    // job fires. Defaults to 2× the extraction idle window.
+    idleTimeoutMs: z
+      .number({ error: "analysis.idleTimeoutMs must be a number" })
+      .int("analysis.idleTimeoutMs must be an integer")
+      .positive("analysis.idleTimeoutMs must be a positive integer")
+      .default(600_000)
+      .describe(
+        "Milliseconds of idle time after the last message before the debounced analysis job fires",
+      ),
+
+    // Optional model intent for the analysis agent loop. When omitted,
+    // the analysis agent uses the same model as the main agent.
+    // Accepted values match the main agent's model-intent vocabulary.
+    modelIntent: z
+      .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
+        error: "analysis.modelIntent must be a valid model intent",
+      })
+      .optional()
+      .describe(
+        "Model selection strategy for the analysis agent loop — falls back to the main agent's model when omitted",
+      ),
+
+    // Optional explicit model override (provider/model string). Takes
+    // precedence over modelIntent when both are set.
+    modelOverride: z
+      .string({ error: "analysis.modelOverride must be a string" })
+      .optional()
+      .describe(
+        "Explicit model override (provider/model string) for the analysis agent loop — takes precedence over modelIntent when both are set",
+      ),
+  })
+  .describe("Controls the auto-analyze agent loop triggered by conversation activity");
+
+export type AnalysisConfig = z.infer<typeof AnalysisConfigSchema>;

package/src/config/schemas/backup.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+
+export const BackupDestinationSchema = z
+  .object({
+    path: z
+      .string({ error: "backup.offsite.destinations[].path must be a string" })
+      .describe("Absolute path to the offsite destination directory"),
+    encrypt: z
+      .boolean({
+        error: "backup.offsite.destinations[].encrypt must be a boolean",
+      })
+      .default(true)
+      .describe(
+        "Encrypt backups written to this destination. Defaults to true; set to false only for destinations where the user trusts physical control (e.g. an external SSD).",
+      ),
+  })
+  .describe("A single offsite backup destination");
+
+export type BackupDestination = z.infer<typeof BackupDestinationSchema>;
+
+export const BackupOffsiteConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "backup.offsite.enabled must be a boolean" })
+      .default(true)
+      .describe("Whether offsite backup is enabled"),
+    destinations: z
+      .array(BackupDestinationSchema)
+      .nullable()
+      .default(null)
+      .describe(
+        "Offsite destinations. null means use the default iCloud Drive destination with encryption on; an explicit array (including []) overrides the default.",
+      ),
+  })
+  .describe("Offsite backup configuration");
+
+export type BackupOffsiteConfig = z.infer<typeof BackupOffsiteConfigSchema>;
+
+export const BackupConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "backup.enabled must be a boolean" })
+      .default(false)
+      .describe("Whether automated backups are enabled"),
+    intervalHours: z
+      .number({ error: "backup.intervalHours must be a number" })
+      .int("backup.intervalHours must be an integer")
+      .min(1, "backup.intervalHours must be >= 1")
+      .max(168, "backup.intervalHours must be <= 168")
+      .default(6)
+      .describe("Interval between automated backups, in hours"),
+    retention: z
+      .number({ error: "backup.retention must be a number" })
+      .int("backup.retention must be an integer")
+      .min(1, "backup.retention must be >= 1")
+      .max(100, "backup.retention must be <= 100")
+      .default(7)
+      .describe("Number of recent backups to retain"),
+    offsite: BackupOffsiteConfigSchema.default(
+      BackupOffsiteConfigSchema.parse({}),
+    ),
+    localDirectory: z
+      .string({ error: "backup.localDirectory must be a string" })
+      .nullable()
+      .default(null)
+      .describe(
+        "Directory for local backup snapshots. null means use the default workspace-adjacent location.",
+      ),
+  })
+  .describe("Automated backup configuration");
+
+export type BackupConfig = z.infer<typeof BackupConfigSchema>;

package/src/config/schemas/calls.ts

@@ -5,9 +5,6 @@ export const VALID_CALLER_IDENTITY_MODES = [
   "assistant_number",
   "user_number",
 ] as const;
-const VALID_CALL_TRANSCRIPTION_PROVIDERS = ["Deepgram", "Google"] as const;
-export const VALID_TTS_PROVIDERS = ["elevenlabs", "fish-audio"] as const;
-
 export const CallsDisclosureConfigSchema = z
   .object({
     enabled: z
@@ -50,30 +47,8 @@ export const CallsVoiceConfigSchema = z
       .string({ error: "calls.voice.language must be a string" })
       .default("en-US")
       .describe("BCP-47 language code for speech recognition and synthesis"),
-    transcriptionProvider: z
-      .enum(VALID_CALL_TRANSCRIPTION_PROVIDERS, {
-        error: `calls.voice.transcriptionProvider must be one of: ${VALID_CALL_TRANSCRIPTION_PROVIDERS.join(
-          ", ",
-        )}`,
-      })
-      .default("Deepgram")
-      .describe("Speech-to-text provider used for call transcription"),
-    speechModel: z
-      .string({ error: "calls.voice.speechModel must be a string" })
-      .optional()
-      .describe(
-        "ASR model to use for speech recognition (e.g. nova-3, nova-2-phonecall for Deepgram; telephony, long for Google)",
-      ),
-    ttsProvider: z
-      .enum(VALID_TTS_PROVIDERS, {
-        error: `calls.voice.ttsProvider must be one of: ${VALID_TTS_PROVIDERS.join(", ")}`,
-      })
-      .default("elevenlabs")
-      .describe("Text-to-speech provider for phone calls"),
     hints: z
-      .array(
-        z.string({ error: "calls.voice.hints values must be strings" }),
-      )
+      .array(z.string({ error: "calls.voice.hints values must be strings" }))
       .default([])
       .describe(
         "Static vocabulary hints for speech recognition — proper nouns, domain terms, and other words the STT provider should prioritize",

package/src/config/schemas/elevenlabs.ts

@@ -1,5 +1,3 @@
-import { z } from "zod";
-
 // Default ElevenLabs voice — "Amelia" (expressive, enthusiastic, British English).
 // Used by both in-app TTS and phone calls (via Twilio ConversationRelay).
 // Mirrored in: clients/macos/.../OpenAIVoiceService.swift (defaultVoiceId)
@@ -7,60 +5,3 @@ export const DEFAULT_ELEVENLABS_VOICE_ID = "ZF6FPAbjXT4488VcRRnw";
 
 /** Valid conversation timeout values (seconds). Shared with voice-config-update tool. */
 export const VALID_CONVERSATION_TIMEOUTS = [5, 10, 15, 30, 60] as const;
-
-export const ElevenLabsConfigSchema = z
-  .object({
-    voiceId: z
-      .string({ error: "elevenlabs.voiceId must be a string" })
-      .min(1, "elevenlabs.voiceId must not be empty")
-      .default(DEFAULT_ELEVENLABS_VOICE_ID)
-      .describe("ElevenLabs voice ID for text-to-speech"),
-    voiceModelId: z
-      .string({ error: "elevenlabs.voiceModelId must be a string" })
-      .default("")
-      .describe(
-        "ElevenLabs model ID override (leave empty to use the default model)",
-      ),
-    speed: z
-      .number({ error: "elevenlabs.speed must be a number" })
-      .min(0.7, "elevenlabs.speed must be >= 0.7")
-      .max(1.2, "elevenlabs.speed must be <= 1.2")
-      .default(1.0)
-      .describe(
-        "Speech playback speed multiplier (0.7 = slower, 1.2 = faster)",
-      ),
-    stability: z
-      .number({ error: "elevenlabs.stability must be a number" })
-      .min(0, "elevenlabs.stability must be >= 0")
-      .max(1, "elevenlabs.stability must be <= 1")
-      .default(0.5)
-      .describe(
-        "Voice stability — higher values produce more consistent speech, lower values add expressiveness",
-      ),
-    similarityBoost: z
-      .number({ error: "elevenlabs.similarityBoost must be a number" })
-      .min(0, "elevenlabs.similarityBoost must be >= 0")
-      .max(1, "elevenlabs.similarityBoost must be <= 1")
-      .default(0.75)
-      .describe(
-        "How closely the output matches the original voice — higher values increase similarity",
-      ),
-    conversationTimeoutSeconds: z
-      .number({
-        error: "elevenlabs.conversationTimeoutSeconds must be a number",
-      })
-      .refine(
-        (v) =>
-          VALID_CONVERSATION_TIMEOUTS.includes(
-            v as (typeof VALID_CONVERSATION_TIMEOUTS)[number],
-          ),
-        {
-          message: `elevenlabs.conversationTimeoutSeconds must be one of: ${VALID_CONVERSATION_TIMEOUTS.join(", ")}`,
-        },
-      )
-      .default(30)
-      .describe("Seconds of silence before voice conversation auto-ends"),
-  })
-  .describe("ElevenLabs text-to-speech configuration");
-
-export type ElevenLabsConfig = z.infer<typeof ElevenLabsConfigSchema>;