@vellumai/assistant 0.11.2 → 0.11.3-dev.202608080427.92f668a

package/src/__tests__/config-schema.test.ts

@@ -888,7 +888,6 @@ describe("AssistantConfigSchema", () => {
         denyCategories: [],
       },
       voice: {
-        language: "en-US",
         interruptSensitivity: "low",
         telephonyStreaming: true,
         utteranceEndMs: 1000,
@@ -933,13 +932,14 @@ describe("AssistantConfigSchema", () => {
         silenceThresholdMs: 1200,
         maxTurnDurationMs: 30000,
         bargeInMinSpeechMs: 250,
+        echoBargeInMargin: 1.5,
+        echoEmaHalfLifeMs: 400,
+        echoDrainSlackMs: 300,
       },
       frontModel: {
         endpointDecisionTimeoutMs: 1200,
         endpointExtensionMs: 1500,
         endpointMaxExtensions: 2,
-        ackFirstDeltaTimeoutMs: 2500,
-        ackGenerationTimeoutMs: 600,
         progress: {
           enabled: true,
           opsThreshold: 3,
@@ -950,6 +950,12 @@ describe("AssistantConfigSchema", () => {
           generationTimeoutMs: 1500,
         },
       },
+      flux: {
+        turnEnd: { enabled: false },
+        model: "flux-general-en",
+        eotThreshold: 0.7,
+        eotTimeoutMs: 5000,
+      },
       maxSessionDurationSeconds: 1800,
       archiveAudio: false,
     });
@@ -974,6 +980,8 @@ describe("AssistantConfigSchema", () => {
     // Unspecified vad fields still get defaults
     expect(result.liveVoice.vad.maxTurnDurationMs).toBe(30000);
     expect(result.liveVoice.maxSessionDurationSeconds).toBe(900);
+    // A partial liveVoice override leaves Flux turn-end disabled by default.
+    expect(result.liveVoice.flux.turnEnd.enabled).toBe(false);
   });
 
   test("accepts a liveVoice.vad.bargeInMinSpeechMs of 0 (guard disabled)", () => {
@@ -1071,7 +1079,6 @@ describe("AssistantConfigSchema", () => {
 
   test("config without calls.voice parses correctly and produces defaults", () => {
     const result = AssistantConfigSchema.parse({});
-    expect(result.calls.voice.language).toBe("en-US");
     expect(result.calls.voice.interruptSensitivity).toBe("low");
     expect(result.calls.voice.telephonyStreaming).toBe(true);
     expect(result.calls.voice.utteranceEndMs).toBe(1000);
@@ -1081,17 +1088,26 @@ describe("AssistantConfigSchema", () => {
     const result = AssistantConfigSchema.parse({
       calls: {
         voice: {
-          language: "es-ES",
           telephonyStreaming: false,
           utteranceEndMs: 2500,
         },
       },
     });
-    expect(result.calls.voice.language).toBe("es-ES");
     expect(result.calls.voice.telephonyStreaming).toBe(false);
     expect(result.calls.voice.utteranceEndMs).toBe(2500);
   });
 
+  test("language is no longer part of the voice config schema", () => {
+    // The retired knob was read by nothing; Zod strips the unrecognized key
+    // so persisted configs that still carry it keep parsing.
+    const result = AssistantConfigSchema.parse({
+      calls: { voice: { language: "es-ES" } },
+    });
+    expect(
+      (result.calls.voice as Record<string, unknown>).language,
+    ).toBeUndefined();
+  });
+
   test("rejects calls.voice.utteranceEndMs outside the 1000-5000 range", () => {
     for (const utteranceEndMs of [999, 5001]) {
       const result = AssistantConfigSchema.safeParse({
@@ -1409,6 +1425,131 @@ describe("AssistantConfigSchema", () => {
     expect(result.services.tts.providers.deepgram.format).toBe("opus");
   });
 
+  test("accepts services.tts.providers languageVoices maps", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          providers: {
+            elevenlabs: {
+              languageVoices: { hi: "voice-hindi", ja: "voice-japanese" },
+            },
+            deepgram: { languageVoices: { hi: "aura-2-hi-voice" } },
+            vellum: { languageVoices: { hi: "aura-2-hi-voice" } },
+          },
+        },
+      },
+    });
+    expect(result.services.tts.providers.elevenlabs.languageVoices).toEqual({
+      hi: "voice-hindi",
+      ja: "voice-japanese",
+    });
+    expect(result.services.tts.providers.deepgram.languageVoices).toEqual({
+      hi: "aura-2-hi-voice",
+    });
+    expect(result.services.tts.providers.vellum.languageVoices).toEqual({
+      hi: "aura-2-hi-voice",
+    });
+  });
+
+  test("normalizes user-entered languageVoices keys to lowercase base subtags", () => {
+    // "hi-IN" or "HI" typed into config must still match a spoken "hi"
+    // instead of silently never applying; the schema normalizes on parse.
+    const result = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          providers: {
+            elevenlabs: {
+              languageVoices: {
+                "hi-IN": "voice-hindi",
+                JA: "voice-japanese",
+                es_419: "voice-spanish",
+                " PT ": "voice-portuguese",
+              },
+            },
+          },
+        },
+      },
+    });
+    expect(result.services.tts.providers.elevenlabs.languageVoices).toEqual({
+      hi: "voice-hindi",
+      ja: "voice-japanese",
+      es: "voice-spanish",
+      pt: "voice-portuguese",
+    });
+  });
+
+  test("keeps the first entry when languageVoices keys collide after normalization", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          providers: {
+            deepgram: {
+              languageVoices: { "hi-IN": "voice-first", hi: "voice-second" },
+            },
+          },
+        },
+      },
+    });
+    expect(result.services.tts.providers.deepgram.languageVoices).toEqual({
+      hi: "voice-first",
+    });
+  });
+
+  test("drops languageVoices keys that normalize to the empty string", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          providers: {
+            vellum: {
+              languageVoices: {
+                "": "voice-empty",
+                "  ": "voice-blank",
+                "-IN": "voice-region-only",
+                hi: "voice-hindi",
+              },
+            },
+          },
+        },
+      },
+    });
+    expect(result.services.tts.providers.vellum.languageVoices).toEqual({
+      hi: "voice-hindi",
+    });
+  });
+
+  test("languageVoices defaults to unset", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(
+      result.services.tts.providers.elevenlabs.languageVoices,
+    ).toBeUndefined();
+    expect(
+      result.services.tts.providers.deepgram.languageVoices,
+    ).toBeUndefined();
+    expect(result.services.tts.providers.vellum.languageVoices).toBeUndefined();
+  });
+
+  test("rejects non-string services.tts.providers languageVoices values", () => {
+    for (const provider of ["elevenlabs", "deepgram", "vellum"]) {
+      const result = AssistantConfigSchema.safeParse({
+        services: {
+          tts: {
+            providers: {
+              [provider]: { languageVoices: { hi: 42 } },
+            },
+          },
+        },
+      });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(
+          result.error.issues.some((issue) =>
+            issue.path.join(".").includes("languageVoices"),
+          ),
+        ).toBe(true);
+      }
+    }
+  });
+
   // Legacy config objects on disk may carry a `mode` key. Parsing must strip
   // it rather than reject the config — and must not treat it as a managed
   // selection, which is what migration 130 rewrites to `provider: "vellum"`.
