@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/live-voice/__tests__/live-voice-managed-speech-fallback.test.ts

@@ -54,7 +54,10 @@ let requestedSttProviders: (string | undefined)[];
 
 /** A provider yields a streaming transcriber when its credential resolves. */
 function transcriberFor(providerId: string | undefined): boolean {
-  return providerId === "vellum"
+  // Both managed rows ride the same platform connection, so neither has a
+  // credential of its own. Live voice asks for the flux row specifically,
+  // since managed live voice resolves to it when no family is named.
+  return providerId === "vellum" || providerId === "vellum-flux"
     ? managedAvailable
     : providerId !== undefined && providerKeys[providerId] !== undefined;
 }
@@ -218,8 +221,10 @@ describe("live voice on managed speech", () => {
     expect(readiness).toEqual({ status: "ready" });
 
     // The transcriber the session arms is asked for the same provider the
-    // readiness verdict was earned on.
-    expect(requestedSttProviders).toEqual(["vellum"]);
+    // readiness verdict was earned on. Live voice resolves the flux row while
+    // the roleless verdict above stays on the base one, which is the whole
+    // point of resolving per role.
+    expect(requestedSttProviders).toEqual(["vellum-flux"]);
     expect(readConfigFile()).toBe(configBefore);
   });
 

package/src/live-voice/__tests__/live-voice-session-manager.test.ts

