realtime-voice-agents 2.0.0

package/dist/rest-BYqiVOhe.mjs

@@ -0,0 +1,265 @@
+import { t as TypedEmitter } from "./events-BylBSBW-.mjs";
+//#region src/twilio/messages.ts
+const INBOUND_EVENTS = /* @__PURE__ */ new Set([
+	"connected",
+	"start",
+	"media",
+	"stop",
+	"mark",
+	"dtmf"
+]);
+/**
+* Parse a raw WebSocket frame into a Twilio inbound message.
+* Returns null for non-JSON frames or unknown event types (Twilio may add
+* events; unknown ones must not crash a live call).
+*/
+function parseTwilioMessage(raw) {
+	let parsed;
+	try {
+		parsed = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf8"));
+	} catch {
+		return null;
+	}
+	if (typeof parsed !== "object" || parsed === null) return null;
+	const event = parsed.event;
+	if (typeof event !== "string" || !INBOUND_EVENTS.has(event)) return null;
+	return parsed;
+}
+//#endregion
+//#region src/twilio/transport.ts
+/**
+* TwilioMediaTransport — framing layer over one Twilio Media Stream WebSocket.
+*
+* Wraps any ws-shaped socket (`ws`, @fastify/websocket, express-ws all hand
+* you one), parses inbound frames into typed events, and provides outbound
+* send helpers that carry the streamSid captured from `start`.
+*
+* The handshake (`awaitStart`) tolerates Twilio's `connected` preamble without
+* hardcoding it, bounds the number of pre-start frames, and times out — a
+* socket that never sends `start` must not leak a session.
+*/
+/** ws.OPEN — sockets without readyState are assumed open. */
+const OPEN = 1;
+var TwilioMediaTransport = class extends TypedEmitter {
+	ws;
+	streamSidValue = null;
+	startEvent = null;
+	closed = false;
+	constructor(ws) {
+		super();
+		this.ws = ws;
+		ws.on("message", (data) => this.handleMessage(data));
+		ws.on("close", (code, reason) => {
+			this.closed = true;
+			this.emit("close", {
+				code,
+				reason: reason?.toString()
+			});
+		});
+		ws.on("error", (error) => this.emit("error", error));
+	}
+	get streamSid() {
+		return this.streamSidValue;
+	}
+	get start() {
+		return this.startEvent;
+	}
+	get isOpen() {
+		return !this.closed && (this.ws.readyState === void 0 || this.ws.readyState === OPEN);
+	}
+	/**
+	* Resolve with the `start` frame, or reject on timeout / too many pre-start
+	* frames / socket close. Media frames arriving before `start` are counted
+	* but not delivered (there is no session to deliver them to yet).
+	*/
+	awaitStart(options = {}) {
+		if (this.startEvent) return Promise.resolve(this.startEvent);
+		const timeoutMs = options.timeoutMs ?? 5e3;
+		const maxPreStart = options.maxPreStartMessages ?? 8;
+		return new Promise((resolve, reject) => {
+			let preStartSeen = 0;
+			const timer = setTimeout(() => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error(`Twilio start frame not received within ${timeoutMs}ms`));
+			}, timeoutMs);
+			timer.unref?.();
+			const onStart = (event) => {
+				cleanup();
+				resolve(event);
+			};
+			const onPreStart = () => {
+				preStartSeen++;
+				if (preStartSeen > maxPreStart) {
+					cleanup();
+					reject(/* @__PURE__ */ new Error(`no start frame within the first ${maxPreStart} messages`));
+				}
+			};
+			const onClose = () => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("socket closed before start frame"));
+			};
+			const cleanup = () => {
+				clearTimeout(timer);
+				this.off("start", onStart);
+				this.off("close", onClose);
+				this.off("media", onPreStart);
+			};
+			this.on("start", onStart);
+			this.on("media", onPreStart);
+			this.on("close", onClose);
+		});
+	}
+	/** Forward one media payload (base64 μ-law) to the caller. */
+	sendMedia(payload) {
+		const streamSid = this.requireStreamSid();
+		this.sendRaw(JSON.stringify({
+			event: "media",
+			streamSid,
+			media: { payload }
+		}));
+	}
+	/** Interleave a named mark; Twilio echoes it once playout reaches it. */
+	sendMark(name) {
+		const streamSid = this.requireStreamSid();
+		this.sendRaw(JSON.stringify({
+			event: "mark",
+			streamSid,
+			mark: { name }
+		}));
+	}
+	/** Flush Twilio's playout buffer (barge-in). Pending marks echo back as discarded. */
+	sendClear() {
+		const streamSid = this.requireStreamSid();
+		this.sendRaw(JSON.stringify({
+			event: "clear",
+			streamSid
+		}));
+	}
+	close(code, reason) {
+		if (this.closed) return;
+		this.closed = true;
+		try {
+			this.ws.close(code, reason);
+		} catch {}
+	}
+	handleMessage(data) {
+		const message = parseTwilioMessage(data);
+		if (!message) return;
+		switch (message.event) {
+			case "start":
+				this.startEvent = message;
+				this.streamSidValue = message.start.streamSid ?? message.streamSid;
+				this.emit("start", message);
+				break;
+			case "media":
+				this.emit("media", message);
+				break;
+			case "stop":
+				this.emit("stop", message);
+				break;
+			case "mark":
+				this.emit("mark", message);
+				break;
+			case "dtmf": this.emit("dtmf", message);
+		}
+	}
+	requireStreamSid() {
+		if (!this.streamSidValue) throw new Error("cannot send to Twilio before the start frame (no streamSid yet)");
+		return this.streamSidValue;
+	}
+	sendRaw(json) {
+		if (!this.isOpen) return;
+		try {
+			this.ws.send(json);
+		} catch (error) {
+			this.emit("error", error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+};
+//#endregion
+//#region src/twilio/twiml.ts
+/** TwiML helpers for wiring a call into the media-stream bridge. */
+function escapeXml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+/**
+* Build the TwiML that connects a call to the bridge.
+*
+* `<Connect><Stream>` is the bidirectional form. `<Start><Stream>` is
+* send-only — the caller would never hear the agent.
+*/
+function connectStreamTwiml(options) {
+	const params = Object.entries(options.parameters ?? {}).map(([name, value]) => `\n      <Parameter name="${escapeXml(name)}" value="${escapeXml(value)}" />`).join("");
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+  <Connect>
+    ${params ? `<Stream url="${escapeXml(options.wsUrl)}">${params}\n    </Stream>` : `<Stream url="${escapeXml(options.wsUrl)}" />`}
+  </Connect>
+</Response>`;
+}
+//#endregion
+//#region src/twilio/rest.ts
+/**
+* Twilio REST control plane: hangup, transfer, SMS/WhatsApp.
+*
+* Media and control are different planes — the WebSocket carries audio, but
+* ending or redirecting the PSTN leg goes through the REST API. The `twilio`
+* SDK is an optional peer dependency, imported lazily so bridges that never
+* use REST features don't need it installed.
+*/
+/** Loose E.164 check — validated BEFORE interpolation into TwiML. */
+const PHONE_PATTERN = /^\+?[0-9]{5,20}$/;
+function assertValidPhoneNumber(phoneNumber) {
+	if (!PHONE_PATTERN.test(phoneNumber)) throw new Error(`invalid phone number "${phoneNumber}" (expected E.164-like digits, e.g. +15551234567)`);
+}
+var TwilioRestClient = class {
+	config;
+	clientPromise = null;
+	constructor(config) {
+		this.config = config;
+	}
+	client() {
+		if (!this.clientPromise) this.clientPromise = import("twilio").then((mod) => {
+			return (mod.default ?? mod)(this.config.accountSid, this.config.authToken);
+		}).catch((error) => {
+			this.clientPromise = null;
+			throw new Error(`the 'twilio' package is required for REST call control — npm install twilio (${String(error)})`);
+		});
+		return this.clientPromise;
+	}
+	/** End the PSTN leg cleanly (better than just dropping the stream). */
+	async completeCall(callSid) {
+		await (await this.client()).calls(callSid).update({ status: "completed" });
+	}
+	/**
+	* Blind-transfer the call: replace its TwiML with a `<Dial>`. The number
+	* is validated and XML-escaped — never interpolate LLM output raw into
+	* markup.
+	*/
+	async transferCall(callSid, phoneNumber, options = {}) {
+		assertValidPhoneNumber(phoneNumber);
+		const callerId = options.callerId ?? this.config.callerId;
+		if (callerId) assertValidPhoneNumber(callerId);
+		const twiml = `<Response><Dial${callerId ? ` callerId="${escapeXml(callerId)}"` : ""}><Number>${escapeXml(phoneNumber)}</Number></Dial></Response>`;
+		await (await this.client()).calls(callSid).update({ twiml });
+	}
+	async sendSms(options) {
+		assertValidPhoneNumber(options.to);
+		return { sid: (await (await this.client()).messages.create({
+			to: options.to,
+			from: options.from,
+			body: options.body
+		})).sid };
+	}
+	async sendWhatsapp(options) {
+		const to = options.to.startsWith("whatsapp:") ? options.to : `whatsapp:${options.to}`;
+		const from = options.from.startsWith("whatsapp:") ? options.from : `whatsapp:${options.from}`;
+		return { sid: (await (await this.client()).messages.create({
+			to,
+			from,
+			body: options.body
+		})).sid };
+	}
+};
+//#endregion
+export { TwilioMediaTransport as a, escapeXml as i, assertValidPhoneNumber as n, parseTwilioMessage as o, connectStreamTwiml as r, TwilioRestClient as t };

package/dist/rest-BvUKut_k.cjs

@@ -0,0 +1,300 @@
+const require_events = require("./events-BxDTIKKq.cjs");
+//#region src/twilio/messages.ts
+const INBOUND_EVENTS = /* @__PURE__ */ new Set([
+	"connected",
+	"start",
+	"media",
+	"stop",
+	"mark",
+	"dtmf"
+]);
+/**
+* Parse a raw WebSocket frame into a Twilio inbound message.
+* Returns null for non-JSON frames or unknown event types (Twilio may add
+* events; unknown ones must not crash a live call).
+*/
+function parseTwilioMessage(raw) {
+	let parsed;
+	try {
+		parsed = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf8"));
+	} catch {
+		return null;
+	}
+	if (typeof parsed !== "object" || parsed === null) return null;
+	const event = parsed.event;
+	if (typeof event !== "string" || !INBOUND_EVENTS.has(event)) return null;
+	return parsed;
+}
+//#endregion
+//#region src/twilio/transport.ts
+/**
+* TwilioMediaTransport — framing layer over one Twilio Media Stream WebSocket.
+*
+* Wraps any ws-shaped socket (`ws`, @fastify/websocket, express-ws all hand
+* you one), parses inbound frames into typed events, and provides outbound
+* send helpers that carry the streamSid captured from `start`.
+*
+* The handshake (`awaitStart`) tolerates Twilio's `connected` preamble without
+* hardcoding it, bounds the number of pre-start frames, and times out — a
+* socket that never sends `start` must not leak a session.
+*/
+/** ws.OPEN — sockets without readyState are assumed open. */
+const OPEN = 1;
+var TwilioMediaTransport = class extends require_events.TypedEmitter {
+	ws;
+	streamSidValue = null;
+	startEvent = null;
+	closed = false;
+	constructor(ws) {
+		super();
+		this.ws = ws;
+		ws.on("message", (data) => this.handleMessage(data));
+		ws.on("close", (code, reason) => {
+			this.closed = true;
+			this.emit("close", {
+				code,
+				reason: reason?.toString()
+			});
+		});
+		ws.on("error", (error) => this.emit("error", error));
+	}
+	get streamSid() {
+		return this.streamSidValue;
+	}
+	get start() {
+		return this.startEvent;
+	}
+	get isOpen() {
+		return !this.closed && (this.ws.readyState === void 0 || this.ws.readyState === OPEN);
+	}
+	/**
+	* Resolve with the `start` frame, or reject on timeout / too many pre-start
+	* frames / socket close. Media frames arriving before `start` are counted
+	* but not delivered (there is no session to deliver them to yet).
+	*/
+	awaitStart(options = {}) {
+		if (this.startEvent) return Promise.resolve(this.startEvent);
+		const timeoutMs = options.timeoutMs ?? 5e3;
+		const maxPreStart = options.maxPreStartMessages ?? 8;
+		return new Promise((resolve, reject) => {
+			let preStartSeen = 0;
+			const timer = setTimeout(() => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error(`Twilio start frame not received within ${timeoutMs}ms`));
+			}, timeoutMs);
+			timer.unref?.();
+			const onStart = (event) => {
+				cleanup();
+				resolve(event);
+			};
+			const onPreStart = () => {
+				preStartSeen++;
+				if (preStartSeen > maxPreStart) {
+					cleanup();
+					reject(/* @__PURE__ */ new Error(`no start frame within the first ${maxPreStart} messages`));
+				}
+			};
+			const onClose = () => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("socket closed before start frame"));
+			};
+			const cleanup = () => {
+				clearTimeout(timer);
+				this.off("start", onStart);
+				this.off("close", onClose);
+				this.off("media", onPreStart);
+			};
+			this.on("start", onStart);
+			this.on("media", onPreStart);
+			this.on("close", onClose);
+		});
+	}
+	/** Forward one media payload (base64 μ-law) to the caller. */
+	sendMedia(payload) {
+		const streamSid = this.requireStreamSid();
+		this.sendRaw(JSON.stringify({
+			event: "media",
+			streamSid,
+			media: { payload }
+		}));
+	}
+	/** Interleave a named mark; Twilio echoes it once playout reaches it. */
+	sendMark(name) {
+		const streamSid = this.requireStreamSid();
+		this.sendRaw(JSON.stringify({
+			event: "mark",
+			streamSid,
+			mark: { name }
+		}));
+	}
+	/** Flush Twilio's playout buffer (barge-in). Pending marks echo back as discarded. */
+	sendClear() {
+		const streamSid = this.requireStreamSid();
+		this.sendRaw(JSON.stringify({
+			event: "clear",
+			streamSid
+		}));
+	}
+	close(code, reason) {
+		if (this.closed) return;
+		this.closed = true;
+		try {
+			this.ws.close(code, reason);
+		} catch {}
+	}
+	handleMessage(data) {
+		const message = parseTwilioMessage(data);
+		if (!message) return;
+		switch (message.event) {
+			case "start":
+				this.startEvent = message;
+				this.streamSidValue = message.start.streamSid ?? message.streamSid;
+				this.emit("start", message);
+				break;
+			case "media":
+				this.emit("media", message);
+				break;
+			case "stop":
+				this.emit("stop", message);
+				break;
+			case "mark":
+				this.emit("mark", message);
+				break;
+			case "dtmf": this.emit("dtmf", message);
+		}
+	}
+	requireStreamSid() {
+		if (!this.streamSidValue) throw new Error("cannot send to Twilio before the start frame (no streamSid yet)");
+		return this.streamSidValue;
+	}
+	sendRaw(json) {
+		if (!this.isOpen) return;
+		try {
+			this.ws.send(json);
+		} catch (error) {
+			this.emit("error", error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+};
+//#endregion
+//#region src/twilio/twiml.ts
+/** TwiML helpers for wiring a call into the media-stream bridge. */
+function escapeXml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+/**
+* Build the TwiML that connects a call to the bridge.
+*
+* `<Connect><Stream>` is the bidirectional form. `<Start><Stream>` is
+* send-only — the caller would never hear the agent.
+*/
+function connectStreamTwiml(options) {
+	const params = Object.entries(options.parameters ?? {}).map(([name, value]) => `\n      <Parameter name="${escapeXml(name)}" value="${escapeXml(value)}" />`).join("");
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+  <Connect>
+    ${params ? `<Stream url="${escapeXml(options.wsUrl)}">${params}\n    </Stream>` : `<Stream url="${escapeXml(options.wsUrl)}" />`}
+  </Connect>
+</Response>`;
+}
+//#endregion
+//#region src/twilio/rest.ts
+/**
+* Twilio REST control plane: hangup, transfer, SMS/WhatsApp.
+*
+* Media and control are different planes — the WebSocket carries audio, but
+* ending or redirecting the PSTN leg goes through the REST API. The `twilio`
+* SDK is an optional peer dependency, imported lazily so bridges that never
+* use REST features don't need it installed.
+*/
+/** Loose E.164 check — validated BEFORE interpolation into TwiML. */
+const PHONE_PATTERN = /^\+?[0-9]{5,20}$/;
+function assertValidPhoneNumber(phoneNumber) {
+	if (!PHONE_PATTERN.test(phoneNumber)) throw new Error(`invalid phone number "${phoneNumber}" (expected E.164-like digits, e.g. +15551234567)`);
+}
+var TwilioRestClient = class {
+	config;
+	clientPromise = null;
+	constructor(config) {
+		this.config = config;
+	}
+	client() {
+		if (!this.clientPromise) this.clientPromise = import("twilio").then((mod) => {
+			return (mod.default ?? mod)(this.config.accountSid, this.config.authToken);
+		}).catch((error) => {
+			this.clientPromise = null;
+			throw new Error(`the 'twilio' package is required for REST call control — npm install twilio (${String(error)})`);
+		});
+		return this.clientPromise;
+	}
+	/** End the PSTN leg cleanly (better than just dropping the stream). */
+	async completeCall(callSid) {
+		await (await this.client()).calls(callSid).update({ status: "completed" });
+	}
+	/**
+	* Blind-transfer the call: replace its TwiML with a `<Dial>`. The number
+	* is validated and XML-escaped — never interpolate LLM output raw into
+	* markup.
+	*/
+	async transferCall(callSid, phoneNumber, options = {}) {
+		assertValidPhoneNumber(phoneNumber);
+		const callerId = options.callerId ?? this.config.callerId;
+		if (callerId) assertValidPhoneNumber(callerId);
+		const twiml = `<Response><Dial${callerId ? ` callerId="${escapeXml(callerId)}"` : ""}><Number>${escapeXml(phoneNumber)}</Number></Dial></Response>`;
+		await (await this.client()).calls(callSid).update({ twiml });
+	}
+	async sendSms(options) {
+		assertValidPhoneNumber(options.to);
+		return { sid: (await (await this.client()).messages.create({
+			to: options.to,
+			from: options.from,
+			body: options.body
+		})).sid };
+	}
+	async sendWhatsapp(options) {
+		const to = options.to.startsWith("whatsapp:") ? options.to : `whatsapp:${options.to}`;
+		const from = options.from.startsWith("whatsapp:") ? options.from : `whatsapp:${options.from}`;
+		return { sid: (await (await this.client()).messages.create({
+			to,
+			from,
+			body: options.body
+		})).sid };
+	}
+};
+//#endregion
+Object.defineProperty(exports, "TwilioMediaTransport", {
+	enumerable: true,
+	get: function() {
+		return TwilioMediaTransport;
+	}
+});
+Object.defineProperty(exports, "TwilioRestClient", {
+	enumerable: true,
+	get: function() {
+		return TwilioRestClient;
+	}
+});
+Object.defineProperty(exports, "assertValidPhoneNumber", {
+	enumerable: true,
+	get: function() {
+		return assertValidPhoneNumber;
+	}
+});
+Object.defineProperty(exports, "connectStreamTwiml", {
+	enumerable: true,
+	get: function() {
+		return connectStreamTwiml;
+	}
+});
+Object.defineProperty(exports, "escapeXml", {
+	enumerable: true,
+	get: function() {
+		return escapeXml;
+	}
+});
+Object.defineProperty(exports, "parseTwilioMessage", {
+	enumerable: true,
+	get: function() {
+		return parseTwilioMessage;
+	}
+});

package/dist/rolldown-runtime-VH7oDXx4.cjs

@@ -0,0 +1,28 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/dist/session-config-BVLl7-ha.mjs

@@ -0,0 +1,74 @@
+import { n as deepMerge } from "./BaseRealtimeProvider-BQigr5mB.mjs";
+//#region src/providers/openai-compatible/session-config.ts
+/**
+* session.update payload construction — GA Realtime API only.
+*
+* The single most fragile spot in Twilio↔OpenAI bridges: a rejected
+* session.update leaves the session on 24 kHz PCM defaults, which Twilio
+* renders as loud static. Keeping every field in one builder makes the wire
+* shape a single point of truth (and of fixing).
+*
+* GA shape notes (vs the old beta many tutorials still show):
+* - audio formats are MIME-style objects (`{ type: 'audio/pcmu' }`), nested
+*   under `session.audio.input/output` — not flat `input_audio_format: 'g711_ulaw'`
+* - assistant audio arrives as `response.output_audio.delta` — not
+*   `response.audio.delta`
+* - `turn_detection: null` explicitly disables server VAD
+*/
+function buildTurnDetection(vad) {
+	if (vad === null) return null;
+	const config = vad ?? { type: "server" };
+	const shared = {
+		...config.interruptResponse !== void 0 ? { interrupt_response: config.interruptResponse } : {},
+		...config.createResponse !== void 0 ? { create_response: config.createResponse } : {}
+	};
+	if (config.type === "semantic") return {
+		type: "semantic_vad",
+		...config.eagerness ? { eagerness: config.eagerness } : {},
+		...shared
+	};
+	return {
+		type: "server_vad",
+		...config.threshold !== void 0 ? { threshold: config.threshold } : {},
+		...config.silenceDurationMs !== void 0 ? { silence_duration_ms: config.silenceDurationMs } : {},
+		...config.prefixPaddingMs !== void 0 ? { prefix_padding_ms: config.prefixPaddingMs } : {},
+		...shared
+	};
+}
+function buildSessionUpdate(init, config = {}) {
+	const voice = init.voice ?? config.defaultVoice;
+	const transcription = init.transcription === false ? void 0 : init.transcription;
+	let session = {
+		type: "realtime",
+		instructions: init.instructions,
+		tools: (init.tools ?? []).map((tool) => ({
+			type: "function",
+			name: tool.name,
+			description: tool.description ?? "",
+			parameters: tool.parameters
+		})),
+		tool_choice: "auto",
+		audio: {
+			input: {
+				format: { type: "audio/pcmu" },
+				turn_detection: buildTurnDetection(init.vad),
+				...transcription ? { transcription: {
+					model: transcription.model ?? "gpt-4o-mini-transcribe",
+					...transcription.language ? { language: transcription.language } : {}
+				} } : {}
+			},
+			output: {
+				format: { type: "audio/pcmu" },
+				...voice ? { voice } : {}
+			}
+		}
+	};
+	session = deepMerge(session, init.providerOptions);
+	session = deepMerge(session, config.extraSessionOptions);
+	return {
+		type: "session.update",
+		session
+	};
+}
+//#endregion
+export { buildTurnDetection as n, buildSessionUpdate as t };