@xopcai/xopc 0.0.264 → 0.0.265

package/dist/src/voice/realtime/agentBroker.js

@@ -0,0 +1,116 @@
+//#region src/voice/realtime/agentBroker.ts
+const RUN_ASSIGNMENT_TIMEOUT_MS = 5e3;
+const RUN_ASSIGNMENT_POLL_MS = 20;
+const MAX_TRACKED_TASKS = 256;
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		const finish = () => {
+			signal.removeEventListener("abort", abort);
+			resolve();
+		};
+		const timer = setTimeout(finish, ms);
+		const abort = () => {
+			clearTimeout(timer);
+			reject(signal.reason ?? /* @__PURE__ */ new Error("Voice task subscription cancelled"));
+		};
+		signal.addEventListener("abort", abort, { once: true });
+		if (signal.aborted) abort();
+	});
+}
+function eventData(delivery) {
+	if (delivery.kind !== "realtime.event") return void 0;
+	const value = delivery.payload.data;
+	return value && typeof value === "object" && typeof value.type === "string" ? value : void 0;
+}
+/** Durable voice-to-Agent boundary. Playback and socket cancellation only detach event delivery. */
+var DurableVoiceAgentBroker = class {
+	runByTask = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async delegate(input) {
+		const clientMessageId = `voice:${input.expectedSessionId}:${input.turnId}`;
+		const activeRunId = this.deps.snapshot(input.sessionKey).activeRunId;
+		const activeRunCursor = activeRunId ? this.deps.currentSequence(`run:${activeRunId}`) : 0;
+		const result = await this.deps.submit({
+			sessionKey: input.sessionKey,
+			expectedSessionId: input.expectedSessionId,
+			clientMessageId,
+			delivery: activeRunId ? "steer" : "next",
+			content: input.text,
+			origin: {
+				type: "channel",
+				channel: "voice"
+			}
+		});
+		if (result.ok === false) throw new Error(`Voice task submission failed: ${result.code}`);
+		const deadline = Date.now() + RUN_ASSIGNMENT_TIMEOUT_MS;
+		let row = this.deps.find(input.sessionKey, clientMessageId);
+		while (!row?.runId && !row?.targetRunId) {
+			if (row && [
+				"completed",
+				"cancelled",
+				"failed",
+				"interrupted"
+			].includes(row.status)) throw new Error(row.error ?? `Voice task ended before assignment: ${row.status}`);
+			if (Date.now() >= deadline) throw new Error("Voice task run assignment timed out");
+			await sleep(RUN_ASSIGNMENT_POLL_MS, input.signal);
+			row = this.deps.find(input.sessionKey, clientMessageId);
+		}
+		const runId = row.runId ?? row.targetRunId;
+		this.runByTask.set(row.id, runId);
+		if (this.runByTask.size > MAX_TRACKED_TASKS) this.runByTask.delete(this.runByTask.keys().next().value);
+		const afterSeq = result.effectiveDelivery === "steer" && runId === activeRunId ? activeRunCursor : 0;
+		return {
+			taskId: row.id,
+			runId,
+			events: this.events(row.id, runId, afterSeq, input.signal)
+		};
+	}
+	async cancel(taskId) {
+		const runId = this.runByTask.get(taskId);
+		if (!runId) return false;
+		await this.deps.cancelRun(runId);
+		this.runByTask.delete(taskId);
+		return true;
+	}
+	async *events(taskId, runId, afterSeq, signal) {
+		const queued = [];
+		let wake;
+		const push = (event) => {
+			queued.push(event);
+			wake?.();
+			wake = void 0;
+		};
+		const subscription = this.deps.subscribe(`run:${runId}`, afterSeq, push);
+		subscription.initial.forEach(push);
+		const abort = () => {
+			wake?.();
+			wake = void 0;
+		};
+		signal.addEventListener("abort", abort, { once: true });
+		try {
+			while (!signal.aborted) {
+				if (!queued.length) await new Promise((resolve) => {
+					wake = resolve;
+				});
+				if (signal.aborted) return;
+				const delivery = queued.shift();
+				if (!delivery) continue;
+				if (delivery.kind === "realtime.gap") throw new Error("Voice task event history is unavailable");
+				const event = eventData(delivery);
+				if (!event) continue;
+				yield event;
+				if (event.type === "stream_end") {
+					this.runByTask.delete(taskId);
+					return;
+				}
+			}
+		} finally {
+			signal.removeEventListener("abort", abort);
+			subscription.unsubscribe();
+		}
+	}
+};
+//#endregion
+export { DurableVoiceAgentBroker };