@@ -122,24 +122,86 @@ describe("LiveVoiceSessionManager", () => {
     const rejected = await manager.startSession(START_FRAME, second.sink);
 
     expect(accepted).toEqual({ status: "accepted", sessionId: "session-1" });
+    const busyFrame = {
+      type: "busy",
+      seq: 1,
+      activeSessionId: "session-1",
+      // Names where the blocking session is, so the refused client has
+      // somewhere to point the user.
+      holder: { conversationId: "conversation-123" },
+    } as const satisfies LiveVoiceServerFrame;
     expect(rejected).toEqual({
       status: "busy",
       activeSessionId: "session-1",
+      frame: busyFrame,
+    });
+    expect(second.frames).toEqual([busyFrame]);
+    expect(sessions).toHaveLength(1);
+    expect(sessions[0]?.start).toHaveBeenCalledTimes(1);
+  });
+
+  test("names the holder's device and the conversation it landed in", async () => {
+    const sessions: TestSession[] = [];
+    const manager = new LiveVoiceSessionManager({
+      createSessionId: mock(() => `session-${sessions.length + 1}`),
+      createSession: (context) => {
+        const session = createTestSession({
+          start: mock(async () => {
+            await context.sendFrame({
+              type: "ready",
+              sessionId: context.sessionId,
+              // The session minted its own conversation, so the start frame's
+              // is not the one to send anybody to.
+              conversationId: "conversation-minted",
+            });
+          }),
+        });
+        sessions.push(session);
+        return session;
+      },
+    });
+    const second = createSink();
+
+    await manager.startSession(
+      { ...START_FRAME, client: "ios" },
+      createSink().sink,
+    );
+    const rejected = await manager.startSession(START_FRAME, second.sink);
+
+    expect(rejected).toMatchObject({
+      status: "busy",
       frame: {
-        type: "busy",
-        seq: 1,
-        activeSessionId: "session-1",
+        holder: { client: "ios", conversationId: "conversation-minted" },
       },
     });
-    expect(second.frames).toEqual([
-      {
-        type: "busy",
-        seq: 1,
-        activeSessionId: "session-1",
+  });
+
+  test("says nothing about a holder that revealed nothing", async () => {
+    const sessions: TestSession[] = [];
+    const manager = new LiveVoiceSessionManager({
+      createSessionId: mock(() => `session-${sessions.length + 1}`),
+      createSession: () => {
+        const session = createTestSession();
+        sessions.push(session);
+        return session;
       },
-    ]);
-    expect(sessions).toHaveLength(1);
-    expect(sessions[0]?.start).toHaveBeenCalledTimes(1);
+    });
+    const anonymous = {
+      type: "start",
+      audio: START_FRAME.audio,
+    } as const satisfies LiveVoiceClientStartFrame;
+    const second = createSink();
+
+    await manager.startSession(anonymous, createSink().sink);
+    const rejected = await manager.startSession(anonymous, second.sink);
+
+    // An empty holder would read as "we know where it is" while naming
+    // nothing, so the field is dropped and the client uses its vaguer copy.
+    expect(rejected).toEqual({
+      status: "busy",
+      activeSessionId: "session-1",
+      frame: { type: "busy", seq: 1, activeSessionId: "session-1" },
+    });
   });
 
   test("releases the active session once for repeated close events", async () => {

package/src/live-voice/__tests__/live-voice-session-preflight.test.ts

@@ -7,6 +7,10 @@
  * the start frame with a `credentials_unavailable` error frame carrying
  * the preflight's user message, before any transcriber is resolved, and
  * leaves the session manager free for a retry.
+ *
+ * They also pin the one exception to that rule: a client that declared
+ * `textInput` opens text-only when the *only* thing missing is the
+ * speech-to-text leg, because a session it can type into beats no session.
  */
 
 import { describe, expect, mock, test } from "bun:test";
@@ -35,6 +39,24 @@ const START_FRAME = {
   },
 } as const satisfies LiveVoiceClientStartFrame;
 
+const START_FRAME_TEXT_INPUT = {
+  ...START_FRAME,
+  textInput: true,
+} as const satisfies LiveVoiceClientStartFrame;
+
+const STT_GAP = {
+  kind: "stt",
+  providerId: "deepgram",
+  reason: 'STT provider "deepgram" is missing credentials (Deepgram API Key)',
+} as const;
+
+const NOT_READY_STT_ONLY: LiveVoiceCredentialReadiness = {
+  status: "not-ready",
+  missing: [STT_GAP],
+  userMessage:
+    'Live voice is unavailable because it requires an API key for the speech-to-text provider "deepgram" (Deepgram API Key).',
+};
+
 const NOT_READY: LiveVoiceCredentialReadiness = {
   status: "not-ready",
   missing: [
@@ -60,7 +82,7 @@ class MockStreamingTranscriber implements StreamingTranscriber {
   stop(): void {}
 }
 
-function createContext(): {
+function createContext(startFrame: LiveVoiceClientStartFrame = START_FRAME): {
   context: LiveVoiceSessionFactoryContext;
   frames: LiveVoiceServerFrame[];
 } {
@@ -71,7 +93,7 @@ function createContext(): {
     frames,
     context: {
       sessionId: "session-123",
-      startFrame: START_FRAME,
+      startFrame,
       sendFrame: mock(async (payload) => {
         const frame = sequencer.next(payload);
         frames.push(frame);
@@ -128,6 +150,130 @@ describe("live-voice session credential preflight gating", () => {
     await session.close("websocket_close");
   });
 
+  test("ready preflight leaves audioInput off the ready frame", async () => {
+    // Absent means "the microphone leg is live", which is what every session
+    // that passes the preflight has. Only a downgraded session says otherwise.
+    const { context, frames } = createContext();
+    const session = new LiveVoiceSession(context, {
+      resolveTranscriber: mock(async () => new MockStreamingTranscriber()),
+      resolveCredentialReadiness: mock(
+        async (): Promise<LiveVoiceCredentialReadiness> => ({
+          status: "ready",
+        }),
+      ),
+    });
+
+    await session.start();
+
+    expect(frames[0]).toMatchObject({ type: "ready", textInput: true });
+    expect("audioInput" in (frames[0] ?? {})).toBe(false);
+
+    await session.close("websocket_close");
+  });
+
+  test("a text-input client opens text-only when only the STT leg is missing", async () => {
+    const { context, frames } = createContext(START_FRAME_TEXT_INPUT);
+    const resolveTranscriber = mock(async () => new MockStreamingTranscriber());
+    const session = new LiveVoiceSession(context, {
+      resolveTranscriber,
+      resolveCredentialReadiness: mock(async () => NOT_READY_STT_ONLY),
+    });
+
+    await session.start();
+
+    expect(frames).toHaveLength(1);
+    expect(frames[0]).toMatchObject({
+      type: "ready",
+      sessionId: "session-123",
+      conversationId: "conversation-123",
+      textInput: true,
+      audioInput: false,
+    });
+    // Nothing may arm: resolving a transcriber the preflight just said has no
+    // credential is what would fail the session through armUtterance.
+    expect(resolveTranscriber).not.toHaveBeenCalled();
+
+    await session.close("websocket_close");
+  });
+
+  test("a client without textInput is still rejected on a missing STT leg", async () => {
+    // The downgrade is only safe for a client that can take a turn some other
+    // way. Opening a mute, deaf session for one that cannot is worse than
+    // failing, because nothing in it can ever work.
+    const { context, frames } = createContext();
+    const session = new LiveVoiceSession(context, {
+      resolveTranscriber: mock(async () => new MockStreamingTranscriber()),
+      resolveCredentialReadiness: mock(async () => NOT_READY_STT_ONLY),
+    });
+
+    await expect(session.start()).rejects.toBeInstanceOf(
+      LiveVoiceSessionStartupError,
+    );
+
+    expect(frames).toEqual([
+      {
+        type: "error",
+        seq: 1,
+        code: "credentials_unavailable",
+        message: NOT_READY_STT_ONLY.userMessage,
+      },
+    ]);
+  });
+
+  test("a text-input client is still rejected when the TTS leg is missing", async () => {
+    // Text in, voice out: without the out half there is nothing to downgrade
+    // to, so this fails exactly as it would for any other client.
+    const { context, frames } = createContext(START_FRAME_TEXT_INPUT);
+    const session = new LiveVoiceSession(context, {
+      resolveTranscriber: mock(async () => new MockStreamingTranscriber()),
+      resolveCredentialReadiness: mock(async () => NOT_READY),
+    });
+
+    await expect(session.start()).rejects.toBeInstanceOf(
+      LiveVoiceSessionStartupError,
+    );
+
+    expect(frames[0]).toMatchObject({ code: "credentials_unavailable" });
+  });
+
+  test("a text-input client is still rejected when both legs are missing", async () => {
+    const { context } = createContext(START_FRAME_TEXT_INPUT);
+    const session = new LiveVoiceSession(context, {
+      resolveTranscriber: mock(async () => new MockStreamingTranscriber()),
+      resolveCredentialReadiness: mock(
+        async (): Promise<LiveVoiceCredentialReadiness> => ({
+          ...NOT_READY,
+          missing: [...NOT_READY.missing, STT_GAP],
+        }),
+      ),
+    });
+
+    await expect(session.start()).rejects.toBeInstanceOf(
+      LiveVoiceSessionStartupError,
+    );
+  });
+
+  test("a text-input client is still rejected when not-ready names no gap", async () => {
+    // A verdict that says not-ready and lists nothing is a resolver bug. It
+    // must not be read as "only STT is missing" and quietly opened half-working
+    // on the strength of a vacuously true check.
+    const { context } = createContext(START_FRAME_TEXT_INPUT);
+    const session = new LiveVoiceSession(context, {
+      resolveTranscriber: mock(async () => new MockStreamingTranscriber()),
+      resolveCredentialReadiness: mock(
+        async (): Promise<LiveVoiceCredentialReadiness> => ({
+          status: "not-ready",
+          missing: [],
+          userMessage: "Live voice is unavailable.",
+        }),
+      ),
+    });
+
+    await expect(session.start()).rejects.toBeInstanceOf(
+      LiveVoiceSessionStartupError,
+    );
+  });
+
   test("a rejected start frees the manager slot for a retry", async () => {
     const manager = new LiveVoiceSessionManager({
       createSession: (context) =>

package/src/live-voice/__tests__/live-voice-session-telemetry.test.ts

@@ -157,6 +157,70 @@ describe("live-voice session telemetry", () => {
     });
   });
 
+  /**
+   * Run one typed turn against a session with a real turn starter, then close.
+   *
+   * `readySession` wires none, so `handleTextTurn` returns before dispatching
+   * and every silence assertion against it passes for the wrong reason.
+   */
+  async function endAfterTypedTurn(frame: {
+    text: string;
+    hidden?: boolean;
+  }): Promise<void> {
+    let started = false;
+    const session = new LiveVoiceSession(createContext(), {
+      resolveTranscriber: mock(async () => new MockStreamingTranscriber()),
+      resolveCredentialReadiness: mock(
+        async (): Promise<LiveVoiceCredentialReadiness> => ({
+          status: "ready",
+        }),
+      ),
+      startVoiceTurn: mock(async () => {
+        started = true;
+        return { turnId: "bridge-turn-1", abort: mock() };
+      }),
+      emitMetrics: false,
+    });
+    await session.start();
+    await session.handleClientFrame({ type: "text", ...frame });
+    for (let attempt = 0; attempt < 40 && !started; attempt += 1) {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+    if (!started) {
+      throw new Error("the typed turn never reached the bridge");
+    }
+    await session.close("client_end");
+  }
+
+  test("the greeting that opens a session does not spend its silence reason", async () => {
+    // The classification answers "did anything come from the person?". A
+    // session that greets and hears nothing back is silent, and counting the
+    // greeting would retire the taxonomy for every greeted session.
+    await endAfterTypedTurn({
+      text: "this message is sent automatically",
+      hidden: true,
+    });
+
+    expect(recordLiveVoiceSessionEnded).toHaveBeenCalledWith({
+      sessionId: "session-123",
+      screen: "ended_client_end:silent_no_audio",
+      outcome: "completed",
+    });
+  });
+
+  test("a turn the user really took clears the silence reason", async () => {
+    // The other half, and what keeps the test above honest: the same path with
+    // an ordinary typed turn is the person taking a turn, so the session is
+    // not silent and carries no classification at all.
+    await endAfterTypedTurn({ text: "typed by hand" });
+
+    expect(recordLiveVoiceSessionEnded).toHaveBeenCalledWith({
+      sessionId: "session-123",
+      screen: "ended_client_end",
+      outcome: "completed",
+    });
+  });
+
   test("a dropped socket ends as completed, not failed", async () => {
     const session = readySession();
     await session.start();

package/src/live-voice/__tests__/live-voice-stt.test.ts

@@ -257,6 +257,7 @@ describe("LiveVoiceSession STT", () => {
         sessionId: "session-123",
         conversationId: "conversation-123",
         turnDetection: "manual",
+        textInput: true,
       },
     ]);
   });
@@ -611,6 +612,7 @@ describe("LiveVoiceSession STT", () => {
         sessionId: "session-123",
         conversationId: "conversation-123",
         turnDetection: "server_vad",
+        textInput: true,
       },
     ]);
 
@@ -700,6 +702,7 @@ describe("LiveVoiceSession STT", () => {
         sessionId: "session-123",
         conversationId: "conversation-123",
         turnDetection: "manual",
+        textInput: true,
       },
       {
         type: "error",