@ulearning/ai-sdk 0.0.0-stage → 1.0.0-next.0

package/src/adapters/OpenAIRealtimeVoiceAdapter.test.ts

@@ -0,0 +1,761 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { OpenAIRealtimeVoiceAdapter } from "./OpenAIRealtimeVoiceAdapter";
+
+const deferred = <T>() => {
+  let resolve!: (value: T) => void;
+  let reject!: (reason: unknown) => void;
+  const promise = new Promise<T>((yes, no) => {
+    resolve = yes;
+    reject = no;
+  });
+  return { promise, resolve, reject };
+};
+
+class Channel {
+  readyState = "connecting";
+  onopen: (() => void) | null = null;
+  onclose: (() => void) | null = null;
+  onerror: (() => void) | null = null;
+  onmessage: ((event: { data: string }) => void) | null = null;
+  send = vi.fn<(data: string) => void>();
+  close = vi.fn(() => {
+    this.readyState = "closed";
+    this.onclose?.();
+  });
+  open() {
+    this.readyState = "open";
+    this.onopen?.();
+  }
+  emit(event: unknown) {
+    this.onmessage?.({ data: JSON.stringify(event) });
+  }
+  events() {
+    return this.send.mock.calls.map(([data]) => JSON.parse(data));
+  }
+}
+
+class Peer {
+  static instances: Peer[] = [];
+  channel = new Channel();
+  connectionState = "new";
+  onconnectionstatechange: (() => void) | null = null;
+  ontrack: ((event: { track: { kind: string } }) => void) | null = null;
+  createDataChannel = vi.fn(() => this.channel);
+  addTrack = vi.fn();
+  createOffer = vi.fn(async () => ({ type: "offer", sdp: "browser-offer" }));
+  setLocalDescription = vi.fn(async () => {});
+  setRemoteDescription = vi.fn(async () => {});
+  getStats = vi.fn(
+    async () =>
+      new Map([
+        ["input", { type: "media-source", audioLevel: 0.7 }],
+        ["output", { type: "inbound-rtp", audioLevel: 0.4 }],
+      ]),
+  );
+  close = vi.fn(() => {
+    this.connectionState = "closed";
+    this.onconnectionstatechange?.();
+  });
+  constructor() {
+    Peer.instances.push(this);
+  }
+}
+
+const track = { enabled: true, stop: vi.fn() };
+const stream = { getTracks: () => [track], getAudioTracks: () => [track] };
+const getUserMedia = vi.fn(async () => stream);
+const audio = {
+  autoplay: false,
+  srcObject: null as unknown,
+  play: vi.fn(async () => {}),
+  pause: vi.fn(),
+};
+const exchangeSdp = vi.fn<
+  (sdp: string, options: { signal: AbortSignal }) => Promise<string>
+>(async () => "server-answer");
+const sessions: ReturnType<OpenAIRealtimeVoiceAdapter["connect"]>[] = [];
+
+const start = (abortSignal?: AbortSignal) => {
+  const session = new OpenAIRealtimeVoiceAdapter({ exchangeSdp }).connect(
+    abortSignal ? { abortSignal } : {},
+  );
+  sessions.push(session);
+  const peer = Peer.instances.at(-1)!;
+  return { session, peer, channel: peer.channel };
+};
+
+const connected = async () => {
+  const result = start();
+  await vi.waitFor(() =>
+    expect(result.peer.setRemoteDescription).toHaveBeenCalled(),
+  );
+  result.channel.open();
+  result.channel.emit({
+    type: "session.created",
+    session: {
+      audio: { input: { transcription: { model: "gpt-4o-mini-transcribe" } } },
+    },
+  });
+  return result;
+};
+
+beforeEach(() => {
+  Peer.instances = [];
+  track.enabled = true;
+  getUserMedia.mockResolvedValue(stream);
+  exchangeSdp.mockResolvedValue("server-answer");
+  audio.play.mockResolvedValue();
+  vi.stubGlobal("RTCPeerConnection", Peer);
+  vi.stubGlobal("navigator", { mediaDevices: { getUserMedia } });
+  vi.stubGlobal("document", { createElement: () => audio });
+  vi.stubGlobal(
+    "MediaStream",
+    class {
+      tracks: unknown[];
+      constructor(tracks: unknown[]) {
+        this.tracks = tracks;
+      }
+    },
+  );
+});
+
+afterEach(() => {
+  for (const session of sessions.splice(0)) session.disconnect();
+  vi.unstubAllGlobals();
+  vi.useRealTimers();
+});
+
+describe("OpenAIRealtimeVoiceAdapter", () => {
+  it("exchanges SDP and waits for the data channel before becoming usable", async () => {
+    const { session, peer, channel } = start();
+    await vi.waitFor(() => expect(exchangeSdp).toHaveBeenCalled());
+    expect(exchangeSdp).toHaveBeenCalledWith("browser-offer", {
+      signal: expect.any(AbortSignal),
+    });
+    expect(peer.setRemoteDescription).toHaveBeenCalledWith({
+      type: "answer",
+      sdp: "server-answer",
+    });
+    expect(peer.addTrack).toHaveBeenCalledWith(track, stream);
+    expect(session.status).toEqual({ type: "starting" });
+    channel.open();
+    expect(session.status).toEqual({ type: "running" });
+    expect(session.sendText).toBeTypeOf("function");
+  });
+
+  it("streams cumulative assistant transcripts and records completed user audio", async () => {
+    const { session, channel } = await connected();
+    const onTranscript = vi.fn();
+    session.onTranscript(onTranscript);
+    channel.emit({
+      type: "conversation.item.input_audio_transcription.completed",
+      transcript: "Hello",
+    });
+    channel.emit({
+      type: "response.output_audio_transcript.delta",
+      item_id: "a",
+      delta: "Good ",
+    });
+    channel.emit({
+      type: "response.output_audio_transcript.delta",
+      item_id: "a",
+      delta: "morning",
+    });
+    channel.emit({
+      type: "response.output_audio_transcript.done",
+      item_id: "a",
+      transcript: "Good morning!",
+    });
+    channel.emit({
+      type: "response.output_audio_transcript.delta",
+      item_id: "b",
+      delta: "Next",
+    });
+    expect(onTranscript.mock.calls.map(([item]) => item)).toEqual([
+      { role: "user", text: "Hello", isFinal: true },
+      { role: "assistant", text: "Good ", isFinal: false },
+      { role: "assistant", text: "Good morning", isFinal: false },
+      { role: "assistant", text: "Good morning!", isFinal: true },
+      { role: "assistant", text: "Next", isFinal: false },
+    ]);
+  });
+
+  it("uses audio playback events instead of generation completion for speaking state", async () => {
+    const { session, channel } = await connected();
+    const onMode = vi.fn();
+    session.onModeChange(onMode);
+    channel.emit({ type: "output_audio_buffer.started" });
+    channel.emit({ type: "response.done", response: { status: "completed" } });
+    expect(onMode.mock.calls).toEqual([["speaking"]]);
+    channel.emit({ type: "input_audio_buffer.speech_started" });
+    expect(onMode.mock.calls).toEqual([["speaking"]]);
+    channel.emit({ type: "output_audio_buffer.cleared" });
+    expect(onMode).toHaveBeenLastCalledWith("listening");
+  });
+
+  it("holds replies until preceding spoken turns are transcribed in conversation order", async () => {
+    const { session, channel } = await connected();
+    const onTranscript = vi.fn();
+    session.onTranscript(onTranscript);
+    for (const id of ["first", "second"]) {
+      channel.emit({ type: "input_audio_buffer.committed", item_id: id });
+      channel.emit({
+        type: "response.output_audio_transcript.done",
+        item_id: `${id}-reply`,
+        transcript: `Reply to ${id}`,
+      });
+    }
+    channel.emit({
+      type: "conversation.item.input_audio_transcription.completed",
+      item_id: "second",
+      transcript: "Second question",
+    });
+    expect(onTranscript).not.toHaveBeenCalled();
+    channel.emit({
+      type: "conversation.item.input_audio_transcription.completed",
+      item_id: "first",
+      transcript: "First question",
+    });
+    expect(onTranscript.mock.calls.map(([item]) => item)).toEqual([
+      { role: "user", text: "First question", isFinal: true },
+      { role: "assistant", text: "Reply to first", isFinal: true },
+      { role: "user", text: "Second question", isFinal: true },
+      { role: "assistant", text: "Reply to second", isFinal: true },
+    ]);
+  });
+
+  it("keeps a streaming reply together when the user transcript arrives after its first delta", async () => {
+    const { session, channel } = await connected();
+    const onTranscript = vi.fn();
+    session.onTranscript(onTranscript);
+    channel.emit({ type: "input_audio_buffer.committed", item_id: "user" });
+    channel.emit({
+      type: "response.output_audio_transcript.delta",
+      item_id: "reply",
+      delta: "Good ",
+    });
+    expect(onTranscript).not.toHaveBeenCalled();
+    channel.emit({
+      type: "conversation.item.input_audio_transcription.completed",
+      item_id: "user",
+      transcript: "Hello",
+    });
+    channel.emit({
+      type: "response.output_audio_transcript.delta",
+      item_id: "reply",
+      delta: "morning",
+    });
+    channel.emit({
+      type: "response.output_audio_transcript.done",
+      item_id: "reply",
+      transcript: "Good morning",
+    });
+    expect(onTranscript.mock.calls.map(([item]) => item)).toEqual([
+      { role: "user", text: "Hello", isFinal: true },
+      { role: "assistant", text: "Good ", isFinal: false },
+      { role: "assistant", text: "Good morning", isFinal: false },
+      { role: "assistant", text: "Good morning", isFinal: true },
+    ]);
+  });
+
+  it("releases replies after transcription failure and keeps the call usable", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const { session, channel } = await connected();
+      const onTranscript = vi.fn();
+      session.onTranscript(onTranscript);
+      channel.emit({ type: "input_audio_buffer.committed", item_id: "user" });
+      channel.emit({
+        type: "response.output_audio_transcript.done",
+        item_id: "reply",
+        transcript: "Please repeat that",
+      });
+      channel.emit({
+        type: "conversation.item.input_audio_transcription.failed",
+        item_id: "user",
+        error: { message: "Could not transcribe" },
+      });
+      channel.emit({ type: "response.done", response: { status: "failed" } });
+      channel.emit({
+        type: "error",
+        error: {
+          code: "conversation_already_has_active_response",
+          message: "Already responding",
+        },
+      });
+      expect(session.status.type).toBe("running");
+      expect(onTranscript).toHaveBeenCalledWith({
+        role: "assistant",
+        text: "Please repeat that",
+        isFinal: true,
+      });
+      expect(track.stop).not.toHaveBeenCalled();
+      expect(warn).toHaveBeenCalled();
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it.each(["session.created", "session.updated"])(
+    "streams replies with transcription disabled by %s",
+    async (type) => {
+      const { session, channel } = await connected();
+      const onTranscript = vi.fn();
+      session.onTranscript(onTranscript);
+      channel.emit({
+        type,
+        session: { audio: { input: { transcription: null } } },
+      });
+      channel.emit({ type: "input_audio_buffer.committed", item_id: "user" });
+      channel.emit({
+        type: "response.output_audio_transcript.delta",
+        item_id: "reply",
+        delta: "Hello",
+      });
+      channel.emit({
+        type: "response.output_audio_transcript.done",
+        item_id: "reply",
+        transcript: "Hello!",
+      });
+      expect(onTranscript.mock.calls.map(([item]) => item)).toEqual([
+        { role: "assistant", text: "Hello", isFinal: false },
+        { role: "assistant", text: "Hello!", isFinal: true },
+      ]);
+    },
+  );
+
+  it("releases later turns when a failed response omits the final transcript event", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const { session, channel } = await connected();
+      const onTranscript = vi.fn();
+      session.onTranscript(onTranscript);
+      channel.emit({
+        type: "response.output_audio_transcript.delta",
+        item_id: "reply",
+        delta: "Partial",
+      });
+      channel.emit({ type: "input_audio_buffer.committed", item_id: "user" });
+      channel.emit({
+        type: "conversation.item.input_audio_transcription.completed",
+        item_id: "user",
+        transcript: "Next question",
+      });
+      channel.emit({ type: "response.done", response: { status: "failed" } });
+      channel.emit({
+        type: "response.output_audio_transcript.done",
+        item_id: "next-reply",
+        transcript: "Next reply",
+      });
+      channel.emit({
+        type: "response.done",
+        response: { status: "completed" },
+      });
+      expect(onTranscript.mock.calls.map(([item]) => item)).toEqual([
+        { role: "assistant", text: "Partial", isFinal: false },
+        { role: "assistant", text: "Partial", isFinal: true },
+        { role: "user", text: "Next question", isFinal: true },
+        { role: "assistant", text: "Next reply", isFinal: true },
+      ]);
+      expect(session.status.type).toBe("running");
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it("cleans up a typed request when the data channel rejects the send", async () => {
+    vi.useFakeTimers();
+    const { session, channel } = await connected();
+    channel.send.mockImplementation(() => {
+      throw new Error("Channel unavailable");
+    });
+    await expect(session.sendText!("Hello")).rejects.toThrow(
+      "Channel unavailable",
+    );
+    expect(vi.getTimerCount()).toBe(1);
+    session.disconnect();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it.each([true, false])(
+    "keeps an uninterrupted assistant message together when the next user transcript finishes early: %s",
+    async (early) => {
+      const { session, channel } = await connected();
+      const onTranscript = vi.fn();
+      session.onTranscript(onTranscript);
+      channel.emit({
+        type: "session.updated",
+        session: {
+          audio: {
+            input: {
+              transcription: { model: "gpt-4o-mini-transcribe" },
+              turn_detection: { type: "server_vad", interrupt_response: false },
+            },
+          },
+        },
+      });
+      channel.emit({
+        type: "response.output_audio_transcript.delta",
+        item_id: "reply",
+        delta: "Good ",
+      });
+      channel.emit({
+        type: "input_audio_buffer.committed",
+        item_id: "next-user",
+      });
+      const user = {
+        type: "conversation.item.input_audio_transcription.completed",
+        item_id: "next-user",
+        transcript: "Next question",
+      };
+      if (early) channel.emit(user);
+      channel.emit({
+        type: "response.output_audio_transcript.delta",
+        item_id: "reply",
+        delta: "morning",
+      });
+      channel.emit({
+        type: "response.output_audio_transcript.done",
+        item_id: "reply",
+        transcript: "Good morning",
+      });
+      if (!early) channel.emit(user);
+      expect(onTranscript.mock.calls.map(([item]) => item)).toEqual([
+        { role: "assistant", text: "Good ", isFinal: false },
+        { role: "assistant", text: "Good morning", isFinal: false },
+        { role: "assistant", text: "Good morning", isFinal: true },
+        { role: "user", text: "Next question", isFinal: true },
+      ]);
+    },
+  );
+
+  it("waits for both typed item and response acceptance without echoing the transcript", async () => {
+    const { session, channel } = await connected();
+    const onTranscript = vi.fn();
+    const accepted = vi.fn();
+    session.onTranscript(onTranscript);
+    channel.emit({ type: "response.created" });
+    channel.emit({
+      type: "response.output_audio_transcript.delta",
+      item_id: "old-reply",
+      delta: "Previous reply",
+    });
+    channel.emit({ type: "output_audio_buffer.started" });
+    const sent = Promise.resolve(session.sendText!("Change the topic"));
+    void sent.then(accepted);
+    const events = channel.events();
+    expect(events.map((event) => event.type)).toEqual([
+      "response.cancel",
+      "output_audio_buffer.clear",
+      "conversation.item.create",
+    ]);
+    expect(events[2].item).toMatchObject({
+      role: "user",
+      content: [{ type: "input_text", text: "Change the topic" }],
+    });
+    channel.emit({ type: "response.done", response: { status: "cancelled" } });
+    expect(onTranscript.mock.calls.map(([item]) => item)).toEqual([
+      { role: "assistant", text: "Previous reply", isFinal: false },
+      { role: "assistant", text: "Previous reply", isFinal: true },
+    ]);
+    expect(accepted).not.toHaveBeenCalled();
+    channel.emit({
+      type: "conversation.item.added",
+      item: { id: "unrelated" },
+    });
+    expect(accepted).not.toHaveBeenCalled();
+    channel.emit({
+      type: "conversation.item.added",
+      item: { id: events[2].item.id },
+    });
+    await vi.waitFor(() =>
+      expect(channel.events().at(-1).type).toBe("response.create"),
+    );
+    expect(accepted).not.toHaveBeenCalled();
+    channel.emit({
+      type: "response.created",
+      response: { metadata: { aui_request_id: "unrelated" } },
+    });
+    await Promise.resolve();
+    expect(accepted).not.toHaveBeenCalled();
+    const response = channel.events().at(-1);
+    expect(response.response.metadata.aui_request_id).toBe(response.event_id);
+    channel.emit({
+      type: "response.created",
+      response: { metadata: response.response.metadata },
+    });
+    await sent;
+    expect(onTranscript.mock.calls.map(([item]) => item)).toEqual([
+      { role: "assistant", text: "Previous reply", isFinal: false },
+      { role: "assistant", text: "Previous reply", isFinal: true },
+    ]);
+  });
+
+  it("rejects a typed send whose response request fails after the item was accepted", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const { session, channel } = await connected();
+      const rejected = expect(session.sendText!("Hello")).rejects.toThrow(
+        "Already responding",
+      );
+      const item = channel.events().at(-1);
+      channel.emit({
+        type: "conversation.item.added",
+        item: { id: item.item.id },
+      });
+      await vi.waitFor(() =>
+        expect(channel.events().at(-1).type).toBe("response.create"),
+      );
+      channel.emit({
+        type: "error",
+        error: {
+          event_id: channel.events().at(-1).event_id,
+          code: "conversation_already_has_active_response",
+          message: "Already responding",
+        },
+      });
+      await rejected;
+      expect(session.status.type).toBe("running");
+      expect(track.stop).not.toHaveBeenCalled();
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it("rejects a pending text send on disconnect", async () => {
+    const { session } = await connected();
+    const sent = session.sendText!("Hello");
+    const rejected = expect(sent).rejects.toThrow(
+      "disconnected before accepting",
+    );
+    session.disconnect();
+    await rejected;
+  });
+
+  it.each(["disconnect", "timeout"])(
+    "rejects a typed send on %s while waiting for response acceptance",
+    async (failure) => {
+      const { session, channel } = await connected();
+      vi.useFakeTimers();
+      const rejected = expect(session.sendText!("Hello")).rejects.toThrow(
+        failure === "disconnect"
+          ? "disconnected before accepting"
+          : "did not acknowledge",
+      );
+      channel.emit({
+        type: "conversation.item.added",
+        item: { id: channel.events().at(-1).item.id },
+      });
+      await vi.waitFor(() =>
+        expect(channel.events().at(-1).type).toBe("response.create"),
+      );
+      if (failure === "disconnect") session.disconnect();
+      else await vi.advanceTimersByTimeAsync(10_000);
+      await rejected;
+      session.disconnect();
+      expect(vi.getTimerCount()).toBe(0);
+    },
+  );
+
+  it("rejects an unacknowledged text send instead of committing it to history", async () => {
+    const { session } = await connected();
+    vi.useFakeTimers();
+    const rejected = expect(session.sendText!("Hello")).rejects.toThrow(
+      "did not acknowledge",
+    );
+    await vi.advanceTimersByTimeAsync(10_000);
+    await rejected;
+  });
+
+  it("stops microphone capture, playback, timers, and WebRTC exactly once", async () => {
+    vi.useFakeTimers();
+    const { session, peer, channel } = await connected();
+    peer.ontrack?.({ track: { kind: "audio" } });
+    expect(audio.play).toHaveBeenCalledOnce();
+    session.disconnect();
+    session.disconnect();
+    expect(track.stop).toHaveBeenCalledOnce();
+    expect(audio.pause).toHaveBeenCalledOnce();
+    expect(audio.srcObject).toBeNull();
+    expect(channel.close).toHaveBeenCalledOnce();
+    expect(peer.close).toHaveBeenCalledOnce();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it("mutes the microphone and excludes it from volume measurements", async () => {
+    vi.useFakeTimers();
+    const { session } = await connected();
+    const onVolume = vi.fn();
+    session.onVolumeChange(onVolume);
+    await vi.advanceTimersByTimeAsync(100);
+    expect(onVolume).toHaveBeenLastCalledWith(0.7);
+    session.mute();
+    expect(track.enabled).toBe(false);
+    await vi.advanceTimersByTimeAsync(100);
+    expect(onVolume).toHaveBeenLastCalledWith(0.4);
+    session.unmute();
+    expect(track.enabled).toBe(true);
+  });
+
+  it("applies a mute requested while microphone permission is pending", async () => {
+    const permission = deferred<typeof stream>();
+    getUserMedia.mockReturnValue(permission.promise);
+    const { session, peer } = start();
+    session.mute();
+    permission.resolve(stream);
+    await vi.waitFor(() =>
+      expect(peer.setRemoteDescription).toHaveBeenCalled(),
+    );
+    expect(track.enabled).toBe(false);
+  });
+
+  it("disposes immediately while microphone permission is pending and stops a late stream", async () => {
+    const permission = deferred<typeof stream>();
+    getUserMedia.mockReturnValue(permission.promise);
+    const { session, peer } = start();
+    session.disconnect();
+    await vi.waitFor(() => expect(peer.close).toHaveBeenCalledOnce());
+    permission.resolve(stream);
+    await vi.waitFor(() => expect(track.stop).toHaveBeenCalledOnce());
+    expect(exchangeSdp).not.toHaveBeenCalled();
+  });
+
+  it("aborts an in-flight SDP exchange without installing a late answer", async () => {
+    const answer = deferred<string>();
+    exchangeSdp.mockReturnValue(answer.promise);
+    const controller = new AbortController();
+    const { session, peer } = start(controller.signal);
+    await vi.waitFor(() => expect(exchangeSdp).toHaveBeenCalled());
+    const [, options] = exchangeSdp.mock.calls[0]!;
+    controller.abort();
+    expect(options.signal.aborted).toBe(true);
+    expect(track.stop).toHaveBeenCalledOnce();
+    answer.resolve("late-answer");
+    await Promise.resolve();
+    expect(peer.setRemoteDescription).not.toHaveBeenCalled();
+    expect(session.status).toEqual({ type: "ended", reason: "cancelled" });
+  });
+
+  it("cleans up on permission rejection", async () => {
+    const error = new Error("Permission denied");
+    getUserMedia.mockRejectedValue(error);
+    const { session, peer } = start();
+    await vi.waitFor(() =>
+      expect(session.status).toEqual({ type: "ended", reason: "error", error }),
+    );
+    expect(peer.close).toHaveBeenCalledOnce();
+    expect(exchangeSdp).not.toHaveBeenCalled();
+  });
+
+  it("cleans up on signaling rejection", async () => {
+    const error = new Error("Unauthorized");
+    exchangeSdp.mockRejectedValue(error);
+    const { session, peer } = start();
+    await vi.waitFor(() =>
+      expect(session.status).toEqual({ type: "ended", reason: "error", error }),
+    );
+    expect(track.stop).toHaveBeenCalledOnce();
+    expect(peer.close).toHaveBeenCalledOnce();
+  });
+
+  it("times out a connection whose channel never opens", async () => {
+    vi.useFakeTimers();
+    const { session, peer } = start();
+    await vi.waitFor(() =>
+      expect(peer.setRemoteDescription).toHaveBeenCalled(),
+    );
+    await vi.advanceTimersByTimeAsync(30_000);
+    expect(session.status).toMatchObject({ type: "ended", reason: "error" });
+    expect(track.stop).toHaveBeenCalledOnce();
+    expect(peer.close).toHaveBeenCalledOnce();
+  });
+
+  it.each(["failed", "closed"])(
+    "cleans up when the peer becomes %s",
+    async (state) => {
+      const { session, peer } = await connected();
+      peer.connectionState = state;
+      peer.onconnectionstatechange?.();
+      expect(session.status).toMatchObject({
+        type: "ended",
+        reason: state === "failed" ? "error" : "finished",
+      });
+      expect(track.stop).toHaveBeenCalledOnce();
+    },
+  );
+
+  it("rejects the affected message on a provider error without ending the call", async () => {
+    const { session, channel } = await connected();
+    const rejected = expect(session.sendText!("Hello")).rejects.toThrow();
+    const id = channel.events().at(-1).event_id;
+    channel.emit({
+      type: "error",
+      error: { event_id: id, message: "Invalid item" },
+    });
+    await rejected;
+    expect(session.status.type).toBe("running");
+    expect(track.stop).not.toHaveBeenCalled();
+  });
+
+  it("ignores malformed and unrelated events", async () => {
+    const { session, channel } = await connected();
+    const onTranscript = vi.fn();
+    session.onTranscript(onTranscript);
+    channel.onmessage?.({ data: "not-json" });
+    for (const event of [
+      null,
+      [],
+      {},
+      { type: "session.updated" },
+      { type: "response.output_audio_transcript.delta" },
+      { type: "response.output_audio_transcript.done", item_id: "a" },
+      { type: "conversation.item.input_audio_transcription.completed" },
+    ])
+      channel.emit(event);
+    expect(onTranscript).not.toHaveBeenCalled();
+    expect(session.status.type).toBe("running");
+  });
+
+  it("reports unsupported environments through session status", async () => {
+    vi.stubGlobal("RTCPeerConnection", undefined);
+    const session = new OpenAIRealtimeVoiceAdapter({ exchangeSdp }).connect({});
+    await vi.waitFor(() =>
+      expect(session.status).toMatchObject({ type: "ended", reason: "error" }),
+    );
+    expect(getUserMedia).not.toHaveBeenCalled();
+  });
+
+  it("does not restart the volume meter when a status listener disconnects", async () => {
+    vi.useFakeTimers();
+    const { session, peer, channel } = start();
+    await vi.waitFor(() =>
+      expect(peer.setRemoteDescription).toHaveBeenCalled(),
+    );
+    session.onStatusChange((status) => {
+      if (status.type === "running") session.disconnect();
+    });
+    channel.open();
+    expect(session.status).toEqual({ type: "ended", reason: "cancelled" });
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it("ends the session when remote audio cannot be played", async () => {
+    const { session, peer } = await connected();
+    const error = new Error("Autoplay blocked");
+    audio.play.mockRejectedValue(error);
+    peer.ontrack?.({ track: { kind: "audio" } });
+    await vi.waitFor(() =>
+      expect(session.status).toEqual({ type: "ended", reason: "error", error }),
+    );
+    expect(track.stop).toHaveBeenCalledOnce();
+  });
+
+  it("does not allocate media for an already-aborted connection", () => {
+    const session = new OpenAIRealtimeVoiceAdapter({ exchangeSdp }).connect({
+      abortSignal: AbortSignal.abort(),
+    });
+    expect(session.status).toEqual({ type: "ended", reason: "cancelled" });
+    expect(Peer.instances).toHaveLength(0);
+    expect(getUserMedia).not.toHaveBeenCalled();
+  });
+});