package/dist/src/voice/realtime/agentEngine.js

@@ -2,8 +2,9 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { speakStream } from "../tts/speak-core.js";
 import { AudioPlaybackWindow } from "./audio-playback-window.js";
-import { ConversationTurn } from "./conversationTurn.js";
+import { TurnCoordinator } from "./turnPolicy.js";
 import { isLikelyPlaybackEcho } from "./playback-echo.js";
+import { PcmFrameBuffer } from "./pcmFrameBuffer.js";
 import { SpeakableSegmenter } from "./speakable-segmenter.js";
 import crypto from "node:crypto";
 //#region src/voice/realtime/agentEngine.ts
@@ -34,8 +35,24 @@ function createAgentVoiceEngine(options) {
 	let committing = false;
 	const finalizedUtterances = /* @__PURE__ */ new Set();
 	let pendingTurn;
-	const turn = new ConversationTurn(claim.silenceDurationMs, (text) => {
+	const turn = new TurnCoordinator(claim.silenceDurationMs, (text, decision, turnId) => {
 		if (closed || muted) return;
+		log.info({
+			sessionId: claim.sessionId,
+			turnId,
+			disposition: decision.disposition,
+			confidence: decision.confidence,
+			source: decision.source,
+			transcriptCharacters: text.length
+		}, "Realtime voice turn committed");
+		send("turn.decision", {
+			turnId,
+			disposition: decision.disposition,
+			confidence: decision.confidence,
+			source: decision.source,
+			committed: true
+		});
+		send("turn.committed", { turnId });
 		if (queuedTurns >= 8) {
 			send("session.error", {
 				code: "INPUT_BACKPRESSURE",
@@ -48,13 +65,14 @@ function createAgentVoiceEngine(options) {
 		queuedTurns += 1;
 		const generation = inputGeneration;
 		const pending = {
+			turnId,
 			text,
 			cancelled: false
 		};
 		pendingTurn = pending;
 		conversationTail = conversationTail.then(() => {
 			if (pendingTurn === pending) pendingTurn = void 0;
-			if (generation === inputGeneration && !pending.cancelled) return runConversationTurn(text);
+			if (generation === inputGeneration && !pending.cancelled) return runAssistantTurn(text, turnId);
 		}).finally(() => {
 			if (generation === inputGeneration) queuedTurns -= 1;
 		});
@@ -129,11 +147,10 @@ function createAgentVoiceEngine(options) {
 						}
 					});
 				}
-				for (let offset = 0; offset < item.value.byteLength; offset += 24e3) {
-					const chunk = item.value.subarray(offset, offset + 24e3);
-					await response.playback.reserve(chunk.byteLength, response.abortController.signal);
+				for (const frame of response.pcm.push(item.value)) {
+					await response.playback.reserve(frame.byteLength, response.abortController.signal);
 					if (activeResponse !== response || closed) return;
-					options.sendAudio(response.id, chunk);
+					options.sendAudio(response.id, frame);
 				}
 			}
 		} finally {
@@ -204,7 +221,7 @@ function createAgentVoiceEngine(options) {
 		if (response.speechWorker) prefetchNextSpeech(response);
 		else startSpeechWorker(response);
 	}
-	async function runConversationTurn(text) {
+	async function runAssistantTurn(text, turnId) {
 		if (!claim.tts || !claim.request.sessionKey || !text.trim() || closed) return;
 		cancelActiveResponse("barge_in");
 		const response = {
@@ -219,14 +236,28 @@ function createAgentVoiceEngine(options) {
 			queuedSpeechCharacters: 0,
 			startedAt: Date.now(),
 			firstTextSeen: false,
-			awaitingClarification: false
+			awaitingClarification: false,
+			pcm: new PcmFrameBuffer()
 		};
 		activeResponse = response;
 		send("response.created", { responseId: response.id });
 		try {
 			await interruptionWrites;
 			if (response.abortController.signal.aborted || closed) return;
-			for await (const event of options.runtime.runAgent(text, claim.request.sessionKey, response.abortController.signal)) {
+			if (!claim.conversationSessionId) throw new Error("Conversation identity is unavailable");
+			const task = await options.runtime.agentBroker.delegate({
+				text,
+				turnId,
+				sessionKey: claim.request.sessionKey,
+				expectedSessionId: claim.conversationSessionId,
+				signal: response.abortController.signal
+			});
+			response.taskId = task.taskId;
+			send("task.created", {
+				responseId: response.id,
+				taskId: task.taskId
+			});
+			for await (const event of task.events) {
 				if (activeResponse !== response || response.abortController.signal.aborted) return;
 				if (event.type === "assistant_delta" || event.type === "tool_end" && event.payload?.toolName !== "clarify") response.awaitingClarification = false;
 				if (event.type === "assistant_delta" && typeof event.payload?.delta === "string") {
@@ -247,12 +278,19 @@ function createAgentVoiceEngine(options) {
 					queuePhrases(response, response.segmenter.push(event.payload.delta));
 				}
 				if (event.type === "tool_start") queuePhrases(response, response.segmenter.flush());
-				if ((event.type === "tool_start" || event.type === "tool_end") && typeof event.payload?.toolCallId === "string" && typeof event.payload?.toolName === "string") send("response.activity", {
-					responseId: response.id,
+				if ((event.type === "tool_start" || event.type === "tool_end") && typeof event.payload?.toolCallId === "string" && typeof event.payload?.toolName === "string") send("task.activity", {
+					taskId: task.taskId,
 					toolCallId: event.payload.toolCallId.slice(0, 160),
 					toolName: event.payload.toolName.slice(0, 256),
 					status: event.type === "tool_start" ? "running" : event.payload.status === "error" ? "failed" : "completed"
 				});
+				if (event.type === "stream_end") {
+					const status = event.payload?.status;
+					send("task.done", {
+						taskId: task.taskId,
+						status: status === "cancelled" ? "cancelled" : status === "suspended" ? "suspended" : status === "error" ? "failed" : "completed"
+					});
+				}
 				if (event.type === "clarify_request" && typeof event.payload?.requestId === "string" && typeof event.payload?.question === "string") {
 					response.awaitingClarification = true;
 					send("response.clarification", {
@@ -274,6 +312,12 @@ function createAgentVoiceEngine(options) {
 			send("response.text.done", { responseId: response.id });
 			await waitForSpeech(response);
 			if (response.speechError) throw response.speechError;
+			const finalFrame = response.pcm.finish();
+			if (finalFrame) {
+				await response.playback.reserve(finalFrame.byteLength, response.abortController.signal);
+				if (activeResponse !== response || closed) return;
+				options.sendAudio(response.id, finalFrame);
+			}
 			await response.playback.drain(response.abortController.signal);
 			if (activeResponse !== response || response.abortController.signal.aborted) return;
 			if (response.audioStarted) send("response.audio.done", { responseId: response.id });
@@ -367,7 +411,7 @@ function createAgentVoiceEngine(options) {
 			if (claim.request.purpose === "conversation") {
 				if (pendingTurn) {
 					pendingTurn.cancelled = true;
-					turn.restore(pendingTurn.text);
+					turn.restore(pendingTurn.turnId, pendingTurn.text);
 					pendingTurn = void 0;
 				}
 				turn.start(event.utteranceId);
@@ -500,8 +544,11 @@ function createAgentVoiceEngine(options) {
 			});
 			return cancelActiveResponse(reason);
 		},
-		acknowledge(responseId, playedBytes) {
-			if (activeResponse?.id === responseId) activeResponse.playback.acknowledge(playedBytes);
+		cancelTask(taskId) {
+			return options.runtime.agentBroker.cancel(taskId);
+		},
+		acknowledge(responseId, playedDurationMs) {
+			if (activeResponse?.id === responseId) activeResponse.playback.acknowledge(playedDurationMs * 48);
 		},
 		close() {
 			if (closing) return closing;

package/dist/src/voice/realtime/engine.d.ts

@@ -8,6 +8,7 @@ export interface VoiceEngine {
     setInputMuted(muted: boolean): void | Promise<void>;
     commit(): Promise<void>;
     cancel(responseId: string, reason: 'client_cancelled' | 'barge_in'): boolean;
-    acknowledge(responseId: string, playedBytes: number): void;
+    cancelTask(taskId: string): Promise<boolean>;
+    acknowledge(responseId: string, playedDurationMs: number): void;
     close(): void | Promise<void>;
 }

package/dist/src/voice/realtime/omniEngine.js

@@ -1,7 +1,8 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { AudioPlaybackWindow } from "./audio-playback-window.js";
-import { ConversationTurn } from "./conversationTurn.js";
+import { TurnCoordinator } from "./turnPolicy.js";
+import { PcmFrameBuffer } from "./pcmFrameBuffer.js";
 import crypto from "node:crypto";
 import WebSocket from "ws";
 //#region src/voice/realtime/omniEngine.ts
@@ -50,8 +51,16 @@ function createOmniVoiceEngine(options) {
 	let uploadTimer;
 	let turnSettled = false;
 	const speaking = /* @__PURE__ */ new Set();
-	const turn = new ConversationTurn(options.silenceDurationMs, () => {
+	const turn = new TurnCoordinator(options.silenceDurationMs, (_text, decision, turnId) => {
 		if (closed || failed || muted || inputBlocked) return;
+		options.send("turn.decision", {
+			turnId,
+			disposition: decision.disposition,
+			confidence: decision.confidence,
+			source: decision.source,
+			committed: true
+		});
+		options.send("turn.committed", { turnId });
 		turnSettled = true;
 		if (active) publish(active);
 	});
@@ -146,6 +155,23 @@ function createOmniVoiceEngine(options) {
 		options.send("response.text.done", { responseId: response.id });
 		await response.tail;
 		if (active !== response || closed) return;
+		const finalFrame = response.pcm.finish();
+		if (finalFrame) {
+			await response.playback.reserve(finalFrame.byteLength, response.abort.signal);
+			if (active !== response || closed) return;
+			if (!response.audio) {
+				response.audio = true;
+				options.send("response.audio.started", {
+					responseId: response.id,
+					format: {
+						encoding: "pcm_s16le",
+						channels: 1,
+						sampleRate: 24e3
+					}
+				});
+			}
+			options.sendAudio(response.id, finalFrame);
+		}
 		await response.playback.drain(response.abort.signal);
 		if (active !== response || closed) return;
 		save({
@@ -361,7 +387,8 @@ function createOmniVoiceEngine(options) {
 								tail: Promise.resolve(),
 								published: false,
 								settled,
-								release
+								release,
+								pcm: new PcmFrameBuffer()
 							};
 							if (turnSettled) publish(active);
 						} else if (active && event.response_id === active.id && event.type === "response.audio_transcript.delta") {
@@ -392,9 +419,8 @@ function createOmniVoiceEngine(options) {
 							response.queuedBytes += audio.length;
 							response.tail = response.tail.then(async () => {
 								await response.settled;
-								for (let offset = 0; offset < audio.length; offset += 24e3) {
+								for (const chunk of response.pcm.push(audio)) {
 									if (closed || active !== response) return;
-									const chunk = audio.subarray(offset, offset + 24e3);
 									await response.playback.reserve(chunk.length, response.abort.signal);
 									if (closed || active !== response) return;
 									if (!response.audio) {
@@ -471,8 +497,11 @@ function createOmniVoiceEngine(options) {
 			if (reason === "client_cancelled") discardInput();
 			return cancel(reason);
 		},
-		acknowledge(responseId, playedBytes) {
-			if (active?.id === responseId) active.playback.acknowledge(playedBytes);
+		async cancelTask() {
+			return false;
+		},
+		acknowledge(responseId, playedDurationMs) {
+			if (active?.id === responseId) active.playback.acknowledge(playedDurationMs * 48);
 		},
 		close() {
 			if (closed) return writes;

package/dist/src/voice/realtime/pcmFrameBuffer.d.ts

@@ -0,0 +1,6 @@
+/** Converts arbitrary PCM16 chunks into exact 20 ms wire frames. */
+export declare class PcmFrameBuffer {
+    private remainder;
+    push(bytes: Uint8Array): Uint8Array[];
+    finish(): Uint8Array | undefined;
+}

package/dist/src/voice/realtime/pcmFrameBuffer.js

@@ -0,0 +1,29 @@
+//#region src/voice/realtime/pcmFrameBuffer.ts
+const PCM_24KHZ_20MS_BYTES = 960;
+/** Converts arbitrary PCM16 chunks into exact 20 ms wire frames. */
+var PcmFrameBuffer = class {
+	remainder = new Uint8Array();
+	push(bytes) {
+		if (!bytes.byteLength || bytes.byteLength % 2) throw new Error("PCM16 audio must contain complete samples");
+		const pending = new Uint8Array(this.remainder.byteLength + bytes.byteLength);
+		pending.set(this.remainder);
+		pending.set(bytes, this.remainder.byteLength);
+		const frames = [];
+		let offset = 0;
+		while (offset + PCM_24KHZ_20MS_BYTES <= pending.byteLength) {
+			frames.push(pending.slice(offset, offset + PCM_24KHZ_20MS_BYTES));
+			offset += PCM_24KHZ_20MS_BYTES;
+		}
+		this.remainder = pending.slice(offset);
+		return frames;
+	}
+	finish() {
+		if (!this.remainder.byteLength) return void 0;
+		const frame = new Uint8Array(PCM_24KHZ_20MS_BYTES);
+		frame.set(this.remainder);
+		this.remainder = new Uint8Array();
+		return frame;
+	}
+};
+//#endregion
+export { PcmFrameBuffer };

package/dist/src/voice/realtime/runtime.js

@@ -10,7 +10,7 @@ import { resolveSTTProviderChain } from "../stt/factory.js";
 import { mergeSttConfigFromAppConfig } from "../stt/config.js";
 import { voiceConversationInstructions } from "./conversation-context.js";
 import { createPreauthConnectionBudget } from "../../gateway/security/preauth-connection-budget.js";
-import { encodeVoiceAudioFrame } from "../../../packages/realtime-protocol/src/voice-audio.js";
+import { decodeVoiceUplinkAudioFrame, encodeVoiceAudioFrame } from "../../../packages/realtime-protocol/src/voice-audio.js";
 import { VOICE_REALTIME_HEARTBEAT_INTERVAL_MS, VOICE_REALTIME_MAX_BINARY_FRAME_BYTES, VOICE_REALTIME_START_TIMEOUT_MS, VOICE_REALTIME_WS_PATH, parseVoiceClientJsonFrame, parseVoiceClientMessage } from "../../../packages/realtime-protocol/src/voice.js";
 import { createAgentVoiceEngine } from "./agentEngine.js";
 import { resolveOmniRoute } from "./omniRoute.js";
@@ -157,27 +157,28 @@ var VoiceRealtimeRuntime = class {
 		const config = structuredClone(this.options.getConfig());
 		this.pruneTickets(now);
 		if (!config.voice?.realtime?.enabled) throw new VoiceSessionCreationError("VOICE_DISABLED", "Realtime voice is disabled", 503);
+		const defaultMode = config.voice.realtime.defaultEngine === "omni" ? "natural" : "assistant";
 		request = request.purpose === "conversation" ? {
 			...request,
-			engine: request.engine ?? config.voice.realtime.defaultEngine
+			mode: request.mode ?? defaultMode
 		} : request;
 		let omni;
-		if (request.engine === "omni") try {
+		if (request.mode === "natural") try {
 			omni = await resolveOmniRoute(config);
 		} catch {
 			throw new VoiceSessionCreationError("PROVIDER_UNAVAILABLE", "Natural conversation is unavailable. Check its model, endpoint and credentials.", 503);
 		}
 		if (omni && (!this.options.recordOmniTranscript || !this.options.getConversationContext)) throw new VoiceSessionCreationError("PROVIDER_UNAVAILABLE", "Natural conversation storage is unavailable", 503);
 		const conversationSessionId = request.purpose === "conversation" && request.sessionKey ? await this.options.getSessionIdentity?.(request.sessionKey) : void 0;
-		if (omni && !conversationSessionId) throw new VoiceSessionCreationError("SESSION_NOT_FOUND", "Conversation session was not found", 404);
+		if (request.purpose === "conversation" && !conversationSessionId) throw new VoiceSessionCreationError("SESSION_NOT_FOUND", "Conversation session was not found", 404);
 		const stt = omni ? void 0 : resolveStreamingStt(config, request.language);
 		if (!omni && !stt) throw new VoiceSessionCreationError("PROVIDER_UNAVAILABLE", "No configured streaming speech-to-text provider is available", 503);
 		const inputMode = "server_vad";
 		if (stt && !stt.plugin.streamingAudio.turnDetection.includes(inputMode)) throw new VoiceSessionCreationError("PROVIDER_UNAVAILABLE", `Streaming speech-to-text provider does not support ${inputMode}`, 503);
-		const tts = request.engine === "agent" ? resolveStreamingTts(config) : void 0;
+		const tts = request.mode === "assistant" ? resolveStreamingTts(config) : void 0;
 		if (request.purpose === "conversation") {
 			if (!request.sessionKey || !await this.options.sessionExists(request.sessionKey)) throw new VoiceSessionCreationError("SESSION_NOT_FOUND", "Conversation session was not found", 404);
-			if (this.options.sessionBusy(request.sessionKey)) throw new VoiceSessionCreationError("SESSION_CONFLICT", "Conversation session already has an active response", 409);
+			if (request.mode === "natural" && this.options.sessionBusy(request.sessionKey)) throw new VoiceSessionCreationError("SESSION_CONFLICT", "Conversation session already has an active response", 409);
 			if (this.conversationReservations.has(request.sessionKey)) throw new VoiceSessionCreationError("SESSION_CONFLICT", "Conversation session already has a voice connection", 409);
 			if (!omni && !tts) throw new VoiceSessionCreationError("PROVIDER_UNAVAILABLE", "No configured PCM streaming text-to-speech provider is available", 503);
 		}
@@ -200,11 +201,14 @@ var VoiceRealtimeRuntime = class {
 		request = resolvedRequest;
 		const sessionId = crypto.randomUUID();
 		const ticket = crypto.randomBytes(32).toString("base64url");
+		const connectionEpoch = crypto.randomInt(1, 4294967296);
 		const maxSessionMs = request.purpose === "conversation" ? Math.min(config.voice.realtime.maxConversationMs, omni?.route.managed ? 30 * 6e4 : Number.MAX_SAFE_INTEGER) : config.voice.realtime.maxDictationMs;
 		const claim = {
 			conversationSessionId,
 			sessionId,
+			connectionEpoch,
 			principalId,
+			...request.purpose === "conversation" && request.mode ? { mode: request.mode } : {},
 			request,
 			inputMode,
 			idleTimeoutMs: config.voice.realtime.idleTimeoutMs,
@@ -224,8 +228,10 @@ var VoiceRealtimeRuntime = class {
 			ticket,
 			ticketExpiresAt: new Date(claim.expiresAt).toISOString(),
 			websocketPath: VOICE_REALTIME_WS_PATH,
-			protocolVersion: 2,
+			protocolVersion: 3,
+			connectionEpoch,
 			purpose: request.purpose,
+			...request.purpose === "conversation" && request.mode ? { mode: request.mode } : {},
 			inputMode,
 			bargeIn: config.voice.realtime.bargeIn,
 			inputFormat: {
@@ -233,6 +239,11 @@ var VoiceRealtimeRuntime = class {
 				sampleRate: 16e3,
 				channels: 1
 			},
+			media: {
+				transport: "websocket-pcm",
+				codec: "pcm_s16le",
+				frameDurationMs: 20
+			},
 			limits: {
 				maxBinaryFrameBytes: VOICE_REALTIME_MAX_BINARY_FRAME_BYTES,
 				maxSessionMs,
@@ -252,7 +263,7 @@ var VoiceRealtimeRuntime = class {
 		};
 	}
 	handleUpgrade(req, socket, head) {
-		if (new URL(req.url ?? "/", "http://gateway.local").pathname !== "/api/voice/realtime/v2/ws") return false;
+		if (new URL(req.url ?? "/", "http://gateway.local").pathname !== "/api/voice/realtime/v3/ws") return false;
 		if (this.closed || this.wss.clients.size >= MAX_CONNECTIONS) {
 			socket.destroy();
 			return true;
@@ -319,6 +330,8 @@ var VoiceRealtimeRuntime = class {
 		let ready = false;
 		let seq = 0;
 		let audioSeq = 0;
+		let outputMediaTimestampMs = 0;
+		const inputSequences = /* @__PURE__ */ new Map();
 		let closed = false;
 		let lastActivityAt = Date.now();
 		const abortController = new AbortController();
@@ -326,10 +339,11 @@ var VoiceRealtimeRuntime = class {
 		let context;
 		let unsubscribeMemory;
 		let unsubscribeSession;
+		let inputMutationTail = Promise.resolve();
 		const send = (type, payload) => {
 			if (!claim || socket.readyState !== WebSocketState.OPEN) return;
 			const event = {
-				protocolVersion: 2,
+				protocolVersion: 3,
 				eventId: crypto.randomUUID(),
 				seq: ++seq,
 				type,
@@ -434,11 +448,20 @@ var VoiceRealtimeRuntime = class {
 				setupStage = "engine";
 				const sendAudio = (responseId, bytes) => {
 					if (socket.bufferedAmount > 1024 * 1024) throw new Error("Voice client audio backpressure limit exceeded");
-					if (!closed && socket.readyState === WebSocketState.OPEN) socket.send(encodeVoiceAudioFrame({
-						responseId,
-						seq: ++audioSeq,
-						audio: bytes
-					}), { binary: true });
+					if (closed || socket.readyState !== WebSocketState.OPEN) return;
+					for (let offset = 0; offset < bytes.byteLength; offset += 960) {
+						const audio = bytes.subarray(offset, offset + 960);
+						if (audio.byteLength !== 960) throw new Error("Realtime output must align to 20 ms PCM frames");
+						socket.send(encodeVoiceAudioFrame({
+							connectionEpoch: consumed.connectionEpoch,
+							responseId,
+							seq: ++audioSeq,
+							mediaTimestampMs: outputMediaTimestampMs,
+							durationMs: 20,
+							audio
+						}), { binary: true });
+						outputMediaTimestampMs += 20;
+					}
 				};
 				engine = consumed.omni ? createOmniVoiceEngine({
 					callId: consumed.sessionId,
@@ -469,12 +492,19 @@ var VoiceRealtimeRuntime = class {
 				}, "Realtime voice session ready");
 				send("session.ready", {
 					purpose: consumed.request.purpose,
+					...consumed.mode ? { mode: consumed.mode } : {},
+					connectionEpoch: consumed.connectionEpoch,
 					inputMode: consumed.inputMode,
 					inputFormat: {
 						encoding: "pcm_s16le",
 						sampleRate: 16e3,
 						channels: 1
 					},
+					media: {
+						transport: "websocket-pcm",
+						codec: "pcm_s16le",
+						frameDurationMs: 20
+					},
 					route: consumed.omni ? {
 						engine: "omni",
 						omni: consumed.omni.route
@@ -512,7 +542,19 @@ var VoiceRealtimeRuntime = class {
 					return;
 				}
 				const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : Array.isArray(data) ? Buffer.concat(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-				if (bytes.byteLength === 0 || bytes.byteLength % 2 !== 0 || bytes.byteLength > 65536) {
+				let frame;
+				try {
+					frame = decodeVoiceUplinkAudioFrame(bytes);
+				} catch {
+					send("session.error", {
+						code: "INVALID_AUDIO",
+						message: "Invalid PCM audio frame",
+						recoverable: false
+					});
+					shutdown("invalid_audio", true);
+					return;
+				}
+				if (frame.connectionEpoch !== claim.connectionEpoch || frame.audio.byteLength !== 640) {
 					send("session.error", {
 						code: "INVALID_AUDIO",
 						message: "Invalid PCM audio frame",
@@ -521,12 +563,24 @@ var VoiceRealtimeRuntime = class {
 					shutdown("invalid_audio", true);
 					return;
 				}
+				const previous = inputSequences.get(frame.utteranceId) ?? 0;
+				if (frame.audioSeq <= previous) return;
+				if (frame.audioSeq !== previous + 1 || inputSequences.size >= 256) {
+					send("session.error", {
+						code: "INVALID_AUDIO",
+						message: "Invalid audio sequence",
+						recoverable: false
+					});
+					shutdown("invalid_audio", true);
+					return;
+				}
+				inputSequences.set(frame.utteranceId, frame.audioSeq);
 				if (!ready || !engine) {
 					socket.close(4401, "Voice session is not ready");
 					return;
 				}
 				try {
-					engine.appendAudio(bytes);
+					engine.appendAudio(frame.audio);
 				} catch (error) {
 					log.warn({
 						err: error,
@@ -574,23 +628,45 @@ var VoiceRealtimeRuntime = class {
 						metric,
 						durationMs,
 						source: "client",
-						engine: claim.request.engine
+						mode: claim.mode
 					}, "Voice client timing sample");
 				}
-			} else if (message.type === "response.cancel") {
+			} else if (message.type === "response.stop_playback") {
 				if (!engine?.cancel(message.payload.responseId, "client_cancelled")) send("session.error", {
 					code: "NO_ACTIVE_RESPONSE",
 					message: "No matching response is active",
 					recoverable: true
 				});
-			} else if (message.type === "response.audio.played") try {
-				engine?.acknowledge(message.payload.responseId, message.payload.playedBytes);
+			} else if (message.type === "task.cancel") engine?.cancelTask(message.payload.taskId).then((cancelled) => {
+				if (!cancelled) send("session.error", {
+					code: "NO_ACTIVE_TASK",
+					message: "No matching task is active",
+					recoverable: true
+				});
+			}).catch((error) => {
+				log.warn({
+					err: error,
+					sessionId: claim?.sessionId,
+					taskId: message.payload.taskId
+				}, "Voice task cancellation failed");
+				send("session.error", {
+					code: "TASK_CANCEL_FAILED",
+					message: "Could not cancel the task",
+					recoverable: true
+				});
+			});
+			else if (message.type === "response.audio.played") try {
+				engine?.acknowledge(message.payload.responseId, message.payload.playedDurationMs);
 			} catch {
 				socket.close(4400, "Invalid playback acknowledgement");
 			}
 			else if (message.type === "input.mute") {
 				if (!ready || !engine || claim.request.purpose !== "conversation") return;
-				Promise.resolve().then(() => engine.setInputMuted(message.payload.muted)).catch((error) => {
+				const muted = message.payload.muted;
+				inputMutationTail = inputMutationTail.then(async () => {
+					if (closed || !ready || !engine) return;
+					await engine.setInputMuted(muted);
+				}).catch((error) => {
 					log.warn({
 						err: error,
 						sessionId: claim?.sessionId