@cloudflare/voice-telnyx 0.0.0 → 0.0.2

package/dist/browser.js

@@ -0,0 +1,1010 @@
+import { TelnyxRTC } from "@telnyx/webrtc";
+//#region src/audio/utils.ts
+/**
+* Convert Float32 audio samples (-1.0..1.0) to Int16 PCM (-32768..32767).
+* Clamps values outside the -1..1 range.
+*/
+function float32ToInt16(float32) {
+	const int16 = new Int16Array(float32.length);
+	for (let i = 0; i < float32.length; i++) {
+		const clamped = Math.max(-1, Math.min(1, float32[i]));
+		int16[i] = clamped < 0 ? clamped * 32768 : clamped * 32767;
+	}
+	return int16;
+}
+/**
+* Compute the Root Mean Square (RMS) of audio samples.
+* Returns 0 for empty input.
+*/
+function computeRMS(samples) {
+	if (samples.length === 0) return 0;
+	let sum = 0;
+	for (let i = 0; i < samples.length; i++) sum += samples[i] * samples[i];
+	return Math.sqrt(sum / samples.length);
+}
+/**
+* AudioWorklet processor source code for capturing PCM from a MediaStream.
+*
+* This processor collects Float32 audio frames and posts them to the
+* main thread via the MessagePort. It runs in the AudioWorklet thread.
+*
+* Expected AudioContext sampleRate: 16000 (browser resamples from source).
+*/
+const PCM_CAPTURE_PROCESSOR_SOURCE = `
+class PcmCaptureProcessor extends AudioWorkletProcessor {
+  process(inputs) {
+    const input = inputs[0];
+    if (input && input[0] && input[0].length > 0) {
+      // Post a copy of the Float32 channel data to the main thread
+      this.port.postMessage(new Float32Array(input[0]));
+    }
+    return true;
+  }
+}
+registerProcessor("pcm-capture-processor", PcmCaptureProcessor);
+`;
+/**
+* AudioWorklet processor source code for playing back PCM into a MediaStream.
+*
+* Receives Float32 audio frames from the main thread via MessagePort
+* and writes them to the output buffer. Buffers frames to handle timing
+* differences between the main thread and the audio thread.
+*
+* Expected AudioContext sampleRate: 48000 (matching WebRTC).
+*/
+const PCM_PLAYBACK_PROCESSOR_SOURCE = `
+class PcmPlaybackProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this._buffer = [];
+    this._maxBufferFrames = 50; // ~1s at 48kHz/128 samples per frame
+    this.port.onmessage = (e) => {
+      if (e.data === 'clear') {
+        this._buffer = [];
+        return;
+      }
+      this._buffer.push(e.data);
+      // Evict oldest frames if buffer grows too large
+      while (this._buffer.length > this._maxBufferFrames) {
+        this._buffer.shift();
+      }
+    };
+  }
+
+  process(inputs, outputs) {
+    const output = outputs[0];
+    if (!output || !output[0]) return true;
+
+    const channel = output[0];
+    let written = 0;
+
+    while (written < channel.length && this._buffer.length > 0) {
+      const frame = this._buffer[0];
+      const available = frame.length;
+      const needed = channel.length - written;
+
+      if (available <= needed) {
+        channel.set(frame, written);
+        written += available;
+        this._buffer.shift();
+      } else {
+        channel.set(frame.subarray(0, needed), written);
+        this._buffer[0] = frame.subarray(needed);
+        written += needed;
+      }
+    }
+
+    // Fill remainder with silence
+    for (let i = written; i < channel.length; i++) {
+      channel[i] = 0;
+    }
+
+    return true;
+  }
+}
+registerProcessor("pcm-playback-processor", PcmPlaybackProcessor);
+`;
+//#endregion
+//#region src/providers/call-bridge.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isTelnyxNotification(value) {
+	return isRecord(value);
+}
+function hasNewCall(client) {
+	return "newCall" in client && typeof client.newCall === "function";
+}
+function getPeerConnection(call) {
+	return call.peer?.instance;
+}
+function getRemoteStream(call) {
+	return call.remoteStream ?? null;
+}
+/**
+* Bridges Telnyx phone calls into the Cloudflare voice pipeline.
+*
+* Implements `VoiceAudioInput` from @cloudflare/voice — extracts PCM
+* audio from inbound phone calls and feeds it to the AI pipeline.
+* Also provides `playAudio()` for injecting response audio back
+* into the phone call.
+*
+* Usage:
+* ```typescript
+* const bridge = new TelnyxCallBridge({ loginToken: jwt });
+* const voiceClient = new VoiceClient({
+*   agent: "my-agent",
+*   audioInput: bridge,
+* });
+* ```
+*/
+var TelnyxCallBridge = class {
+	constructor(config) {
+		this.onAudioLevel = null;
+		this.onAudioData = null;
+		this._connected = false;
+		this._activeCall = null;
+		this.client = null;
+		this.captureContext = null;
+		this.captureSource = null;
+		this.captureWorklet = null;
+		this.captureBlobUrl = null;
+		this.captureAudioEl = null;
+		this.statsInterval = null;
+		this.playbackContext = null;
+		this.playbackWorklet = null;
+		this.playbackBlobUrl = null;
+		this.startPromise = null;
+		this.finishStart = null;
+		this.startAttempt = 0;
+		this.mediaSetupAttempt = 0;
+		this.config = config;
+	}
+	/** Whether the Telnyx client is connected to the platform. */
+	get connected() {
+		return this._connected;
+	}
+	/** The currently active Telnyx call, or null. */
+	get activeCall() {
+		return this._activeCall;
+	}
+	/** Connect to Telnyx and start listening for calls. */
+	async start() {
+		if (this._connected) return;
+		if (this.startPromise) return this.startPromise;
+		const attempt = ++this.startAttempt;
+		const client = new TelnyxRTC({
+			login_token: this.config.loginToken,
+			debug: this.config.debug
+		});
+		this.client = client;
+		this.startPromise = new Promise((resolve, reject) => {
+			this.finishStart = resolve;
+			client.on("telnyx.ready", () => {
+				if (this.startAttempt !== attempt || this.client !== client) {
+					resolve();
+					return;
+				}
+				this._connected = true;
+				resolve();
+			});
+			client.on("telnyx.error", (error) => {
+				if (this.startAttempt !== attempt || this.client !== client) {
+					resolve();
+					return;
+				}
+				reject(error);
+			});
+			client.on("telnyx.notification", (notification) => {
+				if (this.startAttempt !== attempt || this.client !== client) return;
+				this.handleNotification(notification);
+			});
+			client.connect();
+		}).finally(() => {
+			if (this.startAttempt === attempt) {
+				this.startPromise = null;
+				this.finishStart = null;
+			}
+		});
+		return this.startPromise;
+	}
+	/** Answer the current inbound call. */
+	answer() {
+		if (!this._activeCall) throw new Error("No active call");
+		this._activeCall.answer?.();
+	}
+	/** End the active call. */
+	hangup() {
+		if (!this._activeCall) return;
+		this._activeCall.hangup?.();
+	}
+	/**
+	* Initiate an outbound PSTN call.
+	* @param destination Phone number or SIP URI to call.
+	* @param callerNumber The caller ID number to present.
+	* @returns The Telnyx Call object.
+	*/
+	dial(destination, callerNumber) {
+		if (!this.client) throw new Error("Not connected — call start() first");
+		if (!hasNewCall(this.client)) throw new Error("Telnyx client does not expose newCall()");
+		const call = this.client.newCall({
+			destinationNumber: destination,
+			callerNumber
+		});
+		this._activeCall = call;
+		return call;
+	}
+	/** Send DTMF digits on the active call. */
+	sendDTMF(digits) {
+		if (!this._activeCall) throw new Error("No active call");
+		this._activeCall.dtmf?.(digits);
+	}
+	/**
+	* Clear any buffered audio in the playback pipeline.
+	* Used during interrupt detection to stop stale audio from playing.
+	*/
+	clearPlaybackBuffer() {
+		this.playbackWorklet?.port.postMessage("clear");
+	}
+	/**
+	* Inject PCM audio into the active phone call (agent → caller).
+	* Accepts 16kHz mono Int16 PCM. Upsamples to 48kHz for WebRTC.
+	* No-op if no active call.
+	*/
+	playAudio(pcm) {
+		if (!this.playbackWorklet) return;
+		const int16 = new Int16Array(pcm);
+		const upsampleRatio = 3;
+		const float32 = new Float32Array(int16.length * upsampleRatio);
+		for (let i = 0; i < int16.length; i++) {
+			const current = int16[i] / 32768;
+			const next = i < int16.length - 1 ? int16[i + 1] / 32768 : current;
+			const base = i * upsampleRatio;
+			for (let j = 0; j < upsampleRatio; j++) float32[base + j] = current + (next - current) * (j / upsampleRatio);
+		}
+		this.playbackWorklet.port.postMessage(float32);
+	}
+	/** Disconnect from Telnyx and clean up all resources. */
+	stop() {
+		this.startAttempt++;
+		this.mediaSetupAttempt++;
+		this.finishStart?.();
+		this.finishStart = null;
+		this.startPromise = null;
+		this.stopAudioCapture();
+		this.stopAudioPlayback();
+		this._activeCall = null;
+		this._connected = false;
+		if (this.client) {
+			this.client.disconnect();
+			this.client = null;
+		}
+	}
+	handleNotification(notification) {
+		if (!isTelnyxNotification(notification)) return;
+		console.log("[TelnyxCallBridge] notification:", notification.type, "call:", !!notification.call, "state:", notification.call?.state);
+		if (notification.type !== "callUpdate" || !notification.call) return;
+		const call = notification.call;
+		console.log("[TelnyxCallBridge] call state:", call.state);
+		switch (call.state) {
+			case "ringing":
+				this._activeCall = call;
+				if (this.config.autoAnswer) {
+					console.log("[TelnyxCallBridge] auto-answering call");
+					call.answer?.();
+				}
+				break;
+			case "active":
+				this._activeCall = call;
+				console.log("[TelnyxCallBridge] call active — starting audio capture + playback");
+				this.mediaSetupAttempt++;
+				this.stopAudioCapture();
+				this.stopAudioPlayback();
+				this.startAudioCapture(call, this.mediaSetupAttempt).catch((err) => console.error("[TelnyxCallBridge] startAudioCapture failed:", err));
+				this.startAudioPlayback(call, this.mediaSetupAttempt).catch((err) => console.error("[TelnyxCallBridge] startAudioPlayback failed:", err));
+				break;
+			case "hangup":
+			case "destroy":
+			case "purge":
+				this.mediaSetupAttempt++;
+				this.stopAudioCapture();
+				this.stopAudioPlayback();
+				this._activeCall = null;
+				break;
+		}
+	}
+	isCurrentMediaSetup(setupAttempt) {
+		return this.mediaSetupAttempt === setupAttempt;
+	}
+	cleanupCaptureResources(resources) {
+		resources.worklet?.disconnect();
+		resources.source?.disconnect();
+		resources.context?.close();
+		if (resources.blobUrl) URL.revokeObjectURL(resources.blobUrl);
+		if (resources.audioEl) {
+			resources.audioEl.pause();
+			resources.audioEl.srcObject = null;
+			resources.audioEl.remove();
+		}
+	}
+	cleanupPlaybackResources(resources) {
+		resources.worklet?.disconnect();
+		resources.context?.close();
+		if (resources.blobUrl) URL.revokeObjectURL(resources.blobUrl);
+	}
+	async startAudioCapture(call, setupAttempt) {
+		const pc = getPeerConnection(call);
+		let track = null;
+		if (pc) track = pc.getReceivers().find((r) => r.track?.kind === "audio")?.track ?? null;
+		if (!track) track = getRemoteStream(call)?.getAudioTracks()?.[0] ?? null;
+		if (!track || track.readyState !== "live") {
+			console.warn("[TelnyxCallBridge] No live audio track — audio capture skipped");
+			return;
+		}
+		track.enabled = true;
+		const remoteStream = new MediaStream([track]);
+		const captureAudioEl = document.createElement("audio");
+		captureAudioEl.srcObject = remoteStream;
+		captureAudioEl.autoplay = true;
+		captureAudioEl.volume = 0;
+		document.body.appendChild(captureAudioEl);
+		try {
+			await captureAudioEl.play();
+		} catch (e) {
+			console.warn("[TelnyxCallBridge] audio element play() failed:", e);
+		}
+		if (track.muted) {
+			console.log("[TelnyxCallBridge] track muted — waiting for unmute...");
+			await new Promise((resolve) => {
+				const onUnmute = () => {
+					track.removeEventListener("unmute", onUnmute);
+					console.log("[TelnyxCallBridge] track unmuted");
+					resolve();
+				};
+				track.addEventListener("unmute", onUnmute);
+				setTimeout(() => {
+					track.removeEventListener("unmute", onUnmute);
+					resolve();
+				}, 5e3);
+			});
+		}
+		if (!this.isCurrentMediaSetup(setupAttempt)) {
+			this.cleanupCaptureResources({ audioEl: captureAudioEl });
+			return;
+		}
+		const captureContext = new AudioContext({ sampleRate: 48e3 });
+		if (captureContext.state === "suspended") await captureContext.resume();
+		if (!this.isCurrentMediaSetup(setupAttempt)) {
+			this.cleanupCaptureResources({
+				audioEl: captureAudioEl,
+				context: captureContext
+			});
+			return;
+		}
+		const blob = new Blob([PCM_CAPTURE_PROCESSOR_SOURCE], { type: "application/javascript" });
+		const captureBlobUrl = URL.createObjectURL(blob);
+		await captureContext.audioWorklet.addModule(captureBlobUrl);
+		if (!this.isCurrentMediaSetup(setupAttempt)) {
+			this.cleanupCaptureResources({
+				audioEl: captureAudioEl,
+				context: captureContext,
+				blobUrl: captureBlobUrl
+			});
+			return;
+		}
+		const captureSource = captureContext.createMediaStreamSource(remoteStream);
+		const captureWorklet = new AudioWorkletNode(captureContext, "pcm-capture-processor");
+		const downsampleRatio = 3;
+		let captureCount = 0;
+		captureWorklet.port.onmessage = (event) => {
+			if (!(event.data instanceof Float32Array)) return;
+			const raw = event.data;
+			const outLen = Math.floor(raw.length / downsampleRatio);
+			const float32 = new Float32Array(outLen);
+			for (let i = 0; i < outLen; i++) {
+				const srcIdx = i * downsampleRatio;
+				const idx0 = Math.floor(srcIdx);
+				const idx1 = Math.min(idx0 + 1, raw.length - 1);
+				const frac = srcIdx - idx0;
+				float32[i] = raw[idx0] * (1 - frac) + raw[idx1] * frac;
+			}
+			const rms = computeRMS(float32);
+			captureCount++;
+			if (captureCount <= 5 || captureCount % 200 === 0) console.log(`[TelnyxCallBridge] capture #${captureCount} rms=${rms.toFixed(4)} samples=${float32.length}`);
+			this.onAudioLevel?.(rms);
+			const int16 = float32ToInt16(float32);
+			this.onAudioData?.(int16.buffer);
+		};
+		this.captureAudioEl = captureAudioEl;
+		this.captureContext = captureContext;
+		this.captureBlobUrl = captureBlobUrl;
+		this.captureSource = captureSource;
+		this.captureWorklet = captureWorklet;
+		captureSource.connect(captureWorklet);
+		captureWorklet.connect(captureContext.destination);
+		if (pc) this.monitorInboundStats(pc);
+	}
+	monitorInboundStats(pc) {
+		let count = 0;
+		this.statsInterval = setInterval(async () => {
+			count++;
+			if (count > 10 || pc.connectionState === "closed") {
+				if (this.statsInterval) {
+					clearInterval(this.statsInterval);
+					this.statsInterval = null;
+				}
+				return;
+			}
+			try {
+				const stats = await pc.getStats();
+				for (const [, report] of stats) {
+					const inbound = report;
+					if (inbound.type === "inbound-rtp" && inbound.kind === "audio") console.log("[TelnyxCallBridge] inbound-rtp:", `bytesRx=${inbound.bytesReceived}`, `pktsRx=${inbound.packetsReceived}`, `pktsLost=${inbound.packetsLost}`, `pktsDiscard=${inbound.packetsDiscarded ?? "n/a"}`, `samplesRx=${inbound.totalSamplesReceived}`, `jbEmit=${inbound.jitterBufferEmittedCount}`);
+				}
+			} catch {
+				if (this.statsInterval) {
+					clearInterval(this.statsInterval);
+					this.statsInterval = null;
+				}
+			}
+		}, 2e3);
+	}
+	stopAudioCapture() {
+		if (this.statsInterval) {
+			clearInterval(this.statsInterval);
+			this.statsInterval = null;
+		}
+		if (this.captureWorklet) {
+			this.captureWorklet.disconnect();
+			this.captureWorklet = null;
+		}
+		if (this.captureSource) {
+			this.captureSource.disconnect();
+			this.captureSource = null;
+		}
+		if (this.captureContext) {
+			this.captureContext.close();
+			this.captureContext = null;
+		}
+		if (this.captureBlobUrl) {
+			URL.revokeObjectURL(this.captureBlobUrl);
+			this.captureBlobUrl = null;
+		}
+		if (this.captureAudioEl) {
+			this.captureAudioEl.pause();
+			this.captureAudioEl.srcObject = null;
+			this.captureAudioEl.remove();
+			this.captureAudioEl = null;
+		}
+	}
+	async startAudioPlayback(call, setupAttempt) {
+		const peerConnection = getPeerConnection(call);
+		if (!peerConnection) return;
+		const playbackContext = new AudioContext({ sampleRate: 48e3 });
+		if (playbackContext.state === "suspended") await playbackContext.resume();
+		if (!this.isCurrentMediaSetup(setupAttempt)) {
+			this.cleanupPlaybackResources({ context: playbackContext });
+			return;
+		}
+		const blob = new Blob([PCM_PLAYBACK_PROCESSOR_SOURCE], { type: "application/javascript" });
+		const playbackBlobUrl = URL.createObjectURL(blob);
+		await playbackContext.audioWorklet.addModule(playbackBlobUrl);
+		if (!this.isCurrentMediaSetup(setupAttempt)) {
+			this.cleanupPlaybackResources({
+				context: playbackContext,
+				blobUrl: playbackBlobUrl
+			});
+			return;
+		}
+		const playbackWorklet = new AudioWorkletNode(playbackContext, "pcm-playback-processor");
+		const destination = playbackContext.createMediaStreamDestination();
+		this.playbackContext = playbackContext;
+		this.playbackBlobUrl = playbackBlobUrl;
+		this.playbackWorklet = playbackWorklet;
+		playbackWorklet.connect(destination);
+		const audioTrack = destination.stream.getAudioTracks()[0];
+		if (audioTrack) {
+			const sender = peerConnection.getSenders().find((s) => s.track?.kind === "audio");
+			if (sender) await sender.replaceTrack(audioTrack);
+		}
+	}
+	stopAudioPlayback() {
+		if (this.playbackWorklet) {
+			this.playbackWorklet.disconnect();
+			this.playbackWorklet = null;
+		}
+		if (this.playbackContext) {
+			this.playbackContext.close();
+			this.playbackContext = null;
+		}
+		if (this.playbackBlobUrl) {
+			URL.revokeObjectURL(this.playbackBlobUrl);
+			this.playbackBlobUrl = null;
+		}
+	}
+};
+//#endregion
+//#region src/phone-client.ts
+var TelnyxPhoneClient = class {
+	constructor(config) {
+		this._status = "idle";
+		this._transcript = [];
+		this._metrics = null;
+		this._audioLevel = 0;
+		this._isMuted = false;
+		this._connected = false;
+		this._error = null;
+		this._interimTranscript = null;
+		this._lastCustomMessage = null;
+		this._audioFormat = null;
+		this._serverProtocolVersion = null;
+		this.inCall = false;
+		this.isPlaying = false;
+		this.isSpeaking = false;
+		this.silenceTimer = null;
+		this.interruptChunkCount = 0;
+		this.warnedFormat = false;
+		this.listeners = /* @__PURE__ */ new Map();
+		this.decodeContext = null;
+		this.transport = config.transport;
+		this.bridge = config.bridge;
+		this.preferredFormat = config.preferredFormat ?? "pcm16";
+		this.silenceThreshold = config.silenceThreshold ?? .04;
+		this.silenceDurationMs = config.silenceDurationMs ?? 500;
+		this.interruptThreshold = config.interruptThreshold ?? .05;
+		this.interruptChunks = config.interruptChunks ?? 2;
+		this.maxTranscriptMessages = config.maxTranscriptMessages ?? 200;
+	}
+	get status() {
+		return this._status;
+	}
+	get transcript() {
+		return this._transcript;
+	}
+	get metrics() {
+		return this._metrics;
+	}
+	get audioLevel() {
+		return this._audioLevel;
+	}
+	get isMuted() {
+		return this._isMuted;
+	}
+	get connected() {
+		return this._connected;
+	}
+	get error() {
+		return this._error;
+	}
+	get interimTranscript() {
+		return this._interimTranscript;
+	}
+	get lastCustomMessage() {
+		return this._lastCustomMessage;
+	}
+	get audioFormat() {
+		return this._audioFormat;
+	}
+	get serverProtocolVersion() {
+		return this._serverProtocolVersion;
+	}
+	addEventListener(event, listener) {
+		let set = this.listeners.get(event);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.listeners.set(event, set);
+		}
+		set.add(listener);
+	}
+	removeEventListener(event, listener) {
+		this.listeners.get(event)?.delete(listener);
+	}
+	emit(event, data) {
+		const set = this.listeners.get(event);
+		if (set) for (const fn of set) fn(data);
+	}
+	/** Open the transport connection and send the protocol handshake. */
+	connect() {
+		this.transport.onopen = () => {
+			this._connected = true;
+			this._error = null;
+			this.transport.sendJSON({
+				type: "hello",
+				protocol_version: 1
+			});
+			this.emit("connectionchange", true);
+			this.emit("error", null);
+			if (this.inCall) this.transport.sendJSON(this.createStartCallMessage());
+		};
+		this.transport.onclose = () => {
+			this._connected = false;
+			this.emit("connectionchange", false);
+		};
+		this.transport.onerror = () => {
+			this._error = "Connection lost. Reconnecting...";
+			this.emit("error", this._error);
+		};
+		this.transport.onmessage = (data) => {
+			if (typeof data === "string") this.handleJSON(data);
+			else if (data instanceof ArrayBuffer) this.handleAudio(data);
+			else if (data instanceof Blob) data.arrayBuffer().then((buf) => this.handleAudio(buf));
+		};
+		this.transport.connect();
+	}
+	/** End any active call, then close the transport. */
+	disconnect() {
+		this.endCall();
+		this.transport.disconnect();
+		this._connected = false;
+		this.emit("connectionchange", false);
+	}
+	/**
+	* Start a voice call. Wires up the bridge audio callbacks,
+	* starts the bridge, and sends `start_call` to the server.
+	*
+	* The bridge's `start()` is called here — do not call it separately.
+	*/
+	async startCall() {
+		if (!this.transport.connected) {
+			this._error = "Cannot start call: not connected. Call connect() first.";
+			this.emit("error", this._error);
+			return;
+		}
+		this.inCall = true;
+		this._error = null;
+		this._metrics = null;
+		this.emit("error", null);
+		this.emit("metricschange", null);
+		this.transport.sendJSON(this.createStartCallMessage());
+		this.bridge.onAudioLevel = (rms) => this.processAudioLevel(rms);
+		this.bridge.onAudioData = (pcm) => {
+			if (this.transport.connected && !this._isMuted) this.transport.sendBinary(pcm);
+		};
+		await this.bridge.start();
+	}
+	/**
+	* End the voice call. Detaches audio callbacks from the bridge
+	* and sends `end_call` to the server.
+	*
+	* Does NOT stop the bridge or hang up the phone — call
+	* `bridge.stop()` or `cleanup()` separately for that.
+	*/
+	endCall() {
+		this.inCall = false;
+		if (this.transport.connected) this.transport.sendJSON({ type: "end_call" });
+		this.bridge.onAudioLevel = null;
+		if (this.bridge.onAudioData !== void 0) this.bridge.onAudioData = null;
+		this.isPlaying = false;
+		this.resetDetection();
+		this._status = "idle";
+		this.emit("statuschange", "idle");
+	}
+	/** Toggle mute. When muted, audio is not sent to the server. */
+	toggleMute() {
+		this._isMuted = !this._isMuted;
+		if (this._isMuted) {
+			this._audioLevel = 0;
+			this.emit("audiolevelchange", 0);
+		}
+		if (this._isMuted && this.isSpeaking) {
+			this.isSpeaking = false;
+			if (this.silenceTimer) {
+				clearTimeout(this.silenceTimer);
+				this.silenceTimer = null;
+			}
+			if (this.transport.connected) this.transport.sendJSON({ type: "end_of_speech" });
+		}
+		this.emit("mutechange", this._isMuted);
+	}
+	/** Send a text message to the agent (bypasses STT, goes to onTurn). */
+	sendText(text) {
+		if (this.transport.connected) this.transport.sendJSON({
+			type: "text_message",
+			text
+		});
+	}
+	/** Send arbitrary JSON to the agent (app-level messages). */
+	sendJSON(data) {
+		if (this.transport.connected) this.transport.sendJSON(data);
+	}
+	createStartCallMessage() {
+		const startMsg = { type: "start_call" };
+		if (this.preferredFormat) startMsg.preferred_format = this.preferredFormat;
+		return startMsg;
+	}
+	handleJSON(raw) {
+		let msg;
+		try {
+			msg = JSON.parse(raw);
+		} catch {
+			return;
+		}
+		switch (msg.type) {
+			case "welcome":
+				this._serverProtocolVersion = msg.protocol_version;
+				if (msg.protocol_version !== 1) console.warn(`[TelnyxPhoneClient] Protocol version mismatch: client=1, server=${msg.protocol_version}`);
+				break;
+			case "audio_config":
+				this._audioFormat = msg.format;
+				this.warnedFormat = false;
+				break;
+			case "status":
+				this._status = msg.status;
+				this.isPlaying = msg.status === "speaking";
+				if (msg.status === "listening" || msg.status === "idle") {
+					this._error = null;
+					this.emit("error", null);
+				}
+				this.emit("statuschange", this._status);
+				break;
+			case "transcript_interim":
+				this._interimTranscript = msg.text;
+				this.emit("interimtranscript", this._interimTranscript);
+				break;
+			case "transcript":
+				this._interimTranscript = null;
+				this.emit("interimtranscript", null);
+				if (msg.role === "user" && this.isPlaying) {
+					this.isPlaying = false;
+					this.bridge.clearPlaybackBuffer();
+				}
+				this._transcript = [...this._transcript, {
+					role: msg.role,
+					text: msg.text,
+					timestamp: Date.now()
+				}];
+				this.trimTranscript();
+				this.emit("transcriptchange", this._transcript);
+				break;
+			case "transcript_start":
+				this._transcript = [...this._transcript, {
+					role: "assistant",
+					text: "",
+					timestamp: Date.now()
+				}];
+				this.trimTranscript();
+				this.emit("transcriptchange", this._transcript);
+				break;
+			case "transcript_delta": {
+				if (this._transcript.length === 0) break;
+				const updated = [...this._transcript];
+				const last = updated[updated.length - 1];
+				if (last.role === "assistant") {
+					updated[updated.length - 1] = {
+						...last,
+						text: last.text + msg.text
+					};
+					this._transcript = updated;
+					this.emit("transcriptchange", this._transcript);
+				}
+				break;
+			}
+			case "transcript_end": {
+				if (this._transcript.length === 0) break;
+				const updated = [...this._transcript];
+				const last = updated[updated.length - 1];
+				if (last.role === "assistant") {
+					updated[updated.length - 1] = {
+						...last,
+						text: msg.text
+					};
+					this._transcript = updated;
+					this.emit("transcriptchange", this._transcript);
+				}
+				break;
+			}
+			case "metrics":
+				this._metrics = {
+					llm_ms: msg.llm_ms,
+					tts_ms: msg.tts_ms,
+					first_audio_ms: msg.first_audio_ms,
+					total_ms: msg.total_ms
+				};
+				this.emit("metricschange", this._metrics);
+				break;
+			case "error":
+				this._error = msg.message;
+				this.emit("error", this._error);
+				break;
+			default:
+				this._lastCustomMessage = msg;
+				this.emit("custommessage", msg);
+				break;
+		}
+	}
+	handleAudio(audio) {
+		if (this._audioFormat === "pcm16" || this._audioFormat === null) this.bridge.playAudio(audio);
+		else this.decodeAndPlay(audio);
+	}
+	async decodeAndPlay(audio) {
+		try {
+			if (!this.decodeContext) this.decodeContext = new AudioContext({ sampleRate: 16e3 });
+			const float32 = (await this.decodeContext.decodeAudioData(audio.slice(0))).getChannelData(0);
+			const int16 = new Int16Array(float32.length);
+			for (let i = 0; i < float32.length; i++) {
+				const s = Math.max(-1, Math.min(1, float32[i]));
+				int16[i] = s < 0 ? s * 32768 : s * 32767;
+			}
+			this.bridge.playAudio(int16.buffer);
+		} catch (err) {
+			if (!this.warnedFormat) {
+				this.warnedFormat = true;
+				console.warn(`[TelnyxPhoneClient] Failed to decode "${this._audioFormat}" audio:`, err);
+			}
+		}
+	}
+	processAudioLevel(rms) {
+		if (this._isMuted) return;
+		this._audioLevel = rms;
+		this.emit("audiolevelchange", rms);
+		if (this.isPlaying && rms > this.interruptThreshold) {
+			this.interruptChunkCount++;
+			if (this.interruptChunkCount >= this.interruptChunks) {
+				this.isPlaying = false;
+				this.interruptChunkCount = 0;
+				this.bridge.clearPlaybackBuffer();
+				if (this.transport.connected) this.transport.sendJSON({ type: "interrupt" });
+			}
+		} else this.interruptChunkCount = 0;
+		if (rms > this.silenceThreshold) {
+			if (!this.isSpeaking) {
+				this.isSpeaking = true;
+				if (this.transport.connected) this.transport.sendJSON({ type: "start_of_speech" });
+			}
+			if (this.silenceTimer) {
+				clearTimeout(this.silenceTimer);
+				this.silenceTimer = null;
+			}
+		} else if (this.isSpeaking) {
+			if (!this.silenceTimer) this.silenceTimer = setTimeout(() => {
+				this.isSpeaking = false;
+				this.silenceTimer = null;
+				if (this.transport.connected) this.transport.sendJSON({ type: "end_of_speech" });
+			}, this.silenceDurationMs);
+		}
+	}
+	resetDetection() {
+		if (this.silenceTimer) {
+			clearTimeout(this.silenceTimer);
+			this.silenceTimer = null;
+		}
+		this.isSpeaking = false;
+		this.interruptChunkCount = 0;
+		this._audioLevel = 0;
+		this.emit("audiolevelchange", 0);
+	}
+	trimTranscript() {
+		if (this._transcript.length > this.maxTranscriptMessages) this._transcript = this._transcript.slice(-this.maxTranscriptMessages);
+	}
+};
+//#endregion
+//#region src/transport/phone-transport.ts
+var TelnyxPhoneTransport = class {
+	constructor(config) {
+		this.audioFormat = null;
+		this.warnedFormat = false;
+		this.onopen = null;
+		this.onclose = null;
+		this.onerror = null;
+		this.onmessage = null;
+		this.inner = config.inner;
+		this.bridge = config.bridge;
+		this.userAudioCallback = config.onServerAudio;
+	}
+	get connected() {
+		return this.inner.connected;
+	}
+	sendJSON(data) {
+		this.inner.sendJSON(data);
+	}
+	sendBinary(data) {
+		this.inner.sendBinary(data);
+	}
+	connect() {
+		this.inner.onopen = () => this.onopen?.();
+		this.inner.onclose = () => this.onclose?.();
+		this.inner.onerror = (err) => this.onerror?.(err);
+		this.inner.onmessage = (data) => {
+			this.intercept(data);
+			this.onmessage?.(data);
+		};
+		this.inner.connect();
+	}
+	disconnect() {
+		this.inner.disconnect();
+	}
+	intercept(data) {
+		if (typeof data === "string") this.trackAudioConfig(data);
+		else if (data instanceof ArrayBuffer) this.routeAudio(data);
+		else if (data instanceof Blob) data.arrayBuffer().then((buf) => this.routeAudio(buf));
+	}
+	/** Parse audio_config messages to know what format the server is sending. */
+	trackAudioConfig(json) {
+		try {
+			const msg = JSON.parse(json);
+			if (msg.type === "audio_config" && msg.format) {
+				this.audioFormat = msg.format;
+				this.warnedFormat = false;
+			}
+		} catch {}
+	}
+	/** Fork audio to the bridge (pcm16 only) and optional user callback. */
+	routeAudio(audio) {
+		this.userAudioCallback?.(audio);
+		if (this.audioFormat === "pcm16" || this.audioFormat === null) this.bridge.playAudio(audio);
+		else if (this.audioFormat && !this.warnedFormat) {
+			this.warnedFormat = true;
+			console.warn(`[TelnyxPhoneTransport] Server audio format is "${this.audioFormat}". TelnyxCallBridge expects pcm16 (16kHz mono Int16 LE). Set audioFormat: "pcm16" in your server-side VoiceAgentOptions.`);
+		}
+	}
+};
+//#endregion
+//#region src/helpers/transport-config.ts
+/**
+* Factory helper that wires up JWT auth + TelnyxCallBridge
+* into a ready-to-use VoiceClient configuration.
+*
+* Usage:
+* ```typescript
+* import { createTelnyxVoiceConfig } from "@cloudflare/voice-telnyx/browser";
+* import { VoiceClient } from "@cloudflare/voice/client";
+*
+* const telnyx = await createTelnyxVoiceConfig({
+*   jwtEndpoint: "/api/telnyx-token",
+*   autoAnswer: true,
+* });
+*
+* const voiceClient = new VoiceClient({
+*   agent: "my-agent",
+*   audioInput: telnyx.audioInput,
+* });
+*
+* // Inject agent audio back into the phone call:
+* voiceClient.on("audio", (pcm) => telnyx.bridge.playAudio(pcm));
+*
+* // On disconnect, clean up server-side credential:
+* await telnyx.cleanup();
+* ```
+*/
+/**
+* Fetch a JWT from the server, create a TelnyxCallBridge, and return
+* everything needed to configure a VoiceClient for phone calls.
+*/
+async function createTelnyxVoiceConfig(options) {
+	const response = await fetch(options.jwtEndpoint, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" }
+	});
+	if (!response.ok) throw new Error(`Failed to fetch JWT: ${response.status}`);
+	const body = await response.json();
+	if (!body.token) throw new Error("JWT response missing token");
+	const credentialId = body.credentialId ?? "";
+	const sipUsername = body.sipUsername ?? "";
+	const bridge = new TelnyxCallBridge({
+		loginToken: body.token,
+		autoAnswer: options.autoAnswer,
+		debug: options.debug
+	});
+	const cleanup = async () => {
+		bridge.stop();
+		if (credentialId) {
+			const response = await fetch(options.jwtEndpoint, {
+				method: "DELETE",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ credentialId })
+			});
+			if (!response.ok) throw new Error(`Failed to revoke Telnyx credential: ${response.status}`);
+		}
+	};
+	return {
+		bridge,
+		audioInput: bridge,
+		credentialId,
+		sipUsername,
+		cleanup
+	};
+}
+//#endregion
+export { TelnyxCallBridge, TelnyxPhoneClient, TelnyxPhoneTransport, createTelnyxVoiceConfig };
+
+//# sourceMappingURL=browser.js.map