realtime-voice-agents 2.0.0

package/dist/transcode-C9aJG7_W.cjs

@@ -0,0 +1,215 @@
+const require_mulaw = require("./mulaw-DLUObjdP.cjs");
+//#region src/audio/resampler.ts
+function gcd(a, b) {
+	while (b !== 0) [a, b] = [b, a % b];
+	return a;
+}
+/** Modified Bessel function of the first kind, order zero (series expansion). */
+function besselI0(x) {
+	let sum = 1;
+	let term = 1;
+	for (let k = 1; k < 50; k++) {
+		term *= (x / (2 * k)) ** 2;
+		sum += term;
+		if (term < sum * 1e-12) break;
+	}
+	return sum;
+}
+const bankCache = /* @__PURE__ */ new Map();
+function designBank(L, M, opts) {
+	const key = `${L}/${M}/${opts.quality}/${opts.kaiserBeta}/${opts.rolloff}`;
+	const cached = bankCache.get(key);
+	if (cached) return cached;
+	let n = opts.quality * Math.max(L, M);
+	n = Math.ceil(n / L) * L;
+	const fc = opts.rolloff * .5 / Math.max(L, M);
+	const center = (n - 1) / 2;
+	const denom = besselI0(opts.kaiserBeta);
+	const proto = new Float64Array(n);
+	for (let i = 0; i < n; i++) {
+		const x = i - center;
+		const sinc = x === 0 ? 2 * fc : Math.sin(2 * Math.PI * fc * x) / (Math.PI * x);
+		const r = 2 * i / (n - 1) - 1;
+		const window = besselI0(opts.kaiserBeta * Math.sqrt(1 - r * r)) / denom;
+		proto[i] = sinc * window;
+	}
+	const tapsPerPhase = n / L;
+	const phases = [];
+	for (let p = 0; p < L; p++) {
+		const phase = new Float64Array(tapsPerPhase);
+		let sum = 0;
+		for (let t = 0; t < tapsPerPhase; t++) {
+			phase[t] = proto[p + t * L];
+			sum += phase[t];
+		}
+		if (sum !== 0) for (let t = 0; t < tapsPerPhase; t++) phase[t] /= sum;
+		phases.push(phase);
+	}
+	const bank = {
+		phases,
+		tapsPerPhase
+	};
+	bankCache.set(key, bank);
+	return bank;
+}
+var Resampler = class {
+	fromRate;
+	toRate;
+	L;
+	M;
+	bank;
+	/** Trailing input samples carried between chunks (tapsPerPhase − 1 long). */
+	hist;
+	/** Phase index of the next output sample. */
+	phase = 0;
+	/**
+	* Input index (relative to the start of the next [hist + chunk] buffer) that
+	* the next output sample is anchored on. Always ≥ tapsPerPhase − 1.
+	*/
+	kRel;
+	constructor(fromRate, toRate, options = {}) {
+		if (!Number.isInteger(fromRate) || !Number.isInteger(toRate) || fromRate <= 0 || toRate <= 0) throw new RangeError(`invalid sample rates: ${fromRate} -> ${toRate}`);
+		this.fromRate = fromRate;
+		this.toRate = toRate;
+		const g = gcd(fromRate, toRate);
+		this.L = toRate / g;
+		this.M = fromRate / g;
+		this.bank = designBank(this.L, this.M, {
+			quality: options.quality ?? 48,
+			kaiserBeta: options.kaiserBeta ?? 8,
+			rolloff: options.rolloff ?? .9
+		});
+		this.hist = new Int16Array(this.bank.tapsPerPhase - 1);
+		this.kRel = this.bank.tapsPerPhase - 1;
+	}
+	/** True when no rate conversion is needed (input is passed through). */
+	get isPassthrough() {
+		return this.L === 1 && this.M === 1;
+	}
+	process(input) {
+		if (this.isPassthrough) return input;
+		const { phases, tapsPerPhase } = this.bank;
+		const histLen = this.hist.length;
+		const buf = new Int16Array(histLen + input.length);
+		buf.set(this.hist, 0);
+		buf.set(input, histLen);
+		const maxOut = Math.ceil((buf.length - this.kRel) * this.L / this.M) + 1;
+		const out = new Int16Array(Math.max(maxOut, 0));
+		let produced = 0;
+		let k = this.kRel;
+		let p = this.phase;
+		while (k < buf.length) {
+			const coeffs = phases[p];
+			let acc = 0;
+			for (let t = 0; t < tapsPerPhase; t++) acc += coeffs[t] * buf[k - t];
+			let sample = Math.round(acc);
+			if (sample > 32767) sample = 32767;
+			else if (sample < -32768) sample = -32768;
+			out[produced++] = sample;
+			p += this.M;
+			k += p / this.L | 0;
+			p %= this.L;
+		}
+		const keepFrom = buf.length - histLen;
+		this.hist = buf.slice(keepFrom);
+		this.kRel = k - keepFrom;
+		this.phase = p;
+		return out.subarray(0, produced);
+	}
+	/** Drain the filter tail by pushing one phase-length of silence. */
+	flush() {
+		if (this.isPassthrough) return /* @__PURE__ */ new Int16Array(0);
+		return this.process(new Int16Array(this.bank.tapsPerPhase));
+	}
+	/** Clear all carried state (history, phase) for reuse on a fresh stream. */
+	reset() {
+		this.hist = new Int16Array(this.bank.tapsPerPhase - 1);
+		this.phase = 0;
+		this.kRel = this.bank.tapsPerPhase - 1;
+	}
+};
+//#endregion
+//#region src/audio/transcode.ts
+/**
+* Per-call transcoders between the Twilio wire format (base64 μ-law 8 kHz) and
+* provider PCM16 formats (Gemini: 16 kHz in, 24 kHz out).
+*
+* Both directions are stateful: the resampler carries FIR history across
+* chunks, and the outbound transcoder carries a dangling odd byte so PCM16
+* frames split mid-sample re-align instead of being truncated.
+*/
+const IS_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+function pcm16ToBufferLE(pcm) {
+	if (IS_LITTLE_ENDIAN) return Buffer.from(pcm.buffer, pcm.byteOffset, pcm.byteLength);
+	const buf = Buffer.allocUnsafe(pcm.length * 2);
+	for (let i = 0; i < pcm.length; i++) buf.writeInt16LE(pcm[i], i * 2);
+	return buf;
+}
+function bufferLEToPcm16(buf) {
+	const samples = buf.length >> 1;
+	if (IS_LITTLE_ENDIAN && buf.byteOffset % 2 === 0) return new Int16Array(buf.buffer, buf.byteOffset, samples);
+	const pcm = new Int16Array(samples);
+	for (let i = 0; i < samples; i++) pcm[i] = buf.readInt16LE(i * 2);
+	return pcm;
+}
+/** Twilio → provider: base64 μ-law 8 kHz in, base64 PCM16LE at `outRate` out. */
+var InboundTranscoder = class {
+	resampler;
+	constructor(outRate = 16e3, options) {
+		this.resampler = new Resampler(8e3, outRate, options);
+	}
+	process(base64Mulaw) {
+		const mulaw = Buffer.from(base64Mulaw, "base64");
+		const pcm = require_mulaw.mulawToPcm16(new Uint8Array(mulaw.buffer, mulaw.byteOffset, mulaw.length));
+		return pcm16ToBufferLE(this.resampler.process(pcm)).toString("base64");
+	}
+	reset() {
+		this.resampler.reset();
+	}
+};
+/** Provider → Twilio: base64 PCM16LE at `inRate` in, base64 μ-law 8 kHz out. */
+var OutboundTranscoder = class {
+	resampler;
+	/** Dangling byte from a chunk that split a 16-bit sample. */
+	carry = null;
+	constructor(inRate = 24e3, options) {
+		this.resampler = new Resampler(inRate, 8e3, options);
+	}
+	process(base64Pcm16) {
+		let buf = Buffer.from(base64Pcm16, "base64");
+		if (this.carry) {
+			buf = Buffer.concat([this.carry, buf]);
+			this.carry = null;
+		}
+		if (buf.length % 2 !== 0) {
+			this.carry = Buffer.from(buf.subarray(buf.length - 1));
+			buf = buf.subarray(0, buf.length - 1);
+		}
+		const pcm = bufferLEToPcm16(buf);
+		const resampled = this.resampler.process(pcm);
+		return Buffer.from(require_mulaw.pcm16ToMulaw(resampled)).toString("base64");
+	}
+	reset() {
+		this.resampler.reset();
+		this.carry = null;
+	}
+};
+//#endregion
+Object.defineProperty(exports, "InboundTranscoder", {
+	enumerable: true,
+	get: function() {
+		return InboundTranscoder;
+	}
+});
+Object.defineProperty(exports, "OutboundTranscoder", {
+	enumerable: true,
+	get: function() {
+		return OutboundTranscoder;
+	}
+});
+Object.defineProperty(exports, "Resampler", {
+	enumerable: true,
+	get: function() {
+		return Resampler;
+	}
+});

