@vellumai/assistant 0.12.1-staging.1 → 0.12.1

package/src/config/bundled-skills/screen-annotation/tools/screen-annotation.test.ts

@@ -53,10 +53,7 @@ describe("screen_point_at", () => {
     );
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain(
-      "The Vellum desktop app is needed to view or control your screen",
-    );
-    expect(result.content).toContain("https://www.vellum.ai/downloads");
+    expect(result.content).toContain("connected desktop client");
   });
 
   /** Drawing on the user's screen is a side effect a stopped turn must not have. */

package/src/config/bundled-skills/skill-management/TOOLS.json

@@ -3,7 +3,7 @@
   "tools": [
     {
       "name": "scaffold_managed_skill",
-      "description": "Create or update a managed skill in {workspaceDir}/skills. The skill becomes available for skill_load when a valid top-level SKILL.md is written under the skill directory. Never persist a skill without explicit user consent. Before persisting, test the snippet: write to a temp file with bash and run with `bun run /tmp/vellum-eval/snippet.ts`. Iterate up to 3 attempts, then ask the user. Clean up temp files after. Do not use file_write for temp files outside the working directory.",
+      "description": "Create or update a managed skill in {workspaceDir}/skills. The skill becomes available for skill_load when a valid top-level SKILL.md is written under the skill directory. Never persist a skill without explicit user consent. Before persisting, test the snippet: write to a temp file with bash and run with `bun run /tmp/vellum-eval/snippet.ts`. Iterate up to 3 attempts, then ask the user. Clean up temp files after. Do not use file_write for temp files outside the working directory. After a skill is written, the next turn may run in a recreated conversation due to file-watcher eviction - continue normally.",
       "category": "skills",
       "risk": "high",
       "input_schema": {
@@ -92,7 +92,7 @@
     },
     {
       "name": "delete_managed_skill",
-      "description": "Delete a managed skill directory from {workspaceDir}/skills. Never delete a skill without explicit user confirmation.",
+      "description": "Delete a managed skill directory from {workspaceDir}/skills. Never delete a skill without explicit user confirmation. After deletion, the next turn may run in a recreated conversation due to file-watcher eviction - continue normally.",
       "category": "skills",
       "risk": "high",
       "input_schema": {

package/src/config/default-profile-catalog.ts

@@ -137,7 +137,7 @@ const VELLUM_PROFILE_IMPLS: ProfileImpls = {
     // The managed latency class, also what the live-voice front model runs on.
     // Its leading tokens are the turn-taking verdict, so what this profile
     // optimizes is the tail of time-to-first-token rather than the median: a
-    // verdict slower than `voice.frontModel.endpointDecisionTimeoutMs`
+    // verdict slower than `liveVoice.frontModel.endpointDecisionTimeoutMs`
     // trips the speculative fail-open commit in live-voice-session.ts, which
     // is audible dead air.
     //

package/src/config/env.ts

@@ -229,8 +229,8 @@ export function setPlatformAssistantId(value: string | undefined): void {
  * Platform assistant ID — UUID of this assistant on the platform.
  *
  * Resolved from the in-memory override (populated by providers-setup
- * rehydration via platform validate, or by secret-routes when the
- * platform pushes the value).
+ * rehydration from the credential store at daemon startup, or by
+ * secret-routes when the platform pushes the value).
  */
 export function getPlatformAssistantId(): string {
   return _platformAssistantIdOverride ?? "";

package/src/config/feature-flag-registry.json

@@ -29,6 +29,18 @@
       "description": "Enable user-hosted onboarding flow",
       "defaultEnabled": false
     },
+    {
+      "id": "proactive-tips",
+      "scope": "client",
+      "key": "proactive-tips",
+      "label": "Proactive Tips",
+      "description": "Gates the dismissible proactive tip card in the web sidebar. String-valued so future A/B arms can be added as new values.",
+      "defaultEnabled": "off",
+      "values": [
+        "off",
+        "on"
+      ]
+    },
     {
       "id": "vision-mode",
       "scope": "client",
@@ -511,14 +523,6 @@
       "label": "Send User Message Tool",
       "description": "Route all user-facing assistant text through the send_user_message tool instead of streamed assistant text",
       "defaultEnabled": false
-    },
-    {
-      "id": "assistant-desktop",
-      "scope": "assistant",
-      "key": "assistant-desktop",
-      "label": "Assistant Desktop",
-      "description": "Streams an interactive desktop from a containerized assistant pod to the web client over /v1/desktop/stream. Off: no desktop affordance is rendered. On: the chat header offers a desktop panel that views and controls the pod's display.",
-      "defaultEnabled": false
     }
   ]
 }

package/src/config/memory-v3-gate.test.ts

@@ -6,7 +6,6 @@ import {
   isMemoryV1Active,
   isMemoryV2ExplicitlyDisabled,
   isMemoryV3Live,
-  isSkillImprovementActive,
   isV2InjectionEngineActive,
   isV3TierActive,
   usesConceptPageMemory,
@@ -56,16 +55,12 @@ function makeConfig(
   enabled: TriState,
   v2Enabled: TriState,
   v3Live: TriState,
-  skillImprovement?: boolean,
 ): AssistantConfig {
   return {
     memory: {
       ...(enabled === undefined ? {} : { enabled }),
       ...(v2Enabled === undefined ? {} : { v2: { enabled: v2Enabled } }),
       ...(v3Live === undefined ? {} : { v3: { live: v3Live } }),
-      ...(skillImprovement === undefined
-        ? {}
-        : { retrospective: { skillImprovement } }),
     },
   } as AssistantConfig;
 }
@@ -301,32 +296,6 @@ describe("v1-staleness guard is one condition", () => {
  * proc-to-skills alias of `isMemoryV3Live` (which did not). One predicate now
  * answers for both features.
  */
-describe("skill improvement gate", () => {
-  test("defaults on for a live v3 tier", () => {
-    expect(isSkillImprovementActive(makeConfig(true, undefined, true))).toBe(
-      true,
-    );
-    expect(isSkillImprovementActive(makeConfig(undefined, undefined, true))).toBe(
-      true,
-    );
-  });
-
-  test("explicit opt-out disables skill improvement without disabling v3", () => {
-    const config = makeConfig(true, undefined, true, false);
-
-    expect(isV3TierActive(config)).toBe(true);
-    expect(isSkillImprovementActive(config)).toBe(false);
-  });
-
-  test("requires the live v3 tier even when explicitly enabled", () => {
-    const v2Config = makeConfig(true, true, false, true);
-    const memoryOffConfig = makeConfig(false, undefined, true, true);
-
-    expect(isSkillImprovementActive(v2Config)).toBe(false);
-    expect(isSkillImprovementActive(memoryOffConfig)).toBe(false);
-  });
-});
-
 describe("v3 tier is one condition", () => {
   test("memory off suppresses the v3 tier even with memory.v3.live set", () => {
     const config = makeConfig(false, undefined, true);

package/src/config/memory-v3-gate.ts

@@ -81,32 +81,28 @@ export function isMemoryV3Live(config: AssistantConfig): boolean {
  * FEATURE asks this predicate; only the injection-suppression checks that must
  * mirror the raw `memory.v3.live` key ask {@link isMemoryV3Live} directly.
  *
- * The memory concept graph is gated on it: both `GET /memory-graph`
- * (`supported`) and the cheap `graph_supported` bit on `GET /memory/stats`
- * must agree with whether the graph can build from the v3 concept-page
- * substrate.
+ * The two features gated on it, and why they must agree:
  *
- * Retrospective skill improvement is a separate optional v3-tier feature.
- * Ask {@link isSkillImprovementActive} for it so an operator can stop managed
- * skill authoring without turning off ordinary retrospective memory capture.
+ * - The memory concept graph — the single source of truth for both
+ *   `GET /memory-graph` (`supported`) and the cheap `graph_supported` bit on
+ *   `GET /memory/stats`, so the advertised capability and the actual build can
+ *   never drift. The graph builds off the v3 concept-page substrate.
+ * - Procedural-memory-as-skills — the retrospective's skill-authoring step and
+ *   its permission grant. Scoped to the v3 tier because skill retrieval rides
+ *   the v3 lanes and the usage-prune stage lives in the v3 maintain job. That
+ *   prune ships observe-first: with `memory.maintenance.skillPruneDays` at its
+ *   default (`null`) it reports stale assistant-authored skills
+ *   (`prunableSkills`) but deletes none — so a v3-tier assistant authors skills
+ *   without an automatic retirement bound until a positive `skillPruneDays` is
+ *   configured.
+ *
+ * Both write into memory on the user's behalf, so both honor the Memory
+ * opt-out identically: one predicate, one answer.
  */
 export function isV3TierActive(config: AssistantConfig): boolean {
   return isMemoryEnabled(config) && isMemoryV3Live(config);
 }
 
-/**
- * Whether a retrospective may turn observed procedures into managed skills.
- * This requires the v3 tier because skills are retrieved through its memory
- * substrate, and it honors the retrospective-specific opt-out without
- * disabling ordinary retrospective fact retention.
- */
-export function isSkillImprovementActive(config: AssistantConfig): boolean {
-  return (
-    isV3TierActive(config) &&
-    config.memory?.retrospective?.skillImprovement !== false
-  );
-}
-
 /**
  * Minimal structural view of the memory config the concept-page gate reads.
  * Accepting the shape (rather than the full `MemoryConfig`) lets call sites

package/src/config/platform-rehydration.ts

@@ -1,5 +1,6 @@
 /**
- * Rehydrate the in-memory platform identity/URL overrides at process startup.
+ * Rehydrate the in-memory platform identity/URL overrides from the credential
+ * store at process startup.
  *
  * These overrides (`setPlatformBaseUrl` and the platform ID setters in
  * `config/env.ts`) are normally only populated at runtime by the secret-routes
@@ -9,10 +10,6 @@
  * environment default (e.g. dev-platform) while the credential store holds the
  * real production values, and requests are sent to the wrong environment.
  *
- * Bound platform ids come from `POST /v1/internal/assistants/validate/`,
- * which trades the assistant API key for assistant/organization/user ids.
- * If validate omits an id, that field is read from the credential store.
- *
  * Each field is best-effort: a credential-store read failure is logged and
  * skipped so a single missing value never blocks startup.
  */
@@ -20,19 +17,11 @@ import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
 import { getLogger } from "../util/logger.js";
 import {
-  getPlatformAssistantId,
-  getPlatformBaseUrl,
-  getPlatformOrganizationId,
-  getPlatformUserId,
   setPlatformAssistantId,
   setPlatformBaseUrl,
   setPlatformOrganizationId,
   setPlatformUserId,
 } from "./env.js";
-import {
-  applyPlatformIdentityIds,
-  fetchPlatformIdentityIds,
-} from "./platform-identity.js";
 
 const log = getLogger("platform-rehydration");
 
@@ -56,75 +45,32 @@ async function rehydrateField(
   }
 }
 
-async function readAssistantApiKey(): Promise<string> {
-  try {
-    const stored = (
-      await getSecureKeyAsync(credentialKey("vellum", "assistant_api_key"))
-    )?.trim();
-    if (stored) {
-      return stored;
-    }
-  } catch (err) {
-    log.warn(
-      { error: err instanceof Error ? err.message : String(err) },
-      "Failed to read assistant API key from credential store (non-fatal)",
-    );
-  }
-  return process.env.ASSISTANT_API_KEY?.trim() ?? "";
-}
-
-async function rehydrateIdentityFromValidate(): Promise<boolean> {
-  const apiKey = await readAssistantApiKey();
-  if (!apiKey) {
-    return false;
-  }
-  const baseUrl = getPlatformBaseUrl();
-  if (!baseUrl) {
-    return false;
-  }
-  const ids = await fetchPlatformIdentityIds(baseUrl, apiKey);
-  if (!ids) {
-    return false;
-  }
-  applyPlatformIdentityIds(ids);
-  log.info("Rehydrated platform identity from platform validate");
-  return true;
-}
-
 /**
  * Rehydrate the platform base URL and the related platform IDs (assistant,
- * organization, user). Safe to call more than once.
+ * organization, user) from the credential store into their in-memory
+ * overrides. Safe to call more than once.
  */
 export async function rehydratePlatformCredentials(): Promise<void> {
-  // Base URL first so managed proxy activation and identity validate resolve
-  // the correct environment for every request that follows.
+  // Base URL first so managed proxy activation resolves the correct
+  // environment for the ID lookups and every request that follows.
   await rehydrateField(
     "platform_base_url",
     setPlatformBaseUrl,
     "platform base URL",
   );
-
-  await rehydrateIdentityFromValidate();
-
-  if (!getPlatformAssistantId()) {
-    await rehydrateField(
-      "platform_assistant_id",
-      setPlatformAssistantId,
-      "platform assistant ID",
-    );
-  }
-  if (!getPlatformOrganizationId()) {
-    await rehydrateField(
-      "platform_organization_id",
-      setPlatformOrganizationId,
-      "platform organization ID",
-    );
-  }
-  if (!getPlatformUserId()) {
-    await rehydrateField(
-      "platform_user_id",
-      setPlatformUserId,
-      "platform user ID",
-    );
-  }
+  await rehydrateField(
+    "platform_assistant_id",
+    setPlatformAssistantId,
+    "platform assistant ID",
+  );
+  await rehydrateField(
+    "platform_organization_id",
+    setPlatformOrganizationId,
+    "platform organization ID",
+  );
+  await rehydrateField(
+    "platform_user_id",
+    setPlatformUserId,
+    "platform user ID",
+  );
 }

package/src/config/schema.ts

@@ -41,6 +41,7 @@ import {
   AuditLogConfigSchema,
   LogFileConfigSchema,
 } from "./schemas/logging.js";
+import { McpConfigSchema } from "./schemas/mcp.js";
 import { MemoryConfigSchema } from "./schemas/memory.js";
 import { MigrationsConfigSchema } from "./schemas/migrations.js";
 import { MonitoringConfigSchema } from "./schemas/monitoring.js";
@@ -61,7 +62,6 @@ import {
 } from "./schemas/timeouts.js";
 import { ToolsConfigSchema } from "./schemas/tools.js";
 import { UserRoutesConfigSchema } from "./schemas/user-routes.js";
-import { VoiceConfigSchema } from "./schemas/voice.js";
 import { WorkflowsConfigSchema } from "./schemas/workflows.js";
 import { WorkspaceGitConfigSchema } from "./schemas/workspace-git.js";
 
@@ -108,6 +108,7 @@ export const AssistantConfigSchema = z.object({
   ),
   journal: JournalConfigSchema.default(JournalConfigSchema.parse({})),
   backup: BackupConfigSchema.default(BackupConfigSchema.parse({})),
+  mcp: McpConfigSchema.default(McpConfigSchema.parse({})),
   acp: AcpConfigSchema.default(AcpConfigSchema.parse({})),
   skills: SkillsConfigSchema.default(SkillsConfigSchema.parse({})),
   workspaceGit: WorkspaceGitConfigSchema.default(
@@ -118,7 +119,6 @@ export const AssistantConfigSchema = z.object({
   twilio: TwilioConfigSchema.default(TwilioConfigSchema.parse({})),
   calls: CallsConfigSchema.default(CallsConfigSchema.parse({})),
   liveVoice: LiveVoiceConfigSchema.default(LiveVoiceConfigSchema.parse({})),
-  voice: VoiceConfigSchema.default(VoiceConfigSchema.parse({})),
   sight: SightConfigSchema.default(SightConfigSchema.parse({})),
   whatsapp: WhatsAppConfigSchema.default(WhatsAppConfigSchema.parse({})),
   telegram: TelegramConfigSchema.default(TelegramConfigSchema.parse({})),

package/src/config/schemas/__tests__/live-voice.test.ts

@@ -3,9 +3,28 @@ import { describe, expect, test } from "bun:test";
 import {
   LiveVoiceConfigSchema,
   LiveVoiceFluxConfigSchema,
+  LiveVoiceFrontModelConfigSchema,
   LiveVoiceVadConfigSchema,
+  VALID_LIVE_VOICE_MODES,
 } from "../live-voice.js";
 
+const PROGRESS_DEFAULTS = {
+  enabled: true,
+  opsThreshold: 3,
+  idleIntervalMs: 5_000,
+  maxSilenceMs: 35_000,
+  longOpMs: 15_000,
+  minGapMs: 6_000,
+  generationTimeoutMs: 1_500,
+};
+
+const FRONT_MODEL_DEFAULTS = {
+  endpointDecisionTimeoutMs: 1200,
+  endpointExtensionMs: 1500,
+  endpointMaxExtensions: 2,
+  progress: PROGRESS_DEFAULTS,
+};
+
 // `eagerEotThreshold` is deliberately absent: it has no default, and leaving it
 // unset is what keeps Deepgram from emitting speculative turn events. `model`
 // is absent for a related reason: unset means the spoken language selects the
@@ -111,6 +130,117 @@ describe("LiveVoiceVadConfigSchema", () => {
   });
 });
 
+describe("LiveVoiceFrontModelConfigSchema", () => {
+  test("empty object parses to defaults", () => {
+    const parsed = LiveVoiceFrontModelConfigSchema.parse({});
+    expect(parsed).toEqual(FRONT_MODEL_DEFAULTS);
+  });
+
+  test("accepts overrides", () => {
+    const parsed = LiveVoiceFrontModelConfigSchema.parse({
+      endpointDecisionTimeoutMs: 400,
+      endpointMaxExtensions: 0,
+    });
+    expect(parsed.endpointDecisionTimeoutMs).toBe(400);
+    expect(parsed.endpointMaxExtensions).toBe(0);
+    // Unspecified fields still get defaults
+    expect(parsed.endpointExtensionMs).toBe(1500);
+  });
+
+  test("strips retired generated-ack settings", () => {
+    const parsed = LiveVoiceFrontModelConfigSchema.parse({
+      ackFirstDeltaTimeoutMs: 2500,
+      ackGenerationTimeoutMs: 600,
+    });
+    expect(parsed).not.toHaveProperty("ackFirstDeltaTimeoutMs");
+    expect(parsed).not.toHaveProperty("ackGenerationTimeoutMs");
+  });
+
+  test("rejects non-positive endpointDecisionTimeoutMs", () => {
+    const result = LiveVoiceFrontModelConfigSchema.safeParse({
+      endpointDecisionTimeoutMs: 0,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects negative endpointMaxExtensions", () => {
+    const result = LiveVoiceFrontModelConfigSchema.safeParse({
+      endpointMaxExtensions: -1,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("absent progress namespace parses to full progress defaults", () => {
+    const parsed = LiveVoiceFrontModelConfigSchema.parse({});
+    expect(parsed.progress).toEqual(PROGRESS_DEFAULTS);
+  });
+
+  test("partial progress overrides merge with defaults", () => {
+    const parsed = LiveVoiceFrontModelConfigSchema.parse({
+      progress: { enabled: false, opsThreshold: 5 },
+    });
+    expect(parsed.progress.enabled).toBe(false);
+    expect(parsed.progress.opsThreshold).toBe(5);
+    // Unspecified progress fields still get defaults
+    expect(parsed.progress.idleIntervalMs).toBe(5_000);
+    expect(parsed.progress.maxSilenceMs).toBe(35_000);
+    expect(parsed.progress.longOpMs).toBe(15_000);
+    expect(parsed.progress.minGapMs).toBe(6_000);
+    expect(parsed.progress.generationTimeoutMs).toBe(1_500);
+  });
+
+  test("a stale maxPerTurn key is stripped, not rejected", () => {
+    // The cap was removed; configs written while it existed must still parse.
+    const parsed = LiveVoiceFrontModelConfigSchema.parse({
+      progress: { maxPerTurn: 3 },
+    });
+    expect("maxPerTurn" in parsed.progress).toBe(false);
+  });
+
+  test("rejects non-positive progress.opsThreshold", () => {
+    const result = LiveVoiceFrontModelConfigSchema.safeParse({
+      progress: { opsThreshold: 0 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects a heartbeat ceiling shorter than the idle tick interval", () => {
+    // The heartbeat is only checked on the idle tick, so a shorter ceiling
+    // could be overshot by a full interval.
+    const result = LiveVoiceFrontModelConfigSchema.safeParse({
+      progress: { idleIntervalMs: 60_000, maxSilenceMs: 10_000 },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map((issue) => issue.message);
+      expect(
+        msgs.some((msg) =>
+          msg.includes("liveVoice.frontModel.progress.maxSilenceMs"),
+        ),
+      ).toBe(true);
+    }
+    // The floor itself is allowed: the tick is exactly on the ceiling.
+    expect(
+      LiveVoiceFrontModelConfigSchema.safeParse({
+        progress: { idleIntervalMs: 60_000, maxSilenceMs: 60_000 },
+      }).success,
+    ).toBe(true);
+  });
+
+  test("rejects a non-boolean progress.enabled", () => {
+    const result = LiveVoiceFrontModelConfigSchema.safeParse({
+      progress: { enabled: "yes" },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map((i) => i.message);
+      expect(
+        msgs.some((m) => m.includes("liveVoice.frontModel.progress.enabled")),
+      ).toBe(true);
+    }
+  });
+});
+
 describe("LiveVoiceFluxConfigSchema", () => {
   test("empty object parses to defaults, with turn-end on", () => {
     expect(LiveVoiceFluxConfigSchema.parse({})).toEqual(FLUX_DEFAULTS);
@@ -196,6 +326,7 @@ describe("LiveVoiceConfigSchema", () => {
   test("empty object parses to defaults", () => {
     const parsed = LiveVoiceConfigSchema.parse({});
     expect(parsed).toEqual({
+      mode: "open-mic",
       vad: {
         speechEnergyThreshold: 800,
         noiseFloorMargin: 3,
@@ -206,9 +337,11 @@ describe("LiveVoiceConfigSchema", () => {
         echoEmaHalfLifeMs: 400,
         echoDrainSlackMs: 300,
       },
+      frontModel: FRONT_MODEL_DEFAULTS,
       // Off by default: Flux turn detection is opt-in, so the front-door hold
       // verdict keeps committing turns until it is enabled.
       flux: FLUX_DEFAULTS,
+      maxSessionDurationSeconds: 1800,
       // Off by default: voice turns carry only their transcript, no audio
       // artifacts on the conversation messages (JARVIS-1283).
       archiveAudio: false,
@@ -232,26 +365,43 @@ describe("LiveVoiceConfigSchema", () => {
 
   test("accepts overrides", () => {
     const parsed = LiveVoiceConfigSchema.parse({
+      mode: "ptt",
       vad: { silenceThresholdMs: 900 },
+      frontModel: { endpointDecisionTimeoutMs: 300 },
       flux: { turnEnd: { enabled: true } },
+      maxSessionDurationSeconds: 600,
     });
+    expect(parsed.mode).toBe("ptt");
     expect(parsed.vad.silenceThresholdMs).toBe(900);
     // Unspecified vad fields still get defaults
     expect(parsed.vad.speechEnergyThreshold).toBe(800);
     expect(parsed.vad.maxTurnDurationMs).toBe(30_000);
+    // Partial frontModel overrides merge with defaults
+    expect(parsed.frontModel.endpointDecisionTimeoutMs).toBe(300);
+    expect(parsed.frontModel.endpointExtensionMs).toBe(1500);
     // Partial flux overrides merge with defaults
     expect(parsed.flux.turnEnd.enabled).toBe(true);
     expect(parsed.flux.eotThreshold).toBe(0.7);
+    expect(parsed.maxSessionDurationSeconds).toBe(600);
   });
 
-  test("persisted configs carrying retired keys keep parsing", () => {
-    // Zod strips unrecognized keys, so a persisted config that still carries
-    // `mode` or `maxSessionDurationSeconds` parses.
-    const parsed = LiveVoiceConfigSchema.parse({
-      mode: "ptt",
-      maxSessionDurationSeconds: 600,
+  test("rejects invalid mode", () => {
+    const result = LiveVoiceConfigSchema.safeParse({ mode: "always-on" });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map((i) => i.message);
+      expect(msgs.some((m) => m.includes("liveVoice.mode"))).toBe(true);
+    }
+  });
+
+  test("rejects non-positive maxSessionDurationSeconds", () => {
+    const result = LiveVoiceConfigSchema.safeParse({
+      maxSessionDurationSeconds: -1,
     });
-    expect(parsed).not.toHaveProperty("mode");
-    expect(parsed).not.toHaveProperty("maxSessionDurationSeconds");
+    expect(result.success).toBe(false);
+  });
+
+  test("VALID_LIVE_VOICE_MODES lists ptt and open-mic", () => {
+    expect(VALID_LIVE_VOICE_MODES).toEqual(["ptt", "open-mic"]);
   });
 });

package/src/config/schemas/calls.ts

@@ -26,8 +26,32 @@ const CallsDisclosureConfigSchema = z
     "Controls whether and how the assistant discloses its nature at the start of a phone call",
   );
 
+const CallsSafetyConfigSchema = z
+  .object({
+    denyCategories: z
+      .array(
+        z.string({
+          error: "calls.safety.denyCategories values must be strings",
+        }),
+      )
+      .default([])
+      .describe(
+        "Categories of calls that should be denied (e.g. for safety or compliance reasons)",
+      ),
+  })
+  .describe("Safety guardrails for phone calls");
+
 const CallsVoiceConfigSchema = z
   .object({
+    interruptSensitivity: z
+      .enum(["low", "medium", "high"], {
+        error:
+          "calls.voice.interruptSensitivity must be one of: low, medium, high",
+      })
+      .default("low")
+      .describe(
+        "How aggressively the STT provider detects the start of caller speech — low reduces false interrupts from background noise",
+      ),
     telephonyStreaming: z
       .boolean({
         error: "calls.voice.telephonyStreaming must be a boolean",
@@ -203,6 +227,7 @@ export const CallsConfigSchema = z
     disclosure: CallsDisclosureConfigSchema.default(
       CallsDisclosureConfigSchema.parse({}),
     ),
+    safety: CallsSafetyConfigSchema.default(CallsSafetyConfigSchema.parse({})),
     voice: CallsVoiceConfigSchema.default(CallsVoiceConfigSchema.parse({})),
     callerIdentity: CallerIdentityConfigSchema.default(
       CallerIdentityConfigSchema.parse({}),
@@ -211,4 +236,6 @@ export const CallsConfigSchema = z
       CallsVerificationConfigSchema.parse({}),
     ),
   })
-  .describe("Phone call configuration: telephony, voice, and call behavior");
+  .describe(
+    "Phone call configuration — controls telephony, voice, safety, and call behavior",
+  );