try {

agentCommandMock

.mockResolvedValueOnce({ payloads: [{ text: "first answer" }] })

.mockResolvedValueOnce({ payloads: [{ text: "second answer" }] });

.mockResolvedValueOnce({ payloads: [{ text: "second answer" }] })

.mockResolvedValueOnce({ payloads: [{ text: "third answer" }] });

const manager = createManager({

groupPolicy: "open",

voice: {

});

await manager.join({ guildId: "g1", channelId: "1001" });

const player = getLastAudioPlayer();

const entry = getSessionEntry(manager) as {

realtime?: {

beginSpeakerTurn: (

await vi.advanceTimersByTimeAsync(1_510);

expectUserMessageIncludes("second answer");

const idleHandler = player.on.mock.calls.find(([event]) => event === "idle")?.[1] as

| (() => void)

| undefined;

idleHandler?.();

const thirdTurn = entry.realtime?.beginSpeakerTurn(

{ extraSystemPrompt: undefined, senderIsOwner: true, speakerLabel: "Owner" },

"u-owner",

);

thirdTurn?.sendInputAudio(Buffer.alloc(8));

bridgeParams?.onTranscript?.("user", "third question", true);

await vi.advanceTimersByTimeAsync(260);

expectUserMessageNotIncludes("third answer");

} finally {

vi.useRealTimers();

}

| { message: string; suppressed: number; lastLoggedAt: number }

| undefined;

private readonly playerIdleHandler = () => {

const hadOutputAudio = this.isOutputAudioActive();

this.resetOutputStream("player-idle");

this.completeExactSpeechResponse("player-idle");

if (hadOutputAudio) {

this.completeExactSpeechResponse("player-idle");

}

};

constructor(

return;

}

this.logOutputAudioStopped(reason);

this.clearOutputPlaybackWatchdog();

this.outputStream = null;

this.resetOutputAudioStats();

this.completeExactSpeechResponse(reason, { drain: false });

// The Opus resource can close without Discord emitting player idle. This

// close path releases queued exact speech, so clear the old watchdog before

// the next response owns exact-speech state.

this.completeExactSpeechResponse(reason);

}

private queueOutputAudio(stream: PassThrough, discordPcm: Buffer): void {