package/dist/transcode-CsAp97G9.mjs

@@ -0,0 +1,198 @@
+import { c as mulawToPcm16, l as pcm16ToMulaw } from "./mulaw--cwU2c9L.mjs";
+//#region src/audio/resampler.ts
+function gcd(a, b) {
+	while (b !== 0) [a, b] = [b, a % b];
+	return a;
+}
+/** Modified Bessel function of the first kind, order zero (series expansion). */
+function besselI0(x) {
+	let sum = 1;
+	let term = 1;
+	for (let k = 1; k < 50; k++) {
+		term *= (x / (2 * k)) ** 2;
+		sum += term;
+		if (term < sum * 1e-12) break;
+	}
+	return sum;
+}
+const bankCache = /* @__PURE__ */ new Map();
+function designBank(L, M, opts) {
+	const key = `${L}/${M}/${opts.quality}/${opts.kaiserBeta}/${opts.rolloff}`;
+	const cached = bankCache.get(key);
+	if (cached) return cached;
+	let n = opts.quality * Math.max(L, M);
+	n = Math.ceil(n / L) * L;
+	const fc = opts.rolloff * .5 / Math.max(L, M);
+	const center = (n - 1) / 2;
+	const denom = besselI0(opts.kaiserBeta);
+	const proto = new Float64Array(n);
+	for (let i = 0; i < n; i++) {
+		const x = i - center;
+		const sinc = x === 0 ? 2 * fc : Math.sin(2 * Math.PI * fc * x) / (Math.PI * x);
+		const r = 2 * i / (n - 1) - 1;
+		const window = besselI0(opts.kaiserBeta * Math.sqrt(1 - r * r)) / denom;
+		proto[i] = sinc * window;
+	}
+	const tapsPerPhase = n / L;
+	const phases = [];
+	for (let p = 0; p < L; p++) {
+		const phase = new Float64Array(tapsPerPhase);
+		let sum = 0;
+		for (let t = 0; t < tapsPerPhase; t++) {
+			phase[t] = proto[p + t * L];
+			sum += phase[t];
+		}
+		if (sum !== 0) for (let t = 0; t < tapsPerPhase; t++) phase[t] /= sum;
+		phases.push(phase);
+	}
+	const bank = {
+		phases,
+		tapsPerPhase
+	};
+	bankCache.set(key, bank);
+	return bank;
+}
+var Resampler = class {
+	fromRate;
+	toRate;
+	L;
+	M;
+	bank;
+	/** Trailing input samples carried between chunks (tapsPerPhase − 1 long). */
+	hist;
+	/** Phase index of the next output sample. */
+	phase = 0;
+	/**
+	* Input index (relative to the start of the next [hist + chunk] buffer) that
+	* the next output sample is anchored on. Always ≥ tapsPerPhase − 1.
+	*/
+	kRel;
+	constructor(fromRate, toRate, options = {}) {
+		if (!Number.isInteger(fromRate) || !Number.isInteger(toRate) || fromRate <= 0 || toRate <= 0) throw new RangeError(`invalid sample rates: ${fromRate} -> ${toRate}`);
+		this.fromRate = fromRate;
+		this.toRate = toRate;
+		const g = gcd(fromRate, toRate);
+		this.L = toRate / g;
+		this.M = fromRate / g;
+		this.bank = designBank(this.L, this.M, {
+			quality: options.quality ?? 48,
+			kaiserBeta: options.kaiserBeta ?? 8,
+			rolloff: options.rolloff ?? .9
+		});
+		this.hist = new Int16Array(this.bank.tapsPerPhase - 1);
+		this.kRel = this.bank.tapsPerPhase - 1;
+	}
+	/** True when no rate conversion is needed (input is passed through). */
+	get isPassthrough() {
+		return this.L === 1 && this.M === 1;
+	}
+	process(input) {
+		if (this.isPassthrough) return input;
+		const { phases, tapsPerPhase } = this.bank;
+		const histLen = this.hist.length;
+		const buf = new Int16Array(histLen + input.length);
+		buf.set(this.hist, 0);
+		buf.set(input, histLen);
+		const maxOut = Math.ceil((buf.length - this.kRel) * this.L / this.M) + 1;
+		const out = new Int16Array(Math.max(maxOut, 0));
+		let produced = 0;
+		let k = this.kRel;
+		let p = this.phase;
+		while (k < buf.length) {
+			const coeffs = phases[p];
+			let acc = 0;
+			for (let t = 0; t < tapsPerPhase; t++) acc += coeffs[t] * buf[k - t];
+			let sample = Math.round(acc);
+			if (sample > 32767) sample = 32767;
+			else if (sample < -32768) sample = -32768;
+			out[produced++] = sample;
+			p += this.M;
+			k += p / this.L | 0;
+			p %= this.L;
+		}
+		const keepFrom = buf.length - histLen;
+		this.hist = buf.slice(keepFrom);
+		this.kRel = k - keepFrom;
+		this.phase = p;
+		return out.subarray(0, produced);
+	}
+	/** Drain the filter tail by pushing one phase-length of silence. */
+	flush() {
+		if (this.isPassthrough) return /* @__PURE__ */ new Int16Array(0);
+		return this.process(new Int16Array(this.bank.tapsPerPhase));
+	}
+	/** Clear all carried state (history, phase) for reuse on a fresh stream. */
+	reset() {
+		this.hist = new Int16Array(this.bank.tapsPerPhase - 1);
+		this.phase = 0;
+		this.kRel = this.bank.tapsPerPhase - 1;
+	}
+};
+//#endregion
+//#region src/audio/transcode.ts
+/**
+* Per-call transcoders between the Twilio wire format (base64 μ-law 8 kHz) and
+* provider PCM16 formats (Gemini: 16 kHz in, 24 kHz out).
+*
+* Both directions are stateful: the resampler carries FIR history across
+* chunks, and the outbound transcoder carries a dangling odd byte so PCM16
+* frames split mid-sample re-align instead of being truncated.
+*/
+const IS_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+function pcm16ToBufferLE(pcm) {
+	if (IS_LITTLE_ENDIAN) return Buffer.from(pcm.buffer, pcm.byteOffset, pcm.byteLength);
+	const buf = Buffer.allocUnsafe(pcm.length * 2);
+	for (let i = 0; i < pcm.length; i++) buf.writeInt16LE(pcm[i], i * 2);
+	return buf;
+}
+function bufferLEToPcm16(buf) {
+	const samples = buf.length >> 1;
+	if (IS_LITTLE_ENDIAN && buf.byteOffset % 2 === 0) return new Int16Array(buf.buffer, buf.byteOffset, samples);
+	const pcm = new Int16Array(samples);
+	for (let i = 0; i < samples; i++) pcm[i] = buf.readInt16LE(i * 2);
+	return pcm;
+}
+/** Twilio → provider: base64 μ-law 8 kHz in, base64 PCM16LE at `outRate` out. */
+var InboundTranscoder = class {
+	resampler;
+	constructor(outRate = 16e3, options) {
+		this.resampler = new Resampler(8e3, outRate, options);
+	}
+	process(base64Mulaw) {
+		const mulaw = Buffer.from(base64Mulaw, "base64");
+		const pcm = mulawToPcm16(new Uint8Array(mulaw.buffer, mulaw.byteOffset, mulaw.length));
+		return pcm16ToBufferLE(this.resampler.process(pcm)).toString("base64");
+	}
+	reset() {
+		this.resampler.reset();
+	}
+};
+/** Provider → Twilio: base64 PCM16LE at `inRate` in, base64 μ-law 8 kHz out. */
+var OutboundTranscoder = class {
+	resampler;
+	/** Dangling byte from a chunk that split a 16-bit sample. */
+	carry = null;
+	constructor(inRate = 24e3, options) {
+		this.resampler = new Resampler(inRate, 8e3, options);
+	}
+	process(base64Pcm16) {
+		let buf = Buffer.from(base64Pcm16, "base64");
+		if (this.carry) {
+			buf = Buffer.concat([this.carry, buf]);
+			this.carry = null;
+		}
+		if (buf.length % 2 !== 0) {
+			this.carry = Buffer.from(buf.subarray(buf.length - 1));
+			buf = buf.subarray(0, buf.length - 1);
+		}
+		const pcm = bufferLEToPcm16(buf);
+		const resampled = this.resampler.process(pcm);
+		return Buffer.from(pcm16ToMulaw(resampled)).toString("base64");
+	}
+	reset() {
+		this.resampler.reset();
+		this.carry = null;
+	}
+};
+//#endregion
+export { OutboundTranscoder as n, Resampler as r, InboundTranscoder as t };

