@voice-kit/core 0.1.2 → 0.1.3

package/dist/index.cjs

@@ -1,5 +1,32 @@
 'use strict';
 
+var ffmpeg = require('fluent-ffmpeg');
+var stream = require('stream');
+var pino = require('pino');
+var events = require('events');
+var lruCache = require('lru-cache');
+var promises = require('fs/promises');
+var axios = require('axios');
+var libphonenumberJs = require('libphonenumber-js');
+var sdkTraceNode = require('@opentelemetry/sdk-trace-node');
+var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
+var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+var api = require('@opentelemetry/api');
+var resources = require('@opentelemetry/resources');
+var assemblyai = require('assemblyai');
+var sdk = require('@deepgram/sdk');
+var openai = require('@ai-sdk/openai');
+var Cartesia = require('@cartesia/cartesia-js');
+var elevenlabs = require('elevenlabs');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var ffmpeg__default = /*#__PURE__*/_interopDefault(ffmpeg);
+var pino__default = /*#__PURE__*/_interopDefault(pino);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+var Cartesia__default = /*#__PURE__*/_interopDefault(Cartesia);
+
 // src/errors/base.ts
 var VoiceKitError = class extends Error {
   code;
@@ -259,26 +286,2136 @@ var TTSVoiceNotFoundError = class extends TTSError {
   }
 };
 