@@ -2424,7 +2565,9 @@ describe("loadConfig with schema validation", () => {
     expect(config.calls.userConsultTimeoutSeconds).toBe(120);
     expect(config.calls.disclosure.enabled).toBe(true);
     expect(config.calls.safety.denyCategories).toEqual([]);
-    expect(config.calls.voice.language).toBe("en-US");
+    expect(
+      (config.calls.voice as Record<string, unknown>).language,
+    ).toBeUndefined();
     expect(
       (config.calls.voice as Record<string, unknown>).transcriptionProvider,
     ).toBeUndefined();

package/src/__tests__/consult-deadline.test.ts

@@ -5,6 +5,8 @@
  */
 import { describe, expect, test } from "bun:test";
 
+import type { AssistantEvent } from "../api/index.js";
+import { isSubagentProgressEvent } from "../subagent/progress-events.js";
 import { createConsultDeadline } from "../tools/subagent/consult-deadline.js";
 
 const delay = (ms: number): Promise<void> =>
@@ -58,3 +60,66 @@ describe("createConsultDeadline", () => {
     expect(d.signal.aborted).toBe(false);
   });
 });
+
+describe("createConsultDeadline driven by subagent events", () => {
+  /** Feed an event through the classifier exactly as the manager's tap does. */
+  const feed = (
+    d: ReturnType<typeof createConsultDeadline>,
+    msg: AssistantEvent,
+  ): void => {
+    if (isSubagentProgressEvent(msg)) {
+      d.recordProgress();
+    }
+  };
+
+  test("tool activity re-arms the idle window with no token in sight", async () => {
+    // An advisor that opens a file streams no delta for the whole read. Tool
+    // events are the only sign of life, so they must hold the window open.
+    const d = createConsultDeadline({ idleMs: 150, maxMs: 10_000 });
+    const toolEvents = [
+      { type: "tool_use_start", toolName: "file_read", input: {} },
+      { type: "tool_input_delta", toolName: "file_read", content: "{" },
+      { type: "tool_output_chunk", chunk: "line" },
+      { type: "tool_result", result: "contents" },
+    ] as unknown as AssistantEvent[];
+    try {
+      for (let i = 0; i < 8; i++) {
+        await delay(25);
+        expect(d.signal.aborted).toBe(false);
+        feed(d, toolEvents[i % toolEvents.length]!);
+      }
+    } finally {
+      d.dispose();
+    }
+  });
+
+  test("a lifecycle event is not progress and does not hold the window open", async () => {
+    // The classifier is an allowlist: status chatter must not keep a genuinely
+    // stalled consult alive.
+    const d = createConsultDeadline({ idleMs: 50, maxMs: 10_000 });
+    try {
+      for (let i = 0; i < 5; i++) {
+        await delay(50);
+        feed(d, { type: "subagent_status_changed" } as AssistantEvent);
+      }
+      expect(d.signal.aborted).toBe(true);
+    } finally {
+      d.dispose();
+    }
+  });
+
+  test("tool activity cannot push the consult past the absolute backstop", async () => {
+    // The idle window can't fire; the max must, so a wedged tool that keeps
+    // emitting output chunks still ends the consult.
+    const d = createConsultDeadline({ idleMs: 10_000, maxMs: 70 });
+    try {
+      for (let i = 0; i < 8; i++) {
+        await delay(25);
+        feed(d, { type: "tool_output_chunk", chunk: "x" } as AssistantEvent);
+      }
+      expect(d.signal.aborted).toBe(true);
+    } finally {
+      d.dispose();
+    }
+  });
+});