package/dist/transport-B_PJFIVd.d.cts

@@ -0,0 +1,155 @@
+import { t as TypedEmitter } from "./events-BUMYdETO.cjs";
+//#region src/twilio/messages.d.ts
+/**
+ * Twilio Media Streams wire messages.
+ * Reference: https://www.twilio.com/docs/voice/media-streams/websocket-messages
+ *
+ * Inbound (Twilio → server): connected, start, media, stop, mark, dtmf.
+ * Outbound (server → Twilio): media, mark, clear.
+ * All media payloads are base64 μ-law 8 kHz mono on `<Connect><Stream>` calls.
+ */
+interface TwilioConnectedEvent {
+  event: 'connected';
+  protocol?: string;
+  version?: string;
+}
+interface TwilioStartEvent {
+  event: 'start';
+  sequenceNumber?: string;
+  streamSid: string;
+  start: {
+    streamSid: string;
+    accountSid?: string;
+    callSid: string;
+    tracks?: string[];
+    mediaFormat?: {
+      encoding: string;
+      sampleRate: number;
+      channels: number;
+    };
+    /** `<Parameter name="…" value="…"/>` pairs from the TwiML `<Stream>`. */
+    customParameters?: Record<string, string>;
+  };
+}
+interface TwilioMediaEvent {
+  event: 'media';
+  sequenceNumber?: string;
+  streamSid: string;
+  media: {
+    track?: 'inbound' | 'outbound';
+    chunk?: string;
+    /** Milliseconds since stream start — the honest wall clock of the call. */
+    timestamp?: string;
+    /** Base64 μ-law audio. */
+    payload: string;
+  };
+}
+interface TwilioStopEvent {
+  event: 'stop';
+  sequenceNumber?: string;
+  streamSid: string;
+  stop?: {
+    accountSid?: string;
+    callSid?: string;
+  };
+}
+interface TwilioMarkEvent {
+  event: 'mark';
+  sequenceNumber?: string;
+  streamSid: string;
+  mark: {
+    name: string;
+  };
+}
+interface TwilioDtmfEvent {
+  event: 'dtmf';
+  streamSid: string;
+  sequenceNumber?: string;
+  dtmf: {
+    track?: string;
+    digit: string;
+  };
+}
+type TwilioInboundMessage = TwilioConnectedEvent | TwilioStartEvent | TwilioMediaEvent | TwilioStopEvent | TwilioMarkEvent | TwilioDtmfEvent;
+interface TwilioOutboundMedia {
+  event: 'media';
+  streamSid: string;
+  media: {
+    payload: string;
+  };
+}
+interface TwilioOutboundMark {
+  event: 'mark';
+  streamSid: string;
+  mark: {
+    name: string;
+  };
+}
+interface TwilioOutboundClear {
+  event: 'clear';
+  streamSid: string;
+}
+type TwilioOutboundMessage = TwilioOutboundMedia | TwilioOutboundMark | TwilioOutboundClear;
+/**
+ * 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).
+ */
+declare function parseTwilioMessage(raw: string | Buffer): TwilioInboundMessage | null;
+//#endregion
+//#region src/twilio/transport.d.ts
+/** Minimal ws-shaped socket. `ws`-package sockets satisfy this directly. */
+interface WebSocketLike {
+  send(data: string): void;
+  close(code?: number, reason?: string): void;
+  on(event: 'message', listener: (data: unknown, isBinary?: boolean) => void): unknown;
+  on(event: 'close', listener: (code?: number, reason?: unknown) => void): unknown;
+  on(event: 'error', listener: (error: Error) => void): unknown;
+  readyState?: number;
+}
+interface TransportEvents extends Record<string, (...args: any[]) => void> {
+  start: (event: TwilioStartEvent) => void;
+  media: (event: TwilioMediaEvent) => void;
+  stop: (event: TwilioStopEvent) => void;
+  mark: (event: TwilioMarkEvent) => void;
+  dtmf: (event: TwilioDtmfEvent) => void;
+  close: (info: {
+    code?: number;
+    reason?: string;
+  }) => void;
+  error: (error: Error) => void;
+}
+interface AwaitStartOptions {
+  /** Max time to wait for the `start` frame. Default 5000. */
+  timeoutMs?: number;
+  /** Max non-start frames tolerated before giving up. Default 8. */
+  maxPreStartMessages?: number;
+}
+declare class TwilioMediaTransport extends TypedEmitter<TransportEvents> {
+  private readonly ws;
+  private streamSidValue;
+  private startEvent;
+  private closed;
+  constructor(ws: WebSocketLike);
+  get streamSid(): string | null;
+  get start(): TwilioStartEvent | null;
+  get isOpen(): boolean;
+  /**
+   * 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?: AwaitStartOptions): Promise<TwilioStartEvent>;
+  /** Forward one media payload (base64 μ-law) to the caller. */
+  sendMedia(payload: string): void;
+  /** Interleave a named mark; Twilio echoes it once playout reaches it. */
+  sendMark(name: string): void;
+  /** Flush Twilio's playout buffer (barge-in). Pending marks echo back as discarded. */
+  sendClear(): void;
+  close(code?: number, reason?: string): void;
+  private handleMessage;
+  private requireStreamSid;
+  private sendRaw;
+}
+//#endregion
+export { TwilioConnectedEvent as a, TwilioMarkEvent as c, TwilioOutboundMark as d, TwilioOutboundMedia as f, parseTwilioMessage as g, TwilioStopEvent as h, WebSocketLike as i, TwilioMediaEvent as l, TwilioStartEvent as m, TransportEvents as n, TwilioDtmfEvent as o, TwilioOutboundMessage as p, TwilioMediaTransport as r, TwilioInboundMessage as s, AwaitStartOptions as t, TwilioOutboundClear as u };