### Fixes

- OpenAI/realtime voice: honor disabled input-audio interruption locally so server VAD speech-start events do not clear Discord playback after operators set `interruptResponseOnInputAudio: false`.

- Telegram: handle managed select button callbacks before the raw callback fallback while preserving delimiter-containing option values such as `env|prod`. (#79816) Thanks @moeedahmed.

- CLI/media: let explicit image description model refs use bundled static provider catalogs and generic model-backed image hooks, so `openclaw infer image describe --model zai/glm-4.6v` works like direct model runs and Anthropic auth probes avoid stale Claude 3 Haiku catalog entries.

- Browser: wait longer for existing-session Chrome MCP status and non-deep doctor probes so slow first attaches do not falsely report offline while keeping raw CDP status probes short. (#77473) Thanks @rubencu.

- On realtime interruption: `discord voice: realtime model interrupt requested client:response.cancel reason=barge-in`, followed by either `discord voice: realtime model audio truncated client:conversation.item.truncate reason=barge-in audioEndMs=...` or `discord voice: realtime model interrupt confirmed server:response.done status=cancelled ...`

- On ignored echo/noise: `discord voice: realtime model interrupt ignored client:conversation.item.truncate.skipped reason=barge-in audioEndMs=0 minAudioEndMs=250`

- On disabled barge-in: `discord voice: realtime capture ignored during playback (barge-in disabled) ...`

- On idle playback: `discord voice: realtime barge-in ignored reason=... outputActive=false ... playbackChunks=0`

To debug cut-off audio, read the realtime voice logs as a timeline:

- `source=speaker-start` followed by `speaker turn closed ... hasAudio=false` means Discord reported a speaker start but no audio reached OpenClaw. That can be a transient Discord voice event, noise gate behavior, or a client briefly keying the mic.

- `audio playback stopped reason=stream-close` without a nearby barge-in or `provider-clear-audio` means the local Discord playback stream ended unexpectedly. Check the preceding provider and Discord player logs.

- `capture ignored during playback (barge-in disabled)` means OpenClaw intentionally dropped input while assistant audio was active. Enable `voice.realtime.bargeIn` if you want speech to interrupt playback.

- `barge-in ignored ... outputActive=false` means Discord or provider VAD reported speech, but OpenClaw had no active playback to interrupt. This should not cut off audio.

Credentials are resolved per component: LLM route auth for `voice.model`, STT auth for `tools.media.audio`, TTS auth for `messages.tts`/`voice.tts`, and realtime provider auth for `voice.realtime.providers` or the provider's normal auth config.

const player = getLastAudioPlayer();

const entry = getSessionEntry(manager);

const bridgeParams = createRealtimeVoiceBridgeSessionMock.mock.calls.at(-1)?.[0] as

| {

audioSink?: {

sendAudio: (audio: Buffer) => void;

};

}

| undefined;

player.state.status = "playing";

bridgeParams?.audioSink?.sendAudio(Buffer.alloc(480));

await (

manager as unknown as {

expect(realtimeSessionMock.sendAudio).toHaveBeenCalled();

});

it("interrupts provider response state even after local realtime playback has ended", async () => {

it("does not interrupt realtime provider state when local playback is already idle", async () => {

const manager = createManager({

groupPolicy: "open",

allowFrom: ["discord:u1"],

turn?.sendInputAudio(Buffer.alloc(3840));

expect(realtimeSessionMock.handleBargeIn).toHaveBeenCalled();

expect(realtimeSessionMock.handleBargeIn).not.toHaveBeenCalled();

expect(player.stop).not.toHaveBeenCalled();

expect(realtimeSessionMock.sendAudio).toHaveBeenCalled();

});

`discord voice: realtime input audio started guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} user=${turn.context.userId} speaker=${turn.context.speakerLabel} discordBytes=${discordPcm48kStereo.length} realtimeBytes=${realtimePcm.length} outputAudioMs=${Math.floor(this.outputAudioTimestampMs)} outputActive=${this.isOutputAudioActive()}`,

);

}

if (!turn.interruptedPlayback && this.isBargeInEnabled()) {

const outputActive = this.hasInterruptibleOutputAudio();

if (!turn.interruptedPlayback && this.isBargeInEnabled() && outputActive) {

turn.interruptedPlayback = true;

logVoiceVerbose(

`realtime barge-in from active speaker audio: guild ${this.params.entry.guildId} channel ${this.params.entry.channelId} user ${turn.context.userId}`,

);

return;

}

this.syncOutputAudioTimestamp();

const outputActive = this.hasInterruptibleOutputAudio();

if (!outputActive) {

logger.info(

`discord voice: realtime barge-in ignored reason=${reason} outputActive=false guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} playbackChunks=${this.outputAudioChunks}`,

);

return;

}

logger.info(

`discord voice: realtime barge-in requested reason=${reason} guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} outputAudioMs=${Math.floor(this.outputAudioTimestampMs)} outputActive=${this.isOutputAudioActive()} playbackChunks=${this.outputAudioChunks}`,

);

});

}

private hasInterruptibleOutputAudio(): boolean {

this.syncOutputAudioTimestamp();

return (

this.isOutputAudioActive() || this.outputAudioChunks > 0 || this.outputAudioTimestampMs > 0

);

}

private get realtimeConfig(): DiscordRealtimeVoiceConfig {

return this.params.discordConfig.voice?.realtime;

}

});

});

it("does not locally clear playback on speech-start events when input interruption is disabled", async () => {

const provider = buildOpenAIRealtimeVoiceProvider();

const onAudio = vi.fn();

const onClearAudio = vi.fn();

const bridge = provider.createBridge({

providerConfig: { apiKey: "sk-test" }, // pragma: allowlist secret

autoRespondToAudio: true,

interruptResponseOnInputAudio: false,

onAudio,

onClearAudio,

});

const connecting = bridge.connect();

const socket = FakeWebSocket.instances[0];

if (!socket) {

throw new Error("expected bridge to create a websocket");

}

socket.readyState = FakeWebSocket.OPEN;

socket.emit("open");

socket.emit("message", Buffer.from(JSON.stringify({ type: "session.updated" })));

await connecting;

socket.emit(

"message",

Buffer.from(JSON.stringify({ type: "response.created", response: { id: "resp_1" } })),

);

socket.emit(

"message",

Buffer.from(

JSON.stringify({

type: "response.audio.delta",

item_id: "item_1",

delta: Buffer.from("assistant audio").toString("base64"),

}),

),

);

socket.emit(

"message",

Buffer.from(JSON.stringify({ type: "input_audio_buffer.speech_started" })),

);

expect(onAudio).toHaveBeenCalledTimes(1);

expect(onClearAudio).not.toHaveBeenCalled();

expect(parseSent(socket)).not.toContainEqual({ type: "response.cancel" });

expect(parseSent(socket)).not.toContainEqual(

expect.objectContaining({ type: "conversation.item.truncate" }),

);

});

it("keeps assistant playback active on server VAD when automatic audio responses are disabled", async () => {

const provider = buildOpenAIRealtimeVoiceProvider();

const onAudio = vi.fn();

}

case "input_audio_buffer.speech_started":

if (this.config.autoRespondToAudio ?? true) {

if (this.config.interruptResponseOnInputAudio ?? this.config.autoRespondToAudio ?? true) {

this.handleBargeIn();

}

return;