@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/live-voice/__tests__/live-activity-reporter.test.ts

@@ -37,6 +37,10 @@ class RecordingReporter extends LiveActivityReporter {
   readonly dispatched: Array<{ phase: string; event: string; detail: string }> =
     [];
 
+  waitForDispatches(): Promise<void> {
+    return this.waitForPendingDispatches();
+  }
+
   protected override async dispatch(
     phase: string,
     event: "update" | "end",
@@ -46,11 +50,55 @@ class RecordingReporter extends LiveActivityReporter {
   }
 }
 
-function activity(label: string): LiveVoiceServerFramePayload {
+class BlockingReporter extends LiveActivityReporter {
+  readonly dispatched: string[] = [];
+  private releaseFirstDispatch: (() => void) | null = null;
+  private readonly firstDispatch = new Promise<void>((resolve) => {
+    this.releaseFirstDispatch = resolve;
+  });
+
+  releaseFirst(): void {
+    this.releaseFirstDispatch?.();
+  }
+
+  waitForDispatches(): Promise<void> {
+    return this.waitForPendingDispatches();
+  }
+
+  protected override async dispatch(phase: string): Promise<void> {
+    this.dispatched.push(phase);
+    if (this.dispatched.length === 1) {
+      await this.firstDispatch;
+    }
+  }
+}
+
+class TimeoutReporter extends LiveActivityReporter {
+  readonly dispatched: string[] = [];
+  protected override readonly dispatchTimeoutMs = 1;
+
+  waitForDispatches(): Promise<void> {
+    return this.waitForPendingDispatches();
+  }
+
+  protected override async dispatch(phase: string): Promise<void> {
+    this.dispatched.push(phase);
+    if (this.dispatched.length > 1) {
+      return;
+    }
+    await new Promise<void>(() => undefined);
+  }
+}
+
+function activity(
+  label: string,
+  kind?: "escalation",
+): LiveVoiceServerFramePayload {
   return {
     type: "activity",
     turnId: "t1",
     label,
+    ...(kind ? { kind } : {}),
   } as LiveVoiceServerFramePayload;
 }
 
@@ -61,6 +109,9 @@ describe("phaseForFrame", () => {
     );
     expect(phaseForFrame(frame("thinking"), "transcribing")).toBe("thinking");
     expect(phaseForFrame(frame("tts_audio"), "thinking")).toBe("speaking");
+    expect(
+      phaseForFrame(activity("Working on that", "escalation"), "speaking"),
+    ).toBe("thinking");
   });
 
   test("a discarded utterance returns the floor to the user", () => {
@@ -96,10 +147,11 @@ describe("phaseForFrame", () => {
 });
 
 describe("LiveActivityReporter", () => {
-  test("reports a phase change once", () => {
+  test("reports a phase change once", async () => {
     const reporter = new RecordingReporter("conv-1");
 
     reporter.report(frame("thinking"));
+    await reporter.waitForDispatches();
 
     expect(reporter.dispatched).toEqual([
       { phase: "thinking", event: "update", detail: "" },
@@ -107,26 +159,31 @@ describe("LiveActivityReporter", () => {
   });
 
   // The whole reason this class exists rather than a bare fetch per frame.
-  test("does not re-report a phase it is already in", () => {
+  test("does not re-report a phase it is already in", async () => {
     const reporter = new RecordingReporter("conv-1");
 
     reporter.report(frame("tts_audio"));
     reporter.report(frame("tts_audio"));
     reporter.report(frame("tts_audio"));
+    await reporter.waitForDispatches();
 
     expect(reporter.dispatched).toEqual([
       { phase: "speaking", event: "update", detail: "" },
     ]);
   });
 
-  test("reports each genuine transition through a turn", () => {
+  test("reports each genuine transition through a turn", async () => {
     const reporter = new RecordingReporter("conv-1");
 
     reporter.report(frame("utterance_end"));
+    await reporter.waitForDispatches();
     reporter.report(sttFinal("hello there"));
+    await reporter.waitForDispatches();
     reporter.report(frame("tts_audio"));
     reporter.report(frame("tts_audio"));
+    await reporter.waitForDispatches();
     reporter.report(frame("tts_done"));
+    await reporter.waitForDispatches();
 
     expect(reporter.dispatched.map((d) => d.phase)).toEqual([
       "transcribing",
@@ -136,20 +193,63 @@ describe("LiveActivityReporter", () => {
     ]);
   });
 
-  test("frames that do not move the phase are ignored", () => {
+  test("serializes platform dispatches in frame order", async () => {
+    const reporter = new BlockingReporter("conv-1");
+
+    reporter.report(frame("tts_audio"));
+    reporter.report(activity("", "escalation"));
+    await Promise.resolve();
+
+    expect(reporter.dispatched).toEqual(["speaking"]);
+
+    reporter.releaseFirst();
+    await reporter.waitForDispatches();
+    expect(reporter.dispatched).toEqual(["speaking", "thinking"]);
+  });
+
+  test("a timed-out dispatch does not pin later phases", async () => {
+    const reporter = new TimeoutReporter("conv-1");
+
+    reporter.report(frame("tts_audio"));
+    reporter.report(activity("", "escalation"));
+    await reporter.waitForDispatches();
+
+    expect(reporter.dispatched).toEqual(["speaking", "thinking"]);
+  });
+
+  test("coalesces a queued backlog and keeps end next", async () => {
+    const reporter = new BlockingReporter("conv-1");
+
+    reporter.report(frame("utterance_end"));
+    reporter.report(frame("thinking"));
+    reporter.report(activity("Running a command"));
+    reporter.report(frame("tts_audio"));
+    reporter.end();
+    await Promise.resolve();
+
+    expect(reporter.dispatched).toEqual(["transcribing"]);
+
+    reporter.releaseFirst();
+    await reporter.waitForDispatches();
+    expect(reporter.dispatched).toEqual(["transcribing", "ending"]);
+  });
+
+  test("frames that do not move the phase are ignored", async () => {
     const reporter = new RecordingReporter("conv-1");
 
     reporter.report(frame("stt_partial"));
     reporter.report(frame("ready"));
+    await reporter.waitForDispatches();
 
     expect(reporter.dispatched).toEqual([]);
   });
 
-  test("ending retires the activity", () => {
+  test("ending retires the activity", async () => {
     const reporter = new RecordingReporter("conv-1");
     reporter.report(frame("tts_audio"));
 
     reporter.end();
+    await reporter.waitForDispatches();
 
     expect(reporter.dispatched.at(-1)).toEqual({
       phase: "ending",
@@ -161,20 +261,22 @@ describe("LiveActivityReporter", () => {
   // A session can end more than one way and the platform deletes the
   // registration on the first, so a second end would push at an activity that
   // is already gone.
-  test("ending twice pushes once", () => {
+  test("ending twice pushes once", async () => {
     const reporter = new RecordingReporter("conv-1");
 
     reporter.end();
     reporter.end();
+    await reporter.waitForDispatches();
 
     expect(reporter.dispatched).toHaveLength(1);
   });
 
-  test("a frame after the end is not reported", () => {
+  test("a frame after the end is not reported", async () => {
     const reporter = new RecordingReporter("conv-1");
 
     reporter.end();
     reporter.report(frame("tts_audio"));
+    await reporter.waitForDispatches();
 
     expect(reporter.dispatched).toEqual([
       { phase: "ending", event: "end", detail: "" },
@@ -183,12 +285,26 @@ describe("LiveActivityReporter", () => {
 });
 
 describe("LiveActivityReporter activity line", () => {
-  test("carries the activity label alongside the phase it holds", () => {
+  test("keeps escalation out of the Live Activity detail line", async () => {
+    const reporter = new RecordingReporter("conv-1");
+
+    reporter.report(frame("tts_audio"));
+    reporter.report(activity("Working on that", "escalation"));
+    await reporter.waitForDispatches();
+
+    expect(reporter.dispatched).toEqual([
+      { phase: "speaking", event: "update", detail: "" },
+      { phase: "thinking", event: "update", detail: "" },
+    ]);
+  });
+
+  test("carries the activity label alongside the phase it holds", async () => {
     const reporter = new RecordingReporter("conv-1");
 
     reporter.report(frame("utterance_end"));
     reporter.report(frame("thinking"));
     reporter.report(activity("Running a command"));
+    await reporter.waitForDispatches();
 
     expect(reporter.dispatched.at(-1)).toEqual({
       phase: "thinking",
@@ -199,12 +315,13 @@ describe("LiveActivityReporter activity line", () => {
 
   // A push replaces the whole content state, so the label has to ride along on
   // phase changes too, or the next phase would blank it.
-  test("keeps the label through a later phase change", () => {
+  test("keeps the label through a later phase change", async () => {
     const reporter = new RecordingReporter("conv-1");
 
     reporter.report(frame("thinking"));
     reporter.report(activity("Reading a file"));
     reporter.report(frame("tts_audio"));
+    await reporter.waitForDispatches();
 
     expect(reporter.dispatched.at(-1)).toEqual({
       phase: "speaking",
@@ -213,36 +330,56 @@ describe("LiveActivityReporter activity line", () => {
     });
   });
 
-  test("an empty label clears the line", () => {
+  test("restores thinking after bridge speech without clearing an overlay", async () => {
+    const reporter = new RecordingReporter("conv-1");
+
+    reporter.report(frame("thinking"));
+    reporter.report(frame("tts_audio"));
+    reporter.report(activity("Searching the web"));
+    reporter.restoreThinkingPhase();
+    await reporter.waitForDispatches();
+
+    expect(reporter.dispatched.at(-1)).toEqual({
+      phase: "thinking",
+      event: "update",
+      detail: "Searching the web",
+    });
+  });
+
+  test("an empty label clears the line", async () => {
     const reporter = new RecordingReporter("conv-1");
 
     reporter.report(frame("thinking"));
     reporter.report(activity("Reading a file"));
     reporter.report(activity(""));
+    await reporter.waitForDispatches();
 
     expect(reporter.dispatched.at(-1)?.detail).toBe("");
   });
 
-  test("does not dispatch a label it already sent", () => {
+  test("does not dispatch a label it already sent", async () => {
     const reporter = new RecordingReporter("conv-1");
 
     reporter.report(frame("thinking"));
     reporter.report(activity("Reading a file"));
+    await reporter.waitForDispatches();
     const before = reporter.dispatched.length;
     reporter.report(activity("Reading a file"));
+    await reporter.waitForDispatches();
 
     expect(reporter.dispatched.length).toBe(before);
   });
 
   // A tool can start before any phase-bearing frame lands. There is no content
   // state to attach a label to yet, and the phase that follows carries it.
-  test("holds a label that arrives before any phase", () => {
+  test("holds a label that arrives before any phase", async () => {
     const reporter = new RecordingReporter("conv-1");
 
     reporter.report(activity("Searching the web"));
     expect(reporter.dispatched).toEqual([]);
 
     reporter.report(frame("thinking"));
+    await reporter.waitForDispatches();
 
     expect(reporter.dispatched).toEqual([
       { phase: "thinking", event: "update", detail: "Searching the web" },
@@ -253,19 +390,21 @@ describe("LiveActivityReporter activity line", () => {
 describe("LiveActivityReporter and held utterances", () => {
   // End to end through the reporter, not just the mapping: a session using
   // semantic endpointing emits finals while the user still holds the floor.
-  test("a final during a held utterance pushes nothing", () => {
+  test("a final during a held utterance pushes nothing", async () => {
     const reporter = new RecordingReporter("conv-1");
 
     reporter.report(sttFinal("i was thinking maybe"));
+    await reporter.waitForDispatches();
 
     expect(reporter.dispatched).toEqual([]);
   });
 
-  test("the same final after utterance_end advances to thinking", () => {
+  test("the same final after utterance_end advances to thinking", async () => {
     const reporter = new RecordingReporter("conv-1");
 
     reporter.report(frame("utterance_end"));
     reporter.report(sttFinal("i was thinking maybe"));
+    await reporter.waitForDispatches();
 
     expect(reporter.dispatched.map((d) => d.phase)).toEqual([
       "transcribing",