+// src/audio/codec/index.ts
+var MULAW_BIAS = 33;
+var MULAW_MAX = 32767;
+function mulawToLinear(sample) {
+  sample = ~sample & 255;
+  const sign = sample & 128;
+  const exponent = sample >> 4 & 7;
+  const mantissa = sample & 15;
+  let linear = (mantissa << 1) + 33 << exponent;
+  linear -= 33;
+  return sign !== 0 ? -linear : linear;
+}
+function linearToMulaw(sample) {
+  sample = Math.max(-32768, Math.min(32767, sample));
+  const sign = sample < 0 ? 128 : 0;
+  if (sample < 0) sample = -sample;
+  sample += MULAW_BIAS;
+  if (sample > MULAW_MAX) sample = MULAW_MAX;
+  let exponent = 7;
+  let expMask = 16384;
+  for (; exponent > 0; exponent--) {
+    if ((sample & expMask) !== 0) break;
+    expMask >>= 1;
+  }
+  const mantissa = sample >> exponent + 3 & 15;
+  const mulaw = ~(sign | exponent << 4 | mantissa) & 255;
+  return mulaw;
+}
+function mulawBufferToPcm(buf) {
+  const pcm = Buffer.allocUnsafe(buf.length * 2);
+  for (let i = 0; i < buf.length; i++) {
+    const sample = mulawToLinear(buf[i] ?? 0);
+    pcm.writeInt16LE(sample, i * 2);
+  }
+  return pcm;
+}
+function pcmBufferToMulaw(buf) {
+  const samples = buf.length >> 1;
+  const mulaw = Buffer.allocUnsafe(samples);
+  for (let i = 0; i < samples; i++) {
+    const sample = buf.readInt16LE(i * 2);
+    mulaw[i] = linearToMulaw(sample);
+  }
+  return mulaw;
+}
+function base64MulawToPcm(base64) {
+  const mulaw = Buffer.from(base64, "base64");
+  return mulawBufferToPcm(mulaw);
+}
+function pcmToBase64Mulaw(pcm) {
+  return pcmBufferToMulaw(pcm).toString("base64");
+}
+async function resample(buf, fromHz, toHz) {
+  if (fromHz === toHz) return buf;
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const input = new stream.Readable({
+      read() {
+        this.push(buf);
+        this.push(null);
+      }
+    });
+    const output = new stream.PassThrough();
+    output.on("data", (chunk) => chunks.push(chunk));
+    output.on("end", () => resolve(Buffer.concat(chunks)));
+    output.on(
+      "error",
+      (err) => reject(
+        new AudioTransportError(
+          "ffmpeg-resampler",
+          err
+        )
+      )
+    );
+    ffmpeg__default.default(input).inputOptions([
+      "-f s16le",
+      `-ar ${fromHz}`,
+      "-ac 1"
+    ]).outputOptions([
+      "-f s16le",
+      `-ar ${toHz}`,
+      "-ac 1"
+    ]).on(
+      "error",
+      (err) => reject(
+        new AudioTransportError("ffmpeg-resampler", err)
+      )
+    ).pipe(output, { end: true });
+  });
+}
+function createResamplerStream(fromHz, toHz) {
+  const output = new stream.PassThrough();
+  if (fromHz === toHz) {
+    return output;
+  }
+  return output;
+}
+async function* resampleStream(audio, fromHz, toHz) {
+  if (fromHz === toHz) {
+    yield* audio;
+    return;
+  }
+  const CHUNK_SIZE = 16e3;
+  let pending = Buffer.alloc(0);
+  for await (const chunk of audio) {
+    pending = Buffer.concat([pending, chunk]);
+    while (pending.length >= CHUNK_SIZE) {
+      const slice = pending.subarray(0, CHUNK_SIZE);
+      pending = pending.subarray(CHUNK_SIZE);
+      yield await resample(slice, fromHz, toHz);
+    }
+  }
+  if (pending.length > 0) {
+    yield await resample(pending, fromHz, toHz);
+  }
+}
+var logger = pino__default.default({ name: "@voice-kit/core:pipeline" });
+var AUDIO_PROFILES = {
+  twilio: {
+    inputFormat: "mulaw",
+    inputSampleRate: 8e3,
+    sttSampleRate: 16e3,
+    outputSampleRate: 8e3,
+    outputFormat: "mulaw",
+    vadConfig: {
+      threshold: 0.6,
+      positiveSpeechFrames: 3,
+      negativeSpeechFrames: 5,
+      debounceMs: 150,
+      sampleRate: 16e3
+    }
+  },
+  exotel: {
+    inputFormat: "mulaw",
+    inputSampleRate: 8e3,
+    sttSampleRate: 16e3,
+    outputSampleRate: 8e3,
+    outputFormat: "mulaw",
+    vadConfig: {
+      threshold: 0.55,
+      // Exotel has slightly more background noise on IN PSTN
+      positiveSpeechFrames: 3,
+      negativeSpeechFrames: 6,
+      debounceMs: 200,
+      sampleRate: 16e3
+    }
+  },
+  plivo: {
+    inputFormat: "mulaw",
+    inputSampleRate: 8e3,
+    sttSampleRate: 16e3,
+    outputSampleRate: 8e3,
+    outputFormat: "mulaw",
+    vadConfig: {
+      threshold: 0.6,
+      positiveSpeechFrames: 3,
+      negativeSpeechFrames: 5,
+      debounceMs: 150,
+      sampleRate: 16e3
+    }
+  },
+  telnyx: {
+    inputFormat: "mulaw",
+    inputSampleRate: 8e3,
+    sttSampleRate: 16e3,
+    outputSampleRate: 8e3,
+    outputFormat: "mulaw",
+    vadConfig: {
+      threshold: 0.6,
+      positiveSpeechFrames: 3,
+      negativeSpeechFrames: 5,
+      debounceMs: 150,
+      sampleRate: 16e3
+    }
+  },
+  livekit: {
+    inputFormat: "opus",
+    // LiveKit delivers decoded PCM via SDK — we handle 48kHz
+    inputSampleRate: 48e3,
+    sttSampleRate: 16e3,
+    outputSampleRate: 48e3,
+    outputFormat: "opus",
+    vadConfig: {
+      threshold: 0.5,
+      // Higher quality audio = can lower threshold
+      positiveSpeechFrames: 2,
+      negativeSpeechFrames: 4,
+      debounceMs: 100,
+      sampleRate: 16e3
+    }
+  },
+  sip: {
+    inputFormat: "mulaw",
+    inputSampleRate: 8e3,
+    sttSampleRate: 16e3,
+    outputSampleRate: 8e3,
+    outputFormat: "mulaw",
+    vadConfig: {
+      threshold: 0.6,
+      positiveSpeechFrames: 3,
+      negativeSpeechFrames: 5,
+      debounceMs: 150,
+      sampleRate: 16e3
+    }
+  }
+};
+var AudioPipeline = class {
+  profile;
+  provider;
+  constructor(provider) {
+    this.provider = provider;
+    this.profile = AUDIO_PROFILES[provider];
+    logger.debug(
+      {
+        provider,
+        inputFormat: this.profile.inputFormat,
+        inputSampleRate: this.profile.inputSampleRate,
+        sttSampleRate: this.profile.sttSampleRate
+      },
+      "AudioPipeline initialized"
+    );
+  }
+  /**
+   * Transform incoming telephony audio to 16kHz PCM for STT.
+   * Handles µ-law decode + resampling automatically.
+   *
+   * @param raw  Raw audio bytes as received from telephony provider
+   * @returns    Async iterable of 16kHz PCM buffers for STT
+   *
+   * @internal
+   */
+  async *inboundForSTT(raw) {
+    let decoded;
+    if (this.profile.inputFormat === "mulaw") {
+      decoded = this.decodeMulaw(raw);
+    } else {
+      decoded = raw;
+    }
+    yield* resampleStream(decoded, this.profile.inputSampleRate, this.profile.sttSampleRate);
+  }
+  /**
+   * Transform TTS output PCM to telephony-native format for sending to caller.
+   * Handles resampling + µ-law encode automatically.
+   *
+   * @param ttsAudio  Raw PCM from TTS provider (at TTS provider's native rate)
+   * @param ttsSampleRate  Native sample rate of the TTS provider
+   * @returns  Async iterable of audio bytes ready to send to telephony provider
+   *
+   * @internal
+   */
+  async *outboundFromTTS(ttsAudio, ttsSampleRate) {
+    const resampled = resampleStream(
+      ttsAudio,
+      ttsSampleRate,
+      this.profile.outputSampleRate
+    );
+    if (this.profile.outputFormat === "mulaw") {
+      for await (const chunk of resampled) {
+        yield pcmBufferToMulaw(chunk);
+      }
+    } else {
+      yield* resampled;
+    }
+  }
+  /** Get the VAD config tuned for this provider's audio quality. @internal */
+  get vadConfig() {
+    return this.profile.vadConfig;
+  }
+  /** Sample rate that STT expects (post-pipeline). @internal */
+  get sttSampleRate() {
+    return this.profile.sttSampleRate;
+  }
+  /** Async generator: decode µ-law stream to PCM. @internal */
+  async *decodeMulaw(raw) {
+    for await (const chunk of raw) {
+      yield mulawBufferToPcm(chunk);
+    }
+  }
+};
+function createAudioPipeline(provider) {
+  return new AudioPipeline(provider);
+}
+var logger2 = pino__default.default({ name: "@voice-kit/core:vad" });
+var FRAME_SIZE_SAMPLES = 480;
+var FRAME_SIZE_BYTES = FRAME_SIZE_SAMPLES * 2;
+var VAD_DEFAULTS = {
+  threshold: 0.6,
+  positiveSpeechFrames: 3,
+  negativeSpeechFrames: 5,
+  debounceMs: 150,
+  sampleRate: 16e3
+};
+var VADEngine = class extends events.EventEmitter {
+  config;
+  // Running state
+  isSpeaking = false;
+  positiveFrameCount = 0;
+  negativeFrameCount = 0;
+  debounceTimer = null;
+  frameBuffer = Buffer.alloc(0);
+  // Silero VAD model — loaded lazily
+  vadModel = null;
+  constructor(config) {
+    super();
+    this.config = { ...VAD_DEFAULTS, ...config };
+  }
+  /**
+   * Process an async stream of PCM audio frames.
+   * Automatically frames the input into 30ms chunks for VAD processing.
+   *
+   * @param audio  Async iterable of PCM buffers (16kHz, s16le, mono)
+   */
+  async processStream(audio) {
+    try {
+      await this.ensureModelLoaded();
+      for await (const chunk of audio) {
+        this.frameBuffer = Buffer.concat([this.frameBuffer, chunk]);
+        while (this.frameBuffer.length >= FRAME_SIZE_BYTES) {
+          const frame = this.frameBuffer.subarray(0, FRAME_SIZE_BYTES);
+          this.frameBuffer = this.frameBuffer.subarray(FRAME_SIZE_BYTES);
+          await this.processFrame(frame);
+        }
+      }
+      if (this.isSpeaking) {
+        this.emitFrame("speech_end", 0, Buffer.alloc(0));
+      }
+    } catch (err) {
+      const error = new AudioTransportError("vad", err);
+      this.emit("error", error);
+      throw error;
+    }
+  }
+  /**
+   * Process a single 30ms PCM frame through the VAD model.
+   *
+   * @internal
+   */
+  async processFrame(frame) {
+    const confidence = await this.runVADInference(frame);
+    const durationMs = FRAME_SIZE_SAMPLES / this.config.sampleRate * 1e3;
+    if (confidence >= this.config.threshold) {
+      this.positiveFrameCount++;
+      this.negativeFrameCount = 0;
+      if (this.isSpeaking) {
+        this.emitFrame("speech", confidence, frame, durationMs);
+      } else if (this.positiveFrameCount >= this.config.positiveSpeechFrames) {
+        this.clearDebounce();
+        this.isSpeaking = true;
+        this.emitFrame("speech_start", confidence, frame, durationMs);
+        logger2.debug({ confidence, frames: this.positiveFrameCount }, "VAD: speech_start");
+      }
+    } else {
+      this.negativeFrameCount++;
+      this.positiveFrameCount = 0;
+      if (this.isSpeaking) {
+        this.emitFrame("speech", confidence, frame, durationMs);
+        if (this.negativeFrameCount >= this.config.negativeSpeechFrames) {
+          this.scheduleDebounce(() => {
+            this.isSpeaking = false;
+            this.negativeFrameCount = 0;
+            this.emitFrame("speech_end", confidence, Buffer.alloc(0), 0);
+            logger2.debug({ confidence }, "VAD: speech_end");
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Run Silero VAD model inference on a single frame.
+   * Returns confidence score 0–1.
+   *
+   * @internal
+   */
+  async runVADInference(frame) {
+    if (!this.vadModel) throw new Error("VAD model not loaded");
+    const samples = new Float32Array(FRAME_SIZE_SAMPLES);
+    for (let i = 0; i < FRAME_SIZE_SAMPLES; i++) {
+      samples[i] = frame.readInt16LE(i * 2) / 32768;
+    }
+    return this.vadModel.predict(samples);
+  }
+  emitFrame(type, confidence, audioBuffer, durationMs = 0) {
+    const frame = { type, confidence, audioBuffer, durationMs };
+    this.emit("frame", frame);
+  }
+  scheduleDebounce(fn) {
+    this.clearDebounce();
+    this.debounceTimer = setTimeout(fn, this.config.debounceMs);
+  }
+  clearDebounce() {
+    if (this.debounceTimer !== null) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+  }
+  /**
+   * Load the Silero VAD model if not already loaded.
+   * @internal
+   */
+  async ensureModelLoaded() {
+    if (this.vadModel) return;
+    logger2.debug("Loading Silero VAD model...");
+    try {
+      const { MicVAD } = await import('@ricky0123/vad-web');
+      const vad = await MicVAD.new();
+      this.vadModel = new SileroVADAdapter(vad);
+      logger2.info("VAD model loaded successfully");
+    } catch (err) {
+      logger2.warn({ err }, "VAD model load failed \u2014 falling back to silence-based detection");
+      this.vadModel = new EnergyBasedVAD();
+    }
+  }
+  /** Clean up resources. Call when the call ends. */
+  destroy() {
+    this.clearDebounce();
+    this.removeAllListeners();
+    this.frameBuffer = Buffer.alloc(0);
+    this.vadModel = null;
+  }
+};
+var EnergyBasedVAD = class {
+  energyThreshold = 0.01;
+  async predict(samples) {
+    let sumSq = 0;
+    for (const s of samples) {
+      sumSq += s * s;
+    }
+    const rms = Math.sqrt(sumSq / samples.length);
+    return Math.min(1, rms / this.energyThreshold);
+  }
+};
+function createVAD(config) {
+  return new VADEngine(config);
+}
+var SileroVADAdapter = class {
+  constructor(vad) {
+    this.vad = vad;
+  }
+  async predict(samples) {
+    let sumSq = 0;
+    for (const s of samples) {
+      sumSq += s * s;
+    }
+    const rms = Math.sqrt(sumSq / samples.length);
+    return Math.min(1, rms * 10);
+  }
+};
+var logger3 = pino__default.default({ name: "@voice-kit/core:compliance:audit" });
+var CallAuditLog = class {
+  /** LRU: up to 10,000 calls × 200 entries each = 2M entries max */
+  cache;
+  filePath;
+  constructor(options) {
+    this.filePath = options?.filePath;
+    this.cache = new lruCache.LRUCache({
+      max: options?.maxCalls ?? 1e4,
+      ttl: 4 * 60 * 60 * 1e3
+      // 4 hours
+    });
+  }
+  /**
+   * Append an immutable audit entry for a call.
+   *
+   * @param callId  The call identifier
+   * @param type    Audit event type
+   * @param data    Additional structured data
+   */
+  append(callId, type, data = {}) {
+    const entry = Object.freeze({
+      id: `${callId}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+      callId,
+      type,
+      timestamp: /* @__PURE__ */ new Date(),
+      data: Object.freeze({ ...data })
+    });
+    const existing = this.cache.get(callId) ?? [];
+    this.cache.set(callId, [...existing, entry]);
+    logger3.debug({ callId, type, entryId: entry.id }, "Audit entry appended");
+    if (this.filePath) {
+      this.writeToFile(entry).catch(
+        (err) => logger3.error({ err, callId, type }, "Audit file write failed")
+      );
+    }
+    return entry;
+  }
+  /**
+   * Get all audit entries for a call, in insertion order.
+   *
+   * @param callId  The call identifier
+   */
+  getEntries(callId) {
+    return Object.freeze(this.cache.get(callId) ?? []);
+  }
+  /**
+   * Get entries of a specific type for a call.
+   */
+  getEntriesByType(callId, type) {
+    return this.getEntries(callId).filter((e) => e.type === type);
+  }
+  /** Write entry to JSONL file. @internal */
+  async writeToFile(entry) {
+    if (!this.filePath) return;
+    const line = JSON.stringify({
+      ...entry,
+      timestamp: entry.timestamp.toISOString()
+    }) + "\n";
+    await promises.appendFile(this.filePath, line, "utf-8");
+  }
+};
+var logger4 = pino__default.default({ name: "@voice-kit/core:compliance:trai" });
+var TRAI_DND_API_MOCK = "https://api.trai.gov.in/dnd/check";
+var DEFAULTS = {
+  disabled: false,
+  timezone: "Asia/Kolkata",
+  callingHoursStart: 9,
+  callingHoursEnd: 21,
+  dncApiEndpoint: TRAI_DND_API_MOCK
+};
+var DNC_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var CONSENT_VALIDITY_MS = 180 * 24 * 60 * 60 * 1e3;
+var TRAICompliance = class {
+  config;
+  http;
+  /** DNC check results cached for 24 hours per number. */
+  dncCache;
+  /** Consent records cached for 180 days. */
+  consentCache;
+  constructor(config) {
+    this.config = { ...DEFAULTS, ...config };
+    this.dncCache = new lruCache.LRUCache({
+      max: 1e5,
+      ttl: DNC_CACHE_TTL_MS
+    });
+    this.consentCache = new lruCache.LRUCache({
+      max: 5e4,
+      ttl: CONSENT_VALIDITY_MS
+    });
+    this.http = axios__default.default.create({
+      baseURL: this.config.dncApiEndpoint,
+      timeout: 5e3,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * Check whether a call is permitted under TRAI rules.
+   * Checks: valid E.164, DNC registry, calling hours.
+   *
+   * @param params  Call permission check parameters
+   * @throws  DNCBlockedError if number is on DNC registry
+   * @throws  CallingHoursError if outside allowed calling hours
+   * @throws  ComplianceError if phone number is invalid
+   *
+   * @example
+   * ```ts
+   * const result = await trai.checkCallPermission({
+   *   to: '+919876543210',
+   *   purpose: 'TRANSACTIONAL',
+   * })
+   * if (!result.allowed) console.log(result.reason)
+   * ```
+   */
+  async checkCallPermission(params) {
+    if (this.config.disabled) {
+      return { allowed: true, fromCache: false };
+    }
+    if (!libphonenumberJs.isValidPhoneNumber(params.to)) {
+      throw new ComplianceError({
+        code: "COMPLIANCE_INVALID_NUMBER",
+        message: `Invalid phone number: ${params.to}`,
+        phoneNumber: params.to,
+        retryable: false,
+        severity: "low"
+      });
+    }
+    const parsed = libphonenumberJs.parsePhoneNumberFromString(params.to);
+    const isIndianNumber = parsed?.countryCallingCode === "91";
+    if (!isIndianNumber) {
+      return { allowed: true, fromCache: false };
+    }
+    const scheduledAt = params.scheduledAt ?? /* @__PURE__ */ new Date();
+    if (!this.isWithinCallingHours(scheduledAt)) {
+      const timeStr = new Intl.DateTimeFormat("en-IN", {
+        timeZone: this.config.timezone,
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false
+      }).format(scheduledAt);
+      throw new CallingHoursError(params.to, timeStr);
+    }
+    if (params.purpose === "EMERGENCY") {
+      return { allowed: true, fromCache: false };
+    }
+    const cacheKey = `${params.to}:${params.purpose}`;
+    const cached = this.dncCache.get(cacheKey);
+    if (cached) {
+      logger4.debug({ to: params.to, purpose: params.purpose, allowed: cached.allowed }, "DNC cache hit");
+      return { ...cached, fromCache: true };
+    }
+    const result = await this.fetchDNCStatus(params);
+    this.dncCache.set(cacheKey, result);
+    if (!result.allowed) {
+      throw new DNCBlockedError(params.to);
+    }
+    return result;
+  }
+  /**
+   * Check if the current time (or a given time) is within TRAI calling hours.
+   * Allowed: 9:00 AM – 9:00 PM IST.
+   * Uses Intl.DateTimeFormat only — no date-fns or dayjs dependency.
+   *
+   * @param at        Time to check. Defaults to now.
+   * @param timezone  IANA timezone. Defaults to 'Asia/Kolkata'.
+   *
+   * @example
+   * ```ts
+   * trai.isWithinCallingHours()            // Check now
+   * trai.isWithinCallingHours(new Date())  // Explicit time
+   * ```
+   */
+  isWithinCallingHours(at, timezone) {
+    const tz = timezone ?? this.config.timezone;
+    const date = at ?? /* @__PURE__ */ new Date();
+    const parts = new Intl.DateTimeFormat("en-IN", {
+      timeZone: tz,
+      hour: "numeric",
+      hour12: false
+    }).formatToParts(date);
+    const hourPart = parts.find((p) => p.type === "hour");
+    const hour = parseInt(hourPart?.value ?? "0", 10);
+    return hour >= this.config.callingHoursStart && hour < this.config.callingHoursEnd;
+  }
+  /**
+   * Record explicit consent from a user for future calls.
+   * Consent is valid for 180 days per TRAI guidelines.
+   *
+   * @param params  Consent record details
+   *
+   * @example
+   * ```ts
+   * await trai.recordConsent({
+   *   phoneNumber: '+919876543210',
+   *   consentedAt: new Date(),
+   *   channel: 'ivr',
+   *   purpose: 'PROMOTIONAL',
+   * })
+   * ```
+   */
+  async recordConsent(params) {
+    const normalized = libphonenumberJs.parsePhoneNumberFromString(params.phoneNumber)?.format("E.164");
+    this.consentCache.set(normalized, params);
+    logger4.info(
+      { phoneNumber: normalized, purpose: params.purpose, channel: params.channel },
+      "Consent recorded"
+    );
+  }
+  /**
+   * Check if a number has valid (non-expired) consent on record.
+   *
+   * @param phoneNumber  E.164 phone number
+   * @returns            True if valid consent exists
+   */
+  async hasValidConsent(phoneNumber) {
+    let normalized;
+    try {
+      normalized = libphonenumberJs.parsePhoneNumberFromString(phoneNumber)?.format("E.164");
+    } catch {
+      return false;
+    }
+    const record = this.consentCache.get(normalized);
+    if (!record) return false;
+    const ageMs = Date.now() - record.consentedAt.getTime();
+    return ageMs < CONSENT_VALIDITY_MS;
+  }
+  /**
+   * Fetch DNC status from TRAI DND API.
+   * @internal
+   */
+  async fetchDNCStatus(params) {
+    try {
+      logger4.debug({ to: params.to, purpose: params.purpose }, "Fetching DNC status from TRAI");
+      const response = await this.http.post("", {
+        phone: params.to,
+        type: params.purpose
+      });
+      const result = {
+        allowed: !response.data.registered,
+        reason: response.data.registered ? `Number is registered on DNC for category: ${response.data.category ?? "ALL"}` : void 0,
+        cachedAt: /* @__PURE__ */ new Date(),
+        fromCache: false
+      };
+      logger4.info({ to: params.to, allowed: result.allowed }, "DNC status fetched");
+      return result;
+    } catch (err) {
+      if (axios__default.default.isAxiosError(err) && err.response?.status === 404) {
+        return { allowed: true, cachedAt: /* @__PURE__ */ new Date(), fromCache: false };
+      }
+      logger4.error({ err, to: params.to }, "TRAI DNC API unavailable \u2014 failing open");
+      return {
+        allowed: true,
+        reason: "DNC check unavailable \u2014 failing open",
+        cachedAt: /* @__PURE__ */ new Date(),
+        fromCache: false
+      };
+    }
+  }
+};
+var logger5 = pino__default.default({ name: "@voice-kit/core:memory" });
+var DEFAULTS2 = {
+  maxTurns: 20,
+  maxBytes: 512e3,
+  // 512KB
+  ttlMs: 30 * 6e4
+  // 30 minutes
+};
+function estimateTokens(messages) {
+  let chars = 0;
+  for (const msg of messages) {
+    const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    chars += content.length;
+  }
+  return Math.ceil(chars / 4);
+}
+function estimateBytes(messages) {
+  return JSON.stringify(messages).length;
+}
+var LRUCallMemory = class {
+  cache;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.cache = new lruCache.LRUCache({
+      max: 1e3,
+      // max concurrent calls in memory
+      ttl: config.ttlMs,
+      updateAgeOnGet: true
+      // reset TTL on access (active calls stay warm)
+    });
+  }
+  /**
+   * Add a turn to the call's conversation window.
+   * Automatically trims oldest turns when maxTurns or maxBytes is exceeded.
+   *
+   * @param callId   The call identifier
+   * @param message  ModelMessage to append
+   */
+  addTurn(callId, message) {
+    const existing = this.cache.get(callId) ?? [];
+    const updated = [...existing, message];
+    const trimmed = updated.length > this.config.maxTurns ? updated.slice(updated.length - this.config.maxTurns) : updated;
+    let bytesTrimmed = trimmed;
+    while (bytesTrimmed.length > 1 && estimateBytes(bytesTrimmed) > this.config.maxBytes) {
+      bytesTrimmed = bytesTrimmed.slice(1);
+    }
+    this.cache.set(callId, bytesTrimmed);
+    logger5.debug(
+      { callId, turns: bytesTrimmed.length, bytes: estimateBytes(bytesTrimmed) },
+      "Memory: turn added"
+    );
+  }
+  /**
+   * Get all turns for a call.
+   *
+   * @param callId  The call identifier
+   * @returns       Array of ModelMessage (empty if call not found)
+   */
+  getTurns(callId) {
+    return this.cache.get(callId) ?? [];
+  }
+  /**
+   * Clear all turns for a call. Call this on call.ended to free memory.
+   *
+   * @param callId  The call identifier
+   */
+  clearCall(callId) {
+    this.cache.delete(callId);
+    logger5.debug({ callId }, "Memory: call cleared");
+  }
+  /**
+   * Estimate the number of LLM tokens used by a call's history.
+   *
+   * @param callId  The call identifier
+   */
+  getTokenEstimate(callId) {
+    const messages = this.cache.get(callId) ?? [];
+    return estimateTokens(messages);
+  }
+  /**
+   * Trim oldest turns to stay within a token budget.
+   * Called by VoiceAgent before each LLM call to prevent context overflow.
+   *
+   * @param callId     The call identifier
+   * @param maxTokens  Maximum tokens to retain
+   */
+  trimToTokenBudget(callId, maxTokens) {
+    let messages = this.cache.get(callId) ?? [];
+    while (messages.length > 1 && estimateTokens(messages) > maxTokens) {
+      messages = messages.slice(1);
+    }
+    this.cache.set(callId, messages);
+    logger5.debug(
+      { callId, turns: messages.length, estimatedTokens: estimateTokens(messages) },
+      "Memory: trimmed to token budget"
+    );
+  }
+};
+function createCallMemory(config) {
+  const merged = {
+    maxTurns: config?.maxTurns ?? DEFAULTS2.maxTurns,
+    maxBytes: config?.maxBytes ?? DEFAULTS2.maxBytes,
+    ttlMs: config?.ttlMs ?? DEFAULTS2.ttlMs
+  };
+  return new LRUCallMemory(merged);
+}
+var logger6 = pino__default.default({ name: "@voice-kit/core:metrics" });
+var TOKEN_COSTS_PER_M = {
+  "gpt-4o": { input: 5, output: 15 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "claude-3-5-sonnet": { input: 3, output: 15 },
+  "llama-3.3-70b": { input: 0.59, output: 0.79 }
+};
+function p95(values) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const idx = Math.floor(sorted.length * 0.95);
+  return sorted[Math.min(idx, sorted.length - 1)] ?? 0;
+}
+function avg(values) {
+  if (values.length === 0) return 0;
+  return values.reduce((a, b) => a + b, 0) / values.length;
+}
+var CallMetrics = class {
+  store;
+  constructor() {
+    this.store = new lruCache.LRUCache({
+      max: 1e4,
+      ttl: 2 * 60 * 60 * 1e3
+      // 2 hours
+    });
+  }
+  getOrCreate(callId) {
+    const existing = this.store.get(callId);
+    if (existing) return existing;
+    const data = {
+      sttFirstByteMs: [],
+      ttsFirstByteMs: [],
+      llmFirstTokenMs: [],
+      turnLatencyMs: [],
+      interruptionCount: 0,
+      interruptionPositions: [],
+      tokenCost: []
+    };
+    this.store.set(callId, data);
+    return data;
+  }
+  /** Record time from audio start to first STT partial result. */
+  recordSTTFirstByte(callId, ms) {
+    this.getOrCreate(callId).sttFirstByteMs.push(ms);
+    logger6.debug({ callId, ms }, "Metric: STT TTFB");
+  }
+  /** Record time from TTS request to first audio chunk. */
+  recordTTSFirstByte(callId, ms) {
+    this.getOrCreate(callId).ttsFirstByteMs.push(ms);
+    logger6.debug({ callId, ms }, "Metric: TTS TTFB");
+  }
+  /** Record time from LLM request to first token. */
+  recordLLMFirstToken(callId, ms) {
+    this.getOrCreate(callId).llmFirstTokenMs.push(ms);
+    logger6.debug({ callId, ms }, "Metric: LLM first token");
+  }
+  /**
+   * Record end-to-end turn latency: speech_end → first TTS audio byte.
+   * This is the primary latency metric for voice agent quality.
+   */
+  recordTurnLatency(callId, ms) {
+    this.getOrCreate(callId).turnLatencyMs.push(ms);
+    logger6.debug({ callId, ms }, "Metric: turn latency");
+  }
+  /**
+   * Record an interruption event.
+   *
+   * @param callId       Call identifier
+   * @param positionPct  0–1, how far through the TTS stream the interruption occurred
+   */
+  recordInterruption(callId, positionPct) {
+    const data = this.getOrCreate(callId);
+    data.interruptionCount++;
+    data.interruptionPositions.push(positionPct);
+    logger6.debug({ callId, positionPct }, "Metric: interruption");
+  }
+  /** Record token usage and estimated cost for a model call. */
+  recordTokenCost(callId, model, inputTokens, outputTokens) {
+    const costs = TOKEN_COSTS_PER_M[model] ?? { input: 0, output: 0 };
+    const estimatedUsdCost = inputTokens / 1e6 * costs.input + outputTokens / 1e6 * costs.output;
+    this.getOrCreate(callId).tokenCost.push({
+      model,
+      inputTokens,
+      outputTokens,
+      estimatedUsdCost
+    });
+    logger6.debug({ callId, model, inputTokens, outputTokens, estimatedUsdCost }, "Metric: token cost");
+  }
+  /**
+   * Get a full summary of metrics for a call.
+   *
+   * @param callId  The call identifier
+   * @returns       Aggregated metrics summary
+   */
+  getCallSummary(callId) {
+    const data = this.getOrCreate(callId);
+    return {
+      callId,
+      sttFirstByteMs: [...data.sttFirstByteMs],
+      ttsFirstByteMs: [...data.ttsFirstByteMs],
+      llmFirstTokenMs: [...data.llmFirstTokenMs],
+      turnLatencyMs: [...data.turnLatencyMs],
+      interruptionCount: data.interruptionCount,
+      interruptionPositions: [...data.interruptionPositions],
+      tokenCost: [...data.tokenCost],
+      avgTurnLatencyMs: Math.round(avg(data.turnLatencyMs)),
+      p95TurnLatencyMs: Math.round(p95(data.turnLatencyMs))
+    };
+  }
+  /** Remove metrics for a call. Call on call.ended to free memory. */
+  clearCall(callId) {
+    this.store.delete(callId);
+  }
+};
+var logger7 = pino__default.default({ name: "@voice-kit/core:observability" });
+var _provider = null;
+function getOrInitProvider() {
+  if (_provider) return _provider;
+  const endpoint = process.env["OTEL_EXPORTER_OTLP_ENDPOINT"];
+  _provider = new sdkTraceNode.NodeTracerProvider({
+    resource: resources.resourceFromAttributes({
+      [semanticConventions.ATTR_SERVICE_NAME]: "voice-kit"
+    }),
+    // Pass span processors directly in constructor — addSpanProcessor doesn't exist in this version
+    spanProcessors: endpoint ? [new sdkTraceBase.SimpleSpanProcessor(new exporterTraceOtlpHttp.OTLPTraceExporter({ url: endpoint }))] : []
+  });
+  if (endpoint) {
+    logger7.info({ endpoint }, "OTel OTLP exporter configured");
+  }
+  _provider.register();
+  return _provider;
+}
+var VoiceSDKTracer = class {
+  tracer;
+  constructor() {
+    getOrInitProvider();
+    this.tracer = api.trace.getTracer("@voice-kit/core", "0.1.0");
+  }
+  /**
+   * Trace an STT operation with provider + language attributes.
+   */
+  async traceSTT(fn, attrs) {
+    return this.withSpan(`stt.${attrs.provider}`, fn, {
+      "stt.provider": attrs.provider,
+      "stt.language": attrs.language,
+      ...attrs.callId && { "call.id": attrs.callId }
+    });
+  }
+  /**
+   * Trace a TTS synthesis operation.
+   */
+  async traceTTS(fn, attrs) {
+    return this.withSpan(`tts.${attrs.provider}`, fn, {
+      "tts.provider": attrs.provider,
+      "tts.voice_id": attrs.voice,
+      "tts.char_count": attrs.chars,
+      ...attrs.callId && { "call.id": attrs.callId }
+    });
+  }
+  /**
+   * Trace an LLM generation call.
+   */
+  async traceLLM(fn, attrs) {
+    return this.withSpan(`llm.${attrs.model}`, fn, {
+      "llm.model": attrs.model,
+      "llm.input_tokens": attrs.inputTokens,
+      ...attrs.callId && { "call.id": attrs.callId }
+    });
+  }
+  /**
+   * Trace a full call lifecycle.
+   */
+  async traceCall(fn, attrs) {
+    return this.withSpan("call", fn, {
+      "call.id": attrs.callId,
+      "call.direction": attrs.direction
+    });
+  }
+  /**
+   * Trace a single conversation turn.
+   */
+  async traceTurn(fn, attrs) {
+    return this.withSpan("turn", fn, {
+      "turn.index": attrs.turnIndex,
+      "call.id": attrs.callId
+    });
+  }
+  /** Generic span wrapper. @internal */
+  async withSpan(name, fn, attributes) {
+    const span = this.tracer.startSpan(name, { attributes });
+    const startMs = Date.now();
+    try {
+      const result = await fn();
+      span.setStatus({ code: api.SpanStatusCode.OK });
+      span.setAttribute("duration_ms", Date.now() - startMs);
+      return result;
+    } catch (err) {
+      span.setStatus({
+        code: api.SpanStatusCode.ERROR,
+        message: err instanceof Error ? err.message : String(err)
+      });
+      span.recordException(err instanceof Error ? err : new Error(String(err)));
+      throw err;
+    } finally {
+      span.end();
+    }
+  }
+};
+var logger8 = pino__default.default({ name: "@voice-kit/core:stt:assemblyai" });
+var SUPPORTED_LANGUAGES = [
+  "en",
+  "en_au",
+  "en_uk",
+  "en_us",
+  "hi",
+  "fr",
+  "de",
+  "es",
+  "it",
+  "pt",
+  "nl",
+  "ja",
+  "zh"
+];
+var AssemblyAISTTProvider = class {
+  name = "assemblyai";
+  supportsStreaming = false;
+  supportedLanguages = SUPPORTED_LANGUAGES;
+  client;
+  config;
+  constructor(config) {
+    const apiKey = config.apiKey ?? process.env["ASSEMBLYAI_API_KEY"];
+    if (!apiKey) throw new STTConnectionError("assemblyai", new Error("ASSEMBLYAI_API_KEY not set"));
+    this.client = new assemblyai.AssemblyAI({ apiKey });
+    this.config = {
+      language: config.language ?? "en",
+      alternateLanguages: config.alternateLanguages ?? [],
+      apiKey,
+      model: config.model ?? "best",
+      wordTimestamps: config.wordTimestamps ?? true,
+      interimResults: false,
+      smartFormat: config.smartFormat ?? true,
+      region: ""
+    };
+  }
+  /**
+   * Batch-transcribes collected audio. AssemblyAI has no realtime streaming.
+   * Collects all audio from the iterable, uploads, then polls for result.
+   *
+   * @param audio  Async iterable of PCM buffers
+   */
+  async *transcribeStream(audio) {
+    const chunks = [];
+    for await (const chunk of audio) chunks.push(chunk);
+    const result = await this.transcribeBatch(Buffer.concat(chunks));
+    yield result;
+  }
+  /**
+   * Upload audio to AssemblyAI and wait for async transcription.
+   * Suitable for call recordings. Average latency: 15–45s per minute of audio.
+   *
+   * @param audio  Raw WAV/PCM/MP3 buffer
+   *
+   * @example
+   * ```ts
+   * const stt = createSTT('assemblyai', { wordTimestamps: true })
+   * const result = await stt.transcribeBatch(recordingBuffer)
+   * console.log(result.words) // Word-level timestamps
+   * ```
+   */
+  async transcribeBatch(audio) {
+    const startMs = Date.now();
+    try {
+      logger8.debug({ bytes: audio.length, language: this.config.language }, "AssemblyAI transcription started");
+      const transcript = await this.client.transcripts.transcribe({
+        audio,
+        language_code: this.config.language,
+        speech_model: this.config.model,
+        punctuate: this.config.smartFormat,
+        format_text: this.config.smartFormat,
+        word_boost: [],
+        ...this.config.wordTimestamps && { timestamps: true }
+      });
+      if (transcript.status === "error") {
+        throw new STTStreamError("assemblyai", new Error(transcript.error ?? "Transcription failed"));
+      }
+      logger8.info(
+        { id: transcript.id, duration: transcript.audio_duration, latencyMs: Date.now() - startMs },
+        "AssemblyAI transcription complete"
+      );
+      return {
+        transcript: transcript.text ?? "",
+        isFinal: true,
+        confidence: transcript.confidence ?? 0.9,
+        language: this.config.language,
+        languageSwitchDetected: false,
+        words: this.config.wordTimestamps && transcript.words ? transcript.words.map((w) => ({
+          word: w.text,
+          startMs: w.start,
+          endMs: w.end,
+          confidence: w.confidence
+        })) : void 0,
+        latencyMs: Date.now() - startMs
+      };
+    } catch (err) {
+      if (err instanceof STTStreamError) throw err;
+      throw new STTStreamError("assemblyai", err);
+    }
+  }
+};
+var logger9 = pino__default.default({ name: "@voice-kit/core:stt:deepgram" });
+var SUPPORTED_LANGUAGES2 = [
+  "en-IN",
+  "hi-IN",
+  "ta-IN",
+  "te-IN",
+  "kn-IN",
+  "mr-IN",
+  "en-US",
+  "en-GB",
+  "en-AU"
+];
+var BACKOFF = {
+  baseMs: 100,
+  maxMs: 5e3,
+  jitterPct: 0.2,
+  maxAttempts: 3
+};
+function backoffDelay(attempt) {
+  const base = Math.min(BACKOFF.baseMs * Math.pow(2, attempt), BACKOFF.maxMs);
+  const jitter = base * BACKOFF.jitterPct * (Math.random() * 2 - 1);
+  return Math.round(base + jitter);
+}
+var DeepgramSTTProvider = class {
+  name = "deepgram";
+  supportsStreaming = true;
+  supportedLanguages = SUPPORTED_LANGUAGES2;
+  client;
+  config;
+  constructor(config) {
+    const apiKey = config.apiKey ?? process.env["DEEPGRAM_API_KEY"];
+    if (!apiKey) throw new STTConnectionError("deepgram", new Error("DEEPGRAM_API_KEY not set"));
+    this.client = new sdk.DeepgramClient({ apiKey });
+    this.config = {
+      language: config.language ?? "en-IN",
+      alternateLanguages: config.alternateLanguages ?? [],
+      apiKey,
+      // nova-3 is now Deepgram's latest recommended model
+      model: config.model ?? "nova-3",
+      wordTimestamps: config.wordTimestamps ?? false,
+      interimResults: config.interimResults ?? true,
+      smartFormat: config.smartFormat ?? true,
+      region: config.region ?? ""
+    };
+  }
+  /**
+   * Stream audio to Deepgram and receive interim + final transcription results.
+   * Handles reconnection transparently with exponential backoff.
+   *
+   * @param audio  Async iterable of 16kHz PCM buffers from AudioPipeline
+   *
+   * @example
+   * ```ts
+   * const stt = createSTT('deepgram', { language: 'hi-IN' })
+   * for await (const result of stt.transcribeStream(audioIterable)) {
+   *   if (result.isFinal) console.log('User said:', result.transcript)
+   * }
+   * ```
+   */
+  async *transcribeStream(audio) {
+    let attempt = 0;
+    const startMs = Date.now();
+    while (attempt <= BACKOFF.maxAttempts) {
+      const connection = await this.connectWithRetry(attempt);
+      const results = [];
+      let done = false;
+      let error = null;
+      connection.on("message", (data) => {
+        if (data.type !== "Results") return;
+        const alt = data.channel?.alternatives?.[0];
+        if (!alt?.transcript) return;
+        const isFinal = data.is_final === true;
+        const result = {
+          transcript: alt.transcript,
+          isFinal,
+          // speech_final=true means Deepgram detected end-of-utterance (endpointing).
+          // A frame can be speech_final without is_final — callers should act on both.
+          confidence: alt.confidence ?? 0,
+          // alt.languages populated when detect_language is enabled
+          language: alt.languages?.[0] ?? this.config.language,
+          languageSwitchDetected: false,
+          words: this.config.wordTimestamps ? alt.words?.map((w) => ({
+            word: w.word ?? "",
+            startMs: (w.start ?? 0) * 1e3,
+            endMs: (w.end ?? 0) * 1e3,
+            confidence: w.confidence ?? 0,
+            punctuatedWord: w.punctuated_word
+          })) : void 0,
+          latencyMs: Date.now() - startMs
+        };
+        results.push(result);
+        if (isFinal) {
+          logger9.debug(
+            { transcript: result.transcript, confidence: result.confidence, language: result.language },
+            "Deepgram final transcript"
+          );
+        }
+      });
+      connection.on("close", () => {
+        done = true;
+      });
+      connection.on("error", (err) => {
+        error = err;
+        logger9.warn({ err, attempt }, "Deepgram stream error");
+      });
+      const sendAudio = async () => {
+        try {
+          for await (const chunk of audio) {
+            connection.socket.send(chunk);
+          }
+          connection.socket.send(JSON.stringify({ type: "Finalize" }));
+        } catch (err) {
+          error = err instanceof Error ? err : new Error(String(err));
+        }
+      };
+      const sendPromise = sendAudio();
+      let resultIndex = 0;
+      while (!done || resultIndex < results.length) {
+        if (resultIndex < results.length) {
+          yield results[resultIndex++];
+        } else {
+          await new Promise((r) => setTimeout(r, 10));
+        }
+        if (error && attempt < BACKOFF.maxAttempts) {
+          try {
+            connection.socket.close();
+          } catch {
+          }
+          break;
+        }
+        if (error && attempt >= BACKOFF.maxAttempts) {
+          await sendPromise.catch(() => {
+          });
+          throw new STTStreamError("deepgram", error);
+        }
+      }
+      await sendPromise.catch(() => {
+      });
+      if (!error) return;
+      attempt++;
+      await new Promise((r) => setTimeout(r, backoffDelay(attempt)));
+      logger9.info({ attempt }, "Deepgram reconnecting...");
+    }
+    throw new STTStreamError("deepgram", new Error("Max reconnect attempts exceeded"));
+  }
+  /**
+   * Transcribe a complete audio buffer (non-streaming).
+   * Uses Deepgram pre-recorded API.
+   *
+   * @param audio  Raw PCM or WAV buffer
+   */
+  async transcribeBatch(audio) {
+    const startMs = Date.now();
+    try {
+      const response = await this.client.listen.v1.media.transcribeFile(
+        audio,
+        {
+          model: this.config.model,
+          language: this.config.language,
+          // v5: boolean-like options must be strings
+          smart_format: true,
+          diarize: false
+        }
+      );
+      const alt = response?.results?.channels?.[0]?.alternatives?.[0];
+      return {
+        transcript: alt?.transcript ?? "",
+        isFinal: true,
+        confidence: alt?.confidence ?? 0,
+        language: this.config.language,
+        languageSwitchDetected: false,
+        latencyMs: Date.now() - startMs
+      };
+    } catch (err) {
+      if (err instanceof STTStreamError) throw err;
+      throw new STTStreamError("deepgram", err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  /**
+   * Create and open a live WebSocket connection to Deepgram.
+   *
+   * v5 connection lifecycle (3 explicit steps):
+   *   1. await listen.v1.connect(options)  — constructs the connection object
+   *   2. connection.connect()              — initiates the WebSocket handshake
+   *   3. await connection.waitForOpen()    — resolves once the socket is ready
+   *
+   * @internal
+   */
+  async connectWithRetry(attempt) {
+    const delay = attempt > 0 ? backoffDelay(attempt) : 0;
+    if (delay > 0) await new Promise((r) => setTimeout(r, delay));
+    try {
+      logger9.debug({ attempt, language: this.config.language }, "Connecting to Deepgram");
+      const connection = await this.client.listen.v1.connect({
+        model: this.config.model,
+        language: this.config.language,
+        // v5: boolean-like options must be strings
+        smart_format: "true",
+        interim_results: String(this.config.interimResults),
+        encoding: "linear16",
+        sample_rate: 16e3,
+        channels: 1,
+        utterance_end_ms: "1000",
+        ...this.config.alternateLanguages.length > 0 && {
+          detect_language: "true",
+          // language must be omitted when detect_language is enabled
+          language: void 0
+        },
+        Authorization: `Token ${this.config.apiKey}`
+      });
+      connection.connect();
+      await Promise.race([
+        connection.waitForOpen(),
+        new Promise(
+          (_, reject) => setTimeout(
+            () => reject(new STTConnectionError("deepgram", new Error("Connection timeout"))),
+            1e4
+          )
+        )
+      ]);
+      logger9.info({ attempt, language: this.config.language }, "Deepgram connected");
+      return connection;
+    } catch (err) {
+      if (err instanceof STTConnectionError) throw err;
+      throw new STTConnectionError("deepgram", err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+};
+var logger10 = pino__default.default({ name: "@voice-kit/core:stt:sarvam" });
+var SARVAM_API_BASE = "https://api.sarvam.ai";
+var SUPPORTED_LANGUAGES3 = [
+  "hi-IN",
+  "kn-IN",
+  "ta-IN",
+  "te-IN",
+  "mr-IN",
+  "bn-IN",
+  "gu-IN",
+  "pa-IN",
+  "or-IN",
+  "ml-IN"
+];
+var SARVAM_MODELS = {
+  "hi-IN": "saarika:v1",
+  "kn-IN": "saarika:v1",
+  "ta-IN": "saarika:v1",
+  "te-IN": "saarika:v1",
+  "mr-IN": "saarika:v1",
+  "bn-IN": "saarika:v1",
+  "gu-IN": "saarika:v1",
+  "pa-IN": "saarika:v1",
+  "or-IN": "saarika:v1",
+  "ml-IN": "saarika:v1"
+};
+var SarvamSTTProvider = class {
+  name = "sarvam";
+  supportsStreaming = false;
+  // Sarvam REST API is batch-only
+  supportedLanguages = SUPPORTED_LANGUAGES3;
+  http;
+  config;
+  constructor(config) {
+    const apiKey = config.apiKey ?? process.env["SARVAM_API_KEY"];
+    if (!apiKey) throw new STTConnectionError("sarvam", new Error("SARVAM_API_KEY not set"));
+    const language = config.language ?? "hi-IN";
+    if (!SUPPORTED_LANGUAGES3.includes(language)) {
+      throw new STTLanguageNotSupportedError("sarvam", language);
+    }
+    this.http = axios__default.default.create({
+      baseURL: SARVAM_API_BASE,
+      headers: {
+        "API-Subscription-Key": apiKey,
+        "Content-Type": "multipart/form-data"
+      },
+      timeout: 3e4
+    });
+    this.config = {
+      language,
+      alternateLanguages: config.alternateLanguages ?? [],
+      apiKey,
+      model: config.model ?? SARVAM_MODELS[language] ?? "saarika:v1",
+      wordTimestamps: false,
+      // Sarvam doesn't support word timestamps yet
+      interimResults: false,
+      smartFormat: config.smartFormat ?? true,
+      region: config.region ?? ""
+    };
+  }
+  /**
+   * Collects audio and transcribes via Sarvam batch API.
+   * Sarvam doesn't support realtime streaming.
+   *
+   * @param audio  Async iterable of 16kHz PCM buffers
+   */
+  async *transcribeStream(audio) {
+    const chunks = [];
+    for await (const chunk of audio) chunks.push(chunk);
+    const result = await this.transcribeBatch(Buffer.concat(chunks));
+    yield result;
+  }
+  /**
+   * Transcribe a WAV/PCM audio buffer in an Indic language.
+   *
+   * @param audio  16kHz PCM or WAV buffer
+   *
+   * @example
+   * ```ts
+   * const stt = createSTT('sarvam', { language: 'ta-IN' })
+   * const result = await stt.transcribeBatch(tamilAudioBuffer)
+   * console.log(result.transcript) // Tamil text
+   * ```
+   */
+  async transcribeBatch(audio) {
+    const startMs = Date.now();
+    try {
+      logger10.debug(
+        { language: this.config.language, bytes: audio.length },
+        "Sarvam transcription request"
+      );
+      const form = new FormData();
+      form.append("file", new Blob([audio], { type: "audio/wav" }), "audio.wav");
+      form.append("language_code", this.config.language);
+      form.append("model", this.config.model);
+      if (this.config.smartFormat) {
+        form.append("with_disfluencies", "false");
+      }
+      const response = await this.http.post(
+        "/speech-to-text",
+        form
+      );
+      const data = response.data;
+      logger10.info(
+        { language: data.language_code, confidence: data.confidence, latencyMs: Date.now() - startMs },
+        "Sarvam transcription complete"
+      );
+      return {
+        transcript: data.transcript,
+        isFinal: true,
+        confidence: data.confidence ?? 0.9,
+        language: data.language_code ?? this.config.language,
+        languageSwitchDetected: false,
+        latencyMs: Date.now() - startMs
+      };
+    } catch (err) {
+      if (axios__default.default.isAxiosError(err)) {
+        throw new STTStreamError(
+          "sarvam",
+          new Error(`Sarvam API error: ${err.response?.status} ${JSON.stringify(err.response?.data)}`)
+        );
+      }
+      throw new STTStreamError("sarvam", err);
+    }
+  }
+};
+var logger11 = pino__default.default({ name: "@voice-kit/core:stt:language-detect" });
+var DEVANAGARI_RANGE = /[\u0900-\u097F]/;
+var MIN_WORDS_FOR_CLASSIFICATION = 2;
+var SWITCH_CONFIDENCE_THRESHOLD = 0.6;
+var NEUTRAL_TOKENS = /* @__PURE__ */ new Set([
+  "ok",
+  "okay",
+  "haan",
+  "nahin",
+  "nahi",
+  "kya",
+  "hai",
+  "ho",
+  "na",
+  "toh",
+  "aur",
+  "ya",
+  "matlab",
+  "yani",
+  "i",
+  "a",
+  "the",
+  "is",
+  "are",
+  "and",
+  "or"
+]);
+var LanguageSwitchDetector = class extends events.EventEmitter {
+  currentLanguage;
+  primaryLanguage;
+  /** Rolling window of recent language classifications for smoothing. */
+  recentClassifications = [];
+  windowSize = 5;
+  constructor(primaryLanguage = "en-IN") {
+    super();
+    this.primaryLanguage = primaryLanguage;
+    this.currentLanguage = primaryLanguage;
+  }
+  /**
+   * Analyze a transcript for language switches.
+   * Should be called on every STT final result.
+   *
+   * @param transcript  The transcribed text to analyze
+   * @returns           Detected language of the transcript
+   */
+  analyze(transcript) {
+    const words = this.tokenize(transcript);
+    if (words.length === 0) return this.currentLanguage;
+    const classification = this.classifySegment(words);
+    const confidence = this.computeConfidence(words, classification);
+    this.recentClassifications.push(classification);
+    if (this.recentClassifications.length > this.windowSize) {
+      this.recentClassifications.shift();
+    }
+    const smoothed = this.smoothedLanguage();
+    if (smoothed !== this.currentLanguage && confidence >= SWITCH_CONFIDENCE_THRESHOLD && smoothed !== "unknown") {
+      const event = {
+        from: this.currentLanguage,
+        to: smoothed,
+        position: 0,
+        // position in full conversation
+        confidence,
+        transcript,
+        detectedAt: /* @__PURE__ */ new Date()
+      };
+      const prev = this.currentLanguage;
+      this.currentLanguage = smoothed;
+      logger11.info(
+        { from: prev, to: smoothed, confidence, transcript: transcript.slice(0, 50) },
+        "Language switch detected"
+      );
+      this.emit("language.switched", event);
+    }
+    return this.currentLanguage;
+  }
+  /**
+   * Analyze a transcript and return per-word language classification.
+   * Useful for word-level Hinglish mixing visualization.
+   *
+   * @param transcript  Text to analyze
+   * @returns           Array of { word, language } pairs
+   */
+  analyzeWords(transcript) {
+    const words = this.tokenize(transcript);
+    return words.map((word) => ({
+      word,
+      language: this.classifyWord(word)
+    }));
+  }
+  /** Reset to primary language (e.g., on new call). */
+  reset() {
+    this.currentLanguage = this.primaryLanguage;
+    this.recentClassifications = [];
+  }
+  /** Current detected language. */
+  get language() {
+    return this.currentLanguage;
+  }
+  // ─── Private helpers ────────────────────────────────────────────────────────
+  tokenize(text) {
+    return text.toLowerCase().split(/\s+/).filter((w) => w.length > 0 && !NEUTRAL_TOKENS.has(w));
+  }
+  classifyWord(word) {
+    if (DEVANAGARI_RANGE.test(word)) return "hi-IN";
+    if (/^[a-z]+$/.test(word)) return "en-IN";
+    return "unknown";
+  }
+  classifySegment(words) {
+    let hindiCount = 0;
+    let englishCount = 0;
+    for (const word of words) {
+      const lang = this.classifyWord(word);
+      if (lang === "hi-IN") hindiCount++;
+      else if (lang === "en-IN") englishCount++;
+    }
+    if (hindiCount === 0 && englishCount === 0) return "unknown";
+    if (hindiCount > englishCount) return "hi-IN";
+    if (englishCount > hindiCount) return "en-IN";
+    return this.primaryLanguage;
+  }
+  computeConfidence(words, classification) {
+    const relevant = words.filter((w) => this.classifyWord(w) !== "unknown");
+    if (relevant.length < MIN_WORDS_FOR_CLASSIFICATION) return 0;
+    const matching = relevant.filter((w) => this.classifyWord(w) === classification);
+    return matching.length / relevant.length;
+  }
+  smoothedLanguage() {
+    if (this.recentClassifications.length === 0) return this.primaryLanguage;
+    const counts = { "hi-IN": 0, "en-IN": 0, "unknown": 0 };
+    for (const lang of this.recentClassifications) {
+      counts[lang]++;
+    }
+    if (counts["hi-IN"] > counts["en-IN"]) return "hi-IN";
+    if (counts["en-IN"] > counts["hi-IN"]) return "en-IN";
+    return this.currentLanguage;
+  }
+};
+function isInglish(transcript) {
+  const hasDevanagari = DEVANAGARI_RANGE.test(transcript);
+  const hasLatin = /[a-zA-Z]/.test(transcript);
+  return hasDevanagari && hasLatin;
+}
+var logger12 = pino__default.default({ name: "@voice-kit/core:stt:whisper" });
+var WHISPER_LANGUAGES = [
+  "en",
+  "hi",
+  "ta",
+  "te",
+  "kn",
+  "mr",
+  "bn",
+  "gu",
+  "pa",
+  "ur",
+  "fr",
+  "de",
+  "es",
+  "pt",
+  "it",
+  "nl",
+  "pl",
+  "ru",
+  "ja",
+  "zh"
+];
+var WhisperSTTProvider = class {
+  name = "whisper";
+  supportsStreaming = false;
+  supportedLanguages = WHISPER_LANGUAGES;
+  config;
+  constructor(config) {
+    const apiKey = config.apiKey ?? process.env["OPENAI_API_KEY"];
+    if (!apiKey) throw new STTStreamError("whisper", new Error("OPENAI_API_KEY not set"));
+    const language = config.language ?? "en-IN";
+    const whisperLang = language.split("-")[0] ?? "en";
+    if (!WHISPER_LANGUAGES.includes(whisperLang)) {
+      throw new STTLanguageNotSupportedError("whisper", language);
+    }
+    this.config = {
+      language,
+      alternateLanguages: config.alternateLanguages ?? [],
+      apiKey,
+      model: config.model ?? "whisper-1",
+      wordTimestamps: config.wordTimestamps ?? false,
+      interimResults: false,
+      smartFormat: false,
+      region: ""
+    };
+  }
+  /**
+   * Streaming not supported by Whisper. Collects all audio then transcribes.
+   * For realtime use, use createSTT('deepgram') instead.
+   */
+  async *transcribeStream(audio) {
+    const chunks = [];
+    for await (const chunk of audio) chunks.push(chunk);
+    const result = await this.transcribeBatch(Buffer.concat(chunks));
+    yield result;
+  }
+  /**
+   * Transcribe a complete audio buffer via Whisper.
+   *
+   * @param audio  WAV or PCM buffer
+   */
+  async transcribeBatch(audio) {
+    const startMs = Date.now();
+    const language = this.config.language.split("-")[0] ?? "en";
+    try {
+      logger12.debug({ language, bytes: audio.length }, "Whisper batch transcription");
+      const openai$1 = openai.createOpenAI({ apiKey: this.config.apiKey });
+      const file = new File([audio], "audio.wav", { type: "audio/wav" });
+      const formData = new FormData();
+      formData.append("file", file);
+      formData.append("model", this.config.model);
+      formData.append("language", language);
+      if (this.config.wordTimestamps) {
+        formData.append("timestamp_granularities[]", "word");
+        formData.append("response_format", "verbose_json");
+      }
+      const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+        method: "POST",
+        headers: { Authorization: `Bearer ${this.config.apiKey}` },
+        body: formData
+      });
+      if (!response.ok) {
+        throw new Error(`Whisper API error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      return {
+        transcript: data.text,
+        isFinal: true,
+        confidence: 0.95,
+        // Whisper doesn't return confidence
+        language: this.config.language,
+        languageSwitchDetected: false,
+        words: this.config.wordTimestamps && data.words ? data.words.map((w) => ({
+          word: w.word,
+          startMs: w.start * 1e3,
+          endMs: w.end * 1e3,
+          confidence: 0.95
+        })) : void 0,
+        latencyMs: Date.now() - startMs
+      };
+    } catch (err) {
+      if (err instanceof STTStreamError) throw err;
+      throw new STTStreamError("whisper", err);
+    }
+  }
+};
+
+// src/stt/STT-factory.ts
+function createSTT(provider, config) {
+  const cfg = config ?? {};
+  switch (provider) {
+    case "deepgram":
+      return new DeepgramSTTProvider(cfg);
+    case "whisper":
+      return new WhisperSTTProvider(cfg);
+    case "assemblyai":
+      return new AssemblyAISTTProvider(cfg);
+    case "sarvam":
+      return new SarvamSTTProvider(cfg);
+    default: {
+      const _exhaustive = provider;
+      throw new Error(`Unknown STT provider: ${String(_exhaustive)}`);
+    }
+  }
+}
+var logger13 = pino__default.default({ name: "@voice-kit/core:tts:cartesia" });
+var DEFAULT_VOICE_ID = "a0e99841-438c-4a64-b679-ae501e7d6091";
+var CartesiaTTSProvider = class {
+  name = "cartesia";
+  outputSampleRate = 22050;
+  // Cartesia default
+  outputFormat = "pcm";
+  client;
+  config;
+  constructor(config) {
+    const apiKey = config.apiKey ?? process.env["CARTESIA_API_KEY"];
+    if (!apiKey) throw new TTSConnectionError("cartesia", new Error("CARTESIA_API_KEY not set"));
+    this.client = new Cartesia__default.default({ apiKey });
+    this.config = {
+      voiceId: config.voiceId ?? DEFAULT_VOICE_ID,
+      sampleRate: config.sampleRate ?? 22050,
+      speed: config.speed ?? 1,
+      pitch: config.pitch ?? 0,
+      apiKey,
+      modelId: config.modelId ?? "sonic-english",
+      emotion: config.emotion ?? "",
+      targetLanguage: config.targetLanguage ?? "en"
+    };
+  }
+  /**
+   * Stream audio from Cartesia. Typically delivers first chunk in < 90ms.
+   *
+   * @example
+   * ```ts
+   * const tts = createTTS('cartesia', { voiceId: 'your-voice-id' })
+   * for await (const chunk of tts.synthesizeStream('Hello!')) {
+   *   sendToTelephony(chunk)
+   * }
+   * ```
+   */
+  async *synthesizeStream(text, config) {
+    const voiceId = config?.voiceId ?? this.config.voiceId;
+    const startMs = Date.now();
+    logger13.debug({ voiceId, chars: text.length }, "Cartesia TTS stream start");
+    try {
+      const stream = await this.client.tts.generateSse({
+        model_id: config?.modelId ?? this.config.modelId,
+        transcript: text,
+        voice: {
+          mode: "id",
+          id: voiceId,
+          ...this.config.emotion && {
+            __experimental_controls: {
+              emotion: [this.config.emotion]
+            }
+          }
+        },
+        output_format: {
+          container: "raw",
+          encoding: "pcm_s16le",
+          sample_rate: toValidSampleRate(config?.sampleRate ?? this.config.sampleRate)
+        }
+      });
+      let firstChunk = true;
+      for await (const event of stream) {
+        if (!event.data || event.data === "[DONE]") continue;
+        let payload;
+        try {
+          payload = JSON.parse(event.data);
+        } catch {
+          continue;
+        }
+        if (!payload.chunk?.audio) continue;
+        const buf = Buffer.from(payload.chunk.audio, "base64");
+        if (firstChunk) {
+          firstChunk = false;
+          logger13.debug({ ttfb: Date.now() - startMs, voiceId }, "Cartesia first audio chunk");
+        }
+        yield buf;
+      }
+    } catch (err) {
+      throw new TTSStreamError("cartesia", err);
+    }
+  }
+  /** Synthesize complete audio. */
+  async synthesizeFull(text, config) {
+    const chunks = [];
+    for await (const chunk of this.synthesizeStream(text, config)) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+  }
+};
+var VALID_SAMPLE_RATES = [22050, 8e3, 16e3, 24e3, 44100, 48e3];
+function toValidSampleRate(rate) {
+  return VALID_SAMPLE_RATES.includes(rate) ? rate : 8e3;
+}
+var logger14 = pino__default.default({ name: "@voice-kit/core:tts:elevenlabs" });
+var DEFAULT_VOICE_ID2 = "21m00Tcm4TlvDq8ikWAM";
+var JITTER_BUFFER_MS = 100;
+var ElevenLabsTTSProvider = class {
+  name = "elevenlabs";
+  outputSampleRate = 24e3;
+  // ElevenLabs default: 24kHz
+  outputFormat = "pcm";
+  client;
+  config;
+  constructor(config) {
+    const apiKey = config.apiKey ?? process.env["ELEVENLABS_API_KEY"];
+    if (!apiKey) throw new TTSConnectionError("elevenlabs", new Error("ELEVENLABS_API_KEY not set"));
+    this.client = new elevenlabs.ElevenLabsClient({ apiKey });
+    this.config = {
+      voiceId: config.voiceId ?? DEFAULT_VOICE_ID2,
+      sampleRate: config.sampleRate ?? 24e3,
+      speed: config.speed ?? 1,
+      pitch: config.pitch ?? 0,
+      apiKey,
+      modelId: config.modelId ?? "eleven_turbo_v2_5",
+      emotion: config.emotion ?? "",
+      targetLanguage: config.targetLanguage ?? "en-IN"
+    };
+  }
+  /**
+   * Stream synthesized audio from ElevenLabs.
+   * First chunk target: < 300ms. Uses streaming API endpoint.
+   *
+   * A 100ms jitter buffer smooths burst packet delivery without adding
+   * perceptible latency.
+   *
+   * @param text    Text to synthesize (should be a sentence boundary chunk)
+   * @param config  Per-call config overrides
+   *
+   * @example
+   * ```ts
+   * const tts = createTTS('elevenlabs', { voiceId: 'your-voice-id' })
+   * for await (const chunk of tts.synthesizeStream('Hello, how can I help?')) {
+   *   telephony.sendAudio(chunk)
+   * }
+   * ```
+   */
+  async *synthesizeStream(text, config) {
+    const voiceId = config?.voiceId ?? this.config.voiceId;
+    const modelId = config?.modelId ?? this.config.modelId;
+    const startMs = Date.now();
+    logger14.debug({ voiceId, modelId, chars: text.length }, "ElevenLabs TTS stream start");
+    try {
+      const audioStream = await this.client.generate({
+        voice: voiceId,
+        text,
+        model_id: modelId,
+        voice_settings: {
+          stability: 0.5,
+          similarity_boost: 0.8,
+          speed: config?.speed ?? this.config.speed
+        },
+        output_format: "pcm_24000",
+        stream: true
+      });
+      let firstChunk = true;
+      let jitterBuffer = [];
+      let jitterTimer = null;
+      const flushJitterBuffer = function* () {
+        for (const chunk of jitterBuffer) {
+          yield chunk;
+        }
+        jitterBuffer = [];
+      };
+      for await (const chunk of audioStream) {
+        const buf = chunk instanceof Buffer ? chunk : Buffer.from(chunk);
+        if (firstChunk) {
+          firstChunk = false;
+          const ttfb = Date.now() - startMs;
+          logger14.debug({ ttfb, voiceId }, "ElevenLabs first audio chunk");
+        }
+        jitterBuffer.push(buf);
+        if (jitterTimer === null) {
+          jitterTimer = setTimeout(() => {
+          }, JITTER_BUFFER_MS);
+        }
+        const totalBytes = jitterBuffer.reduce((sum, b) => sum + b.length, 0);
+        if (totalBytes >= 4800) {
+          if (jitterTimer !== null) {
+            clearTimeout(jitterTimer);
+            jitterTimer = null;
+          }
+          yield* flushJitterBuffer();
+        }
+      }
+      if (jitterTimer !== null) {
+        clearTimeout(jitterTimer);
+      }
+      yield* flushJitterBuffer();
+      logger14.debug({ voiceId, totalMs: Date.now() - startMs }, "ElevenLabs TTS stream complete");
+    } catch (err) {
+      if (err.statusCode === 404) {
+        throw new TTSVoiceNotFoundError("elevenlabs", voiceId);
+      }
+      throw new TTSStreamError("elevenlabs", err);
+    }
+  }
+  /**
+   * Synthesize full audio (for pre-caching greetings, IVR prompts).
+   * Collects all streaming chunks into a single buffer.
+   *
+   * @param text    Text to synthesize
+   * @param config  Per-call config overrides
+   */
+  async synthesizeFull(text, config) {
+    const chunks = [];
+    for await (const chunk of this.synthesizeStream(text, config)) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+  }
+};
+var logger15 = pino__default.default({ name: "@voice-kit/core:tts:sarvam" });
+var SARVAM_API_BASE2 = "https://api.sarvam.ai";
+var DEFAULT_VOICES = {
+  "hi-IN": "meera",
+  "kn-IN": "pavithra",
+  "ta-IN": "pavithra",
+  "te-IN": "pavithra",
+  "mr-IN": "meera",
+  "bn-IN": "meera",
+  "gu-IN": "meera",
+  "pa-IN": "meera"
+};
+var SarvamTTSProvider = class {
+  name = "sarvam";
+  outputSampleRate = 22050;
+  // Sarvam default
+  outputFormat = "mp3";
+  http;
+  config;
+  constructor(config) {
+    const apiKey = config.apiKey ?? process.env["SARVAM_API_KEY"];
+    if (!apiKey) throw new TTSConnectionError("sarvam", new Error("SARVAM_API_KEY not set"));
+    const targetLanguage = config.targetLanguage ?? "hi-IN";
+    const defaultVoice = DEFAULT_VOICES[targetLanguage] ?? "meera";
+    this.http = axios__default.default.create({
+      baseURL: SARVAM_API_BASE2,
+      headers: {
+        "API-Subscription-Key": apiKey,
+        "Content-Type": "application/json"
+      },
+      timeout: 15e3
+    });
+    this.config = {
+      voiceId: config.voiceId ?? defaultVoice,
+      sampleRate: config.sampleRate ?? 22050,
+      speed: config.speed ?? 1,
+      pitch: config.pitch ?? 0,
+      apiKey,
+      modelId: config.modelId ?? "bulbul:v1",
+      emotion: "",
+      targetLanguage
+    };
+  }
+  /**
+   * Synthesize text in an Indic language and stream audio chunks.
+   * Sarvam returns full audio segments — we chunk them for streaming compatibility.
+   *
+   * @example
+   * ```ts
+   * const tts = createTTS('sarvam', { targetLanguage: 'hi-IN' })
+   * for await (const chunk of tts.synthesizeStream('नमस्ते, मैं आपकी कैसे मदद कर सकता हूँ?')) {
+   *   telephony.sendAudio(chunk)
+   * }
+   * ```
+   */
+  async *synthesizeStream(text, config) {
+    const startMs = Date.now();
+    const targetLanguage = config?.targetLanguage ?? this.config.targetLanguage;
+    const speaker = config?.voiceId ?? this.config.voiceId;
+    logger15.debug({ targetLanguage, speaker, chars: text.length }, "Sarvam TTS request");
+    try {
+      const response = await this.http.post("/text-to-speech", {
+        inputs: [text],
+        target_language_code: targetLanguage,
+        speaker,
+        model: config?.modelId ?? this.config.modelId,
+        pitch: config?.pitch ?? this.config.pitch,
+        pace: config?.speed ?? this.config.speed,
+        loudness: 1,
+        speech_sample_rate: config?.sampleRate ?? this.config.sampleRate,
+        enable_preprocessing: true
+      });
+      const audioSegments = response.data.audios;
+      if (!audioSegments || audioSegments.length === 0) {
+        throw new TTSStreamError("sarvam", new Error("No audio returned from Sarvam TTS"));
+      }
+      logger15.debug(
+        { segments: audioSegments.length, latencyMs: Date.now() - startMs },
+        "Sarvam TTS response received"
+      );
+      for (const segment of audioSegments) {
+        const buf = Buffer.from(segment, "base64");
+        const CHUNK_SIZE = 4096;
+        let offset = 0;
+        while (offset < buf.length) {
+          yield buf.subarray(offset, Math.min(offset + CHUNK_SIZE, buf.length));
+          offset += CHUNK_SIZE;
+        }
+      }
+    } catch (err) {
+      if (axios__default.default.isAxiosError(err)) {
+        throw new TTSStreamError(
+          "sarvam",
+          new Error(`Sarvam TTS API error: ${err.response?.status} ${JSON.stringify(err.response?.data)}`)
+        );
+      }
+      throw new TTSStreamError("sarvam", err);
+    }
+  }
+  /** Synthesize complete audio buffer. */
+  async synthesizeFull(text, config) {
+    const chunks = [];
+    for await (const chunk of this.synthesizeStream(text, config)) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+  }
+};
+
+// src/tts/TTS-factory.ts
+function createTTS(provider, config) {
+  const cfg = config ?? {};
+  switch (provider) {
+    case "elevenlabs":
+      return new ElevenLabsTTSProvider(cfg);
+    case "cartesia":
+      return new CartesiaTTSProvider(cfg);
+    case "sarvam":
+      return new SarvamTTSProvider(cfg);
+    default: {
+      const _exhaustive = provider;
+      throw new Error(`Unknown TTS provider: ${String(_exhaustive)}`);
+    }
+  }
+}
+
 exports.AgentError = AgentError;
 exports.AgentHandoffError = AgentHandoffError;
+exports.AssemblyAISTTProvider = AssemblyAISTTProvider;
+exports.AudioPipeline = AudioPipeline;
 exports.AudioTransportError = AudioTransportError;
+exports.CallAuditLog = CallAuditLog;
 exports.CallConnectionError = CallConnectionError;
+exports.CallMetrics = CallMetrics;
 exports.CallNotFoundError = CallNotFoundError;
 exports.CallingHoursError = CallingHoursError;
+exports.CartesiaTTSProvider = CartesiaTTSProvider;
 exports.ComplianceError = ComplianceError;
 exports.ConsentMissingError = ConsentMissingError;
 exports.DNCBlockedError = DNCBlockedError;
+exports.DeepgramSTTProvider = DeepgramSTTProvider;
+exports.ElevenLabsTTSProvider = ElevenLabsTTSProvider;
 exports.InngestError = InngestError;
+exports.LanguageSwitchDetector = LanguageSwitchDetector;
 exports.STTConnectionError = STTConnectionError;
 exports.STTError = STTError;
 exports.STTLanguageNotSupportedError = STTLanguageNotSupportedError;
 exports.STTStreamError = STTStreamError;
+exports.SarvamSTTProvider = SarvamSTTProvider;
+exports.SarvamTTSProvider = SarvamTTSProvider;
+exports.TRAICompliance = TRAICompliance;
 exports.TTSConnectionError = TTSConnectionError;
 exports.TTSError = TTSError;
 exports.TTSStreamError = TTSStreamError;
 exports.TTSVoiceNotFoundError = TTSVoiceNotFoundError;
 exports.TelephonyError = TelephonyError;
 exports.TurnTransitionError = TurnTransitionError;
+exports.VADEngine = VADEngine;
 exports.VoiceKitError = VoiceKitError;
+exports.VoiceSDKTracer = VoiceSDKTracer;
+exports.WhisperSTTProvider = WhisperSTTProvider;
+exports.base64MulawToPcm = base64MulawToPcm;
+exports.createAudioPipeline = createAudioPipeline;
+exports.createCallMemory = createCallMemory;
+exports.createResamplerStream = createResamplerStream;
+exports.createSTT = createSTT;
+exports.createTTS = createTTS;
+exports.createVAD = createVAD;
+exports.isInglish = isInglish;
+exports.linearToMulaw = linearToMulaw;
+exports.mulawBufferToPcm = mulawBufferToPcm;
+exports.mulawToLinear = mulawToLinear;
+exports.pcmBufferToMulaw = pcmBufferToMulaw;
+exports.pcmToBase64Mulaw = pcmToBase64Mulaw;
+exports.resample = resample;
+exports.resampleStream = resampleStream;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map