@dtelecom/agents-js 0.1.14 → 0.1.15

package/dist/index.d.mts

@@ -1,8 +1,8 @@
 import * as _dtelecom_server_sdk_node from '@dtelecom/server-sdk-node';
 import { Room, AudioSource, RemoteAudioTrack, AudioFrame } from '@dtelecom/server-sdk-node';
 import { EventEmitter } from 'events';
-import { A as AgentConfig, a as AgentStartOptions, M as Message, L as LLMPlugin, P as PipelineOptions, b as AgentState, S as STTStream, T as TranscriptionResult } from './types-BVMiP1bW.mjs';
-export { c as AgentEvents, d as AudioOutput, D as DataMessageHandler, e as LLMChunk, f as MemoryConfig, g as PipelineEvents, R as RespondMode, h as STTPlugin, i as STTStreamOptions, j as TTSPlugin } from './types-BVMiP1bW.mjs';
+import { A as AgentConfig, a as AgentStartOptions, M as Message, L as LLMPlugin, P as PipelineOptions, b as AgentState, S as STTStream, T as TranscriptionResult } from './types-MPHcuMhp.mjs';
+export { c as AgentEvents, d as AudioOutput, D as DataMessageHandler, e as LLMChunk, f as MemoryConfig, g as PipelineEvents, R as RespondMode, h as STTPlugin, i as STTStreamOptions, j as TTSPlugin } from './types-MPHcuMhp.mjs';
 
 declare class VoiceAgent extends EventEmitter {
     private readonly config;

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import * as _dtelecom_server_sdk_node from '@dtelecom/server-sdk-node';
 import { Room, AudioSource, RemoteAudioTrack, AudioFrame } from '@dtelecom/server-sdk-node';
 import { EventEmitter } from 'events';
-import { A as AgentConfig, a as AgentStartOptions, M as Message, L as LLMPlugin, P as PipelineOptions, b as AgentState, S as STTStream, T as TranscriptionResult } from './types-BVMiP1bW.js';
-export { c as AgentEvents, d as AudioOutput, D as DataMessageHandler, e as LLMChunk, f as MemoryConfig, g as PipelineEvents, R as RespondMode, h as STTPlugin, i as STTStreamOptions, j as TTSPlugin } from './types-BVMiP1bW.js';
+import { A as AgentConfig, a as AgentStartOptions, M as Message, L as LLMPlugin, P as PipelineOptions, b as AgentState, S as STTStream, T as TranscriptionResult } from './types-MPHcuMhp.js';
+export { c as AgentEvents, d as AudioOutput, D as DataMessageHandler, e as LLMChunk, f as MemoryConfig, g as PipelineEvents, R as RespondMode, h as STTPlugin, i as STTStreamOptions, j as TTSPlugin } from './types-MPHcuMhp.js';
 
 declare class VoiceAgent extends EventEmitter {
     private readonly config;

package/dist/memory/index.d.mts

@@ -1,4 +1,4 @@
-export { E as Embedder, k as RoomMemory, l as RoomMemoryConfig } from '../types-BVMiP1bW.mjs';
+export { E as Embedder, k as RoomMemory, l as RoomMemoryConfig } from '../types-MPHcuMhp.mjs';
 import '@dtelecom/server-sdk-node';
 
 /**

package/dist/memory/index.d.ts

@@ -1,4 +1,4 @@
-export { E as Embedder, k as RoomMemory, l as RoomMemoryConfig } from '../types-BVMiP1bW.js';
+export { E as Embedder, k as RoomMemory, l as RoomMemoryConfig } from '../types-MPHcuMhp.js';
 import '@dtelecom/server-sdk-node';
 
 /**

package/dist/providers/index.d.mts

@@ -1,4 +1,4 @@
-import { h as STTPlugin, i as STTStreamOptions, S as STTStream, L as LLMPlugin, M as Message, e as LLMChunk, j as TTSPlugin } from '../types-BVMiP1bW.mjs';
+import { h as STTPlugin, i as STTStreamOptions, S as STTStream, L as LLMPlugin, M as Message, e as LLMChunk, j as TTSPlugin } from '../types-MPHcuMhp.mjs';
 import '@dtelecom/server-sdk-node';
 
 /**
@@ -200,4 +200,87 @@ declare class DeepgramTTS implements TTSPlugin {
     private ensureConnection;
 }
 
-export { CartesiaTTS, type CartesiaTTSOptions, DeepgramSTT, type DeepgramSTTOptions, DeepgramTTS, type DeepgramTTSOptions, OpenRouterLLM, type OpenRouterLLMOptions };
+/**
+ * DtelecomSTT — real-time streaming STT via dTelecom STT server (realtime-stt-m2).
+ *
+ * Protocol:
+ * - Connect to ws://<server>:<port> (address from options, no API key)
+ * - Send config: {"type":"config","language":"en"} (or "auto" for Parakeet auto-detect)
+ * - Wait for ready: {"type":"ready","client_id":"...","language":"en"}
+ * - Send audio as binary PCM16 16kHz mono frames
+ * - Receive transcriptions: {"type":"transcription","text":"...","is_final":true,"latency_ms":N}
+ * - Receive VAD events: {"type":"vad_event","event":"speech_start"|"speech_end"}
+ * - Keepalive via {"type":"ping"} / {"type":"pong"}
+ * - Mid-session reconfigure: send {"type":"config","language":"es","model":"whisper"} at any time
+ */
+
+interface DtelecomSTTOptions {
+    /** WebSocket server URL, e.g. "ws://192.168.1.100:8765" */
+    serverUrl: string;
+    /** Initial language (default: "auto" for Parakeet auto-detect) */
+    language?: string;
+    /** Force Whisper model even if Parakeet supports the language */
+    forceWhisper?: boolean;
+}
+declare class DtelecomSTT implements STTPlugin {
+    private readonly options;
+    constructor(options: DtelecomSTTOptions);
+    createStream(options?: STTStreamOptions): STTStream;
+}
+
+/**
+ * DtelecomTTS — real-time streaming TTS via dTelecom TTS server (realtime-tts-m2).
+ *
+ * Protocol:
+ * - Connect to ws://<server>:<port> (address from options, no API key)
+ * - Send config: {"config":{"voice":"af_heart","lang_code":"a","speed":1.0}}
+ * - Send text: {"text":"Hello world"} — uses config defaults
+ * - Send text with per-message override: {"text":"Hola","voice":"bf_emma","lang_code":"b","speed":1.0}
+ * - Receive: {"type":"generating","text":"..."} then binary PCM16 24kHz chunks, then {"type":"done"}
+ * - Cancel: {"type":"clear"} → {"type":"cleared"}
+ *
+ * Key differences from DeepgramTTS:
+ * - Single WebSocket connection (not per-language pool)
+ * - Per-message voice/language switching instead of separate connections
+ * - Server outputs 24kHz PCM16, we resample to 48kHz for the pipeline
+ * - Uses SSML <lang> tags to route text segments to correct voice (same as DeepgramTTS)
+ */
+
+interface VoiceConfig {
+    voice: string;
+    langCode: string;
+}
+interface DtelecomTTSOptions {
+    /** WebSocket server URL, e.g. "ws://192.168.1.100:8766" */
+    serverUrl: string;
+    /** Voice config per language: { en: { voice: "af_heart", langCode: "a" }, es: { voice: "bf_emma", langCode: "b" } } */
+    voices: Record<string, VoiceConfig>;
+    /** Default language code (default: "en") */
+    defaultLanguage?: string;
+    /** Speech speed multiplier (default: 1.0) */
+    speed?: number;
+}
+declare class DtelecomTTS implements TTSPlugin {
+    private readonly serverUrl;
+    private readonly voices;
+    private readonly defaultLang;
+    private readonly speed;
+    private ws;
+    private connectPromise;
+    private flushState;
+    /** Default language code for untagged text (e.g. 'en'). */
+    get defaultLanguage(): string;
+    constructor(options: DtelecomTTSOptions);
+    /** Pre-connect WebSocket to TTS server. */
+    warmup(): Promise<void>;
+    /** Close WebSocket connection. */
+    close(): void;
+    /** Strip SSML lang tags from text for display/events. */
+    cleanText(text: string): string;
+    synthesize(text: string, signal?: AbortSignal): AsyncGenerator<Buffer>;
+    private synthesizeSegment;
+    /** Ensure a WebSocket connection exists and is open. */
+    private ensureConnection;
+}
+
+export { CartesiaTTS, type CartesiaTTSOptions, DeepgramSTT, type DeepgramSTTOptions, DeepgramTTS, type DeepgramTTSOptions, DtelecomSTT, type DtelecomSTTOptions, DtelecomTTS, type DtelecomTTSOptions, type VoiceConfig as DtelecomVoiceConfig, OpenRouterLLM, type OpenRouterLLMOptions };

package/dist/providers/index.d.ts

@@ -1,4 +1,4 @@
-import { h as STTPlugin, i as STTStreamOptions, S as STTStream, L as LLMPlugin, M as Message, e as LLMChunk, j as TTSPlugin } from '../types-BVMiP1bW.js';
+import { h as STTPlugin, i as STTStreamOptions, S as STTStream, L as LLMPlugin, M as Message, e as LLMChunk, j as TTSPlugin } from '../types-MPHcuMhp.js';
 import '@dtelecom/server-sdk-node';
 
 /**
@@ -200,4 +200,87 @@ declare class DeepgramTTS implements TTSPlugin {
     private ensureConnection;
 }
 
-export { CartesiaTTS, type CartesiaTTSOptions, DeepgramSTT, type DeepgramSTTOptions, DeepgramTTS, type DeepgramTTSOptions, OpenRouterLLM, type OpenRouterLLMOptions };
+/**
+ * DtelecomSTT — real-time streaming STT via dTelecom STT server (realtime-stt-m2).
+ *
+ * Protocol:
+ * - Connect to ws://<server>:<port> (address from options, no API key)
+ * - Send config: {"type":"config","language":"en"} (or "auto" for Parakeet auto-detect)
+ * - Wait for ready: {"type":"ready","client_id":"...","language":"en"}
+ * - Send audio as binary PCM16 16kHz mono frames
+ * - Receive transcriptions: {"type":"transcription","text":"...","is_final":true,"latency_ms":N}
+ * - Receive VAD events: {"type":"vad_event","event":"speech_start"|"speech_end"}
+ * - Keepalive via {"type":"ping"} / {"type":"pong"}
+ * - Mid-session reconfigure: send {"type":"config","language":"es","model":"whisper"} at any time
+ */
+
+interface DtelecomSTTOptions {
+    /** WebSocket server URL, e.g. "ws://192.168.1.100:8765" */
+    serverUrl: string;
+    /** Initial language (default: "auto" for Parakeet auto-detect) */
+    language?: string;
+    /** Force Whisper model even if Parakeet supports the language */
+    forceWhisper?: boolean;
+}
+declare class DtelecomSTT implements STTPlugin {
+    private readonly options;
+    constructor(options: DtelecomSTTOptions);
+    createStream(options?: STTStreamOptions): STTStream;
+}
+
+/**
+ * DtelecomTTS — real-time streaming TTS via dTelecom TTS server (realtime-tts-m2).
+ *
+ * Protocol:
+ * - Connect to ws://<server>:<port> (address from options, no API key)
+ * - Send config: {"config":{"voice":"af_heart","lang_code":"a","speed":1.0}}
+ * - Send text: {"text":"Hello world"} — uses config defaults
+ * - Send text with per-message override: {"text":"Hola","voice":"bf_emma","lang_code":"b","speed":1.0}
+ * - Receive: {"type":"generating","text":"..."} then binary PCM16 24kHz chunks, then {"type":"done"}
+ * - Cancel: {"type":"clear"} → {"type":"cleared"}
+ *
+ * Key differences from DeepgramTTS:
+ * - Single WebSocket connection (not per-language pool)
+ * - Per-message voice/language switching instead of separate connections
+ * - Server outputs 24kHz PCM16, we resample to 48kHz for the pipeline
+ * - Uses SSML <lang> tags to route text segments to correct voice (same as DeepgramTTS)
+ */
+
+interface VoiceConfig {
+    voice: string;
+    langCode: string;
+}
+interface DtelecomTTSOptions {
+    /** WebSocket server URL, e.g. "ws://192.168.1.100:8766" */
+    serverUrl: string;
+    /** Voice config per language: { en: { voice: "af_heart", langCode: "a" }, es: { voice: "bf_emma", langCode: "b" } } */
+    voices: Record<string, VoiceConfig>;
+    /** Default language code (default: "en") */
+    defaultLanguage?: string;
+    /** Speech speed multiplier (default: 1.0) */
+    speed?: number;
+}
+declare class DtelecomTTS implements TTSPlugin {
+    private readonly serverUrl;
+    private readonly voices;
+    private readonly defaultLang;
+    private readonly speed;
+    private ws;
+    private connectPromise;
+    private flushState;
+    /** Default language code for untagged text (e.g. 'en'). */
+    get defaultLanguage(): string;
+    constructor(options: DtelecomTTSOptions);
+    /** Pre-connect WebSocket to TTS server. */
+    warmup(): Promise<void>;
+    /** Close WebSocket connection. */
+    close(): void;
+    /** Strip SSML lang tags from text for display/events. */
+    cleanText(text: string): string;
+    synthesize(text: string, signal?: AbortSignal): AsyncGenerator<Buffer>;
+    private synthesizeSegment;
+    /** Ensure a WebSocket connection exists and is open. */
+    private ensureConnection;
+}
+
+export { CartesiaTTS, type CartesiaTTSOptions, DeepgramSTT, type DeepgramSTTOptions, DeepgramTTS, type DeepgramTTSOptions, DtelecomSTT, type DtelecomSTTOptions, DtelecomTTS, type DtelecomTTSOptions, type VoiceConfig as DtelecomVoiceConfig, OpenRouterLLM, type OpenRouterLLMOptions };

package/dist/providers/index.js

@@ -33,6 +33,8 @@ __export(providers_exports, {
   CartesiaTTS: () => CartesiaTTS,
   DeepgramSTT: () => DeepgramSTT,
   DeepgramTTS: () => DeepgramTTS,
+  DtelecomSTT: () => DtelecomSTT,
+  DtelecomTTS: () => DtelecomTTS,
   OpenRouterLLM: () => OpenRouterLLM
 });
 module.exports = __toCommonJS(providers_exports);
@@ -904,11 +906,403 @@ var DeepgramTTS = class {
     return promise;
   }
 };
+
+// src/providers/dtelecom-stt.ts
+var import_ws4 = __toESM(require("ws"));
+var log5 = createLogger("DtelecomSTT");
+var KEEPALIVE_INTERVAL_MS2 = 5e3;
+var DtelecomSTT = class {
+  options;
+  constructor(options) {
+    if (!options.serverUrl) {
+      throw new Error("DtelecomSTT requires a serverUrl");
+    }
+    this.options = options;
+  }
+  createStream(options) {
+    const language = options?.language ?? this.options.language ?? "auto";
+    return new DtelecomSTTStream(this.options, language);
+  }
+};
+var DtelecomSTTStream = class extends BaseSTTStream {
+  ws = null;
+  serverUrl;
+  forceWhisper;
+  _ready = false;
+  _closed = false;
+  pendingAudio = [];
+  keepAliveTimer = null;
+  language;
+  constructor(options, language) {
+    super();
+    this.serverUrl = options.serverUrl;
+    this.language = language;
+    this.forceWhisper = options.forceWhisper ?? false;
+    this.connect();
+  }
+  sendAudio(pcm16) {
+    if (this._closed) return;
+    if (!this._ready) {
+      this.pendingAudio.push(pcm16);
+      return;
+    }
+    if (this.ws?.readyState === import_ws4.default.OPEN) {
+      this.ws.send(pcm16);
+    }
+  }
+  /**
+   * Switch language mid-session.
+   * Sends a reconfigure message to the server; clears buffers and updates model routing.
+   */
+  setLanguage(language, options) {
+    if (this._closed) return;
+    this.language = language;
+    const config = { type: "config", language };
+    if (options?.forceWhisper) {
+      config.model = "whisper";
+    }
+    if (this.ws?.readyState === import_ws4.default.OPEN) {
+      this.ws.send(JSON.stringify(config));
+      log5.info(`Reconfiguring STT: language=${language}${options?.forceWhisper ? ", model=whisper" : ""}`);
+    }
+  }
+  async close() {
+    if (this._closed) return;
+    this._closed = true;
+    this._ready = false;
+    this.pendingAudio = [];
+    this.stopKeepAlive();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    log5.debug("DtelecomSTT stream closed");
+  }
+  connect() {
+    log5.debug(`Connecting to dTelecom STT: ${this.serverUrl}`);
+    this.ws = new import_ws4.default(this.serverUrl);
+    this.ws.on("open", () => {
+      log5.info("dTelecom STT WebSocket connected");
+      const config = { type: "config", language: this.language };
+      if (this.forceWhisper) {
+        config.model = "whisper";
+      }
+      this.ws.send(JSON.stringify(config));
+    });
+    this.ws.on("message", (data, isBinary) => {
+      if (isBinary) return;
+      try {
+        const msg = JSON.parse(data.toString());
+        this.handleMessage(msg);
+      } catch (err) {
+        log5.error("Failed to parse dTelecom STT message:", err);
+      }
+    });
+    this.ws.on("error", (err) => {
+      log5.error("dTelecom STT WebSocket error:", err);
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    });
+    this.ws.on("close", (code, reason) => {
+      log5.debug(`dTelecom STT WebSocket closed: ${code} ${reason.toString()}`);
+      this._ready = false;
+      this.stopKeepAlive();
+      if (!this._closed) {
+        log5.info("dTelecom STT connection lost, reconnecting in 1s...");
+        setTimeout(() => {
+          if (!this._closed) this.connect();
+        }, 1e3);
+      }
+    });
+  }
+  handleMessage(msg) {
+    const type = msg.type;
+    if (type === "ready") {
+      this.handleReady(msg);
+    } else if (type === "transcription") {
+      this.handleTranscription(msg);
+    } else if (type === "vad_event") {
+      this.handleVadEvent(msg);
+    } else if (type === "pong") {
+    } else if (type === "error") {
+      const errorMsg = msg.message || msg.error || "Unknown STT error";
+      log5.error(`dTelecom STT error: ${errorMsg}`);
+      this.emit("error", new Error(errorMsg));
+    }
+  }
+  handleReady(msg) {
+    const clientId = msg.client_id;
+    const lang = msg.language;
+    log5.info(`dTelecom STT ready: client_id=${clientId}, language=${lang}`);
+    this._ready = true;
+    for (const buf of this.pendingAudio) {
+      if (this.ws?.readyState === import_ws4.default.OPEN) {
+        this.ws.send(buf);
+      }
+    }
+    this.pendingAudio = [];
+    this.startKeepAlive();
+  }
+  handleTranscription(msg) {
+    const text = msg.text ?? "";
+    const isFinal = msg.is_final ?? false;
+    const language = msg.language;
+    const latencyMs = msg.latency_ms;
+    if (!text) return;
+    if (isFinal && latencyMs !== void 0) {
+      log5.info(`stt_final: ${latencyMs.toFixed(0)}ms "${text.slice(0, 50)}"`);
+    }
+    this.emit("transcription", {
+      text,
+      isFinal,
+      language,
+      sttDuration: isFinal ? latencyMs : void 0
+    });
+  }
+  handleVadEvent(msg) {
+    const event = msg.event;
+    log5.debug(`VAD event: ${event}`);
+    if (event === "speech_start") {
+      this.emit("transcription", {
+        text: "",
+        isFinal: false
+      });
+    }
+  }
+  startKeepAlive() {
+    this.stopKeepAlive();
+    this.keepAliveTimer = setInterval(() => {
+      if (this.ws?.readyState === import_ws4.default.OPEN) {
+        this.ws.send(JSON.stringify({ type: "ping" }));
+      }
+    }, KEEPALIVE_INTERVAL_MS2);
+  }
+  stopKeepAlive() {
+    if (this.keepAliveTimer) {
+      clearInterval(this.keepAliveTimer);
+      this.keepAliveTimer = null;
+    }
+  }
+};
+
+// src/providers/dtelecom-tts.ts
+var import_ws5 = __toESM(require("ws"));
+var import_wave_resampler = require("wave-resampler");
+var log6 = createLogger("DtelecomTTS");
+function resample24to48(input) {
+  const samples = new Int16Array(input.buffer, input.byteOffset, input.length / 2);
+  if (samples.length === 0) return Buffer.alloc(0);
+  const resampled = (0, import_wave_resampler.resample)(samples, 24e3, 48e3, { method: "sinc", LPF: false });
+  const output = new Int16Array(resampled.length);
+  for (let i = 0; i < resampled.length; i++) {
+    output[i] = Math.round(resampled[i]);
+  }
+  return Buffer.from(output.buffer, output.byteOffset, output.byteLength);
+}
+var DtelecomTTS = class {
+  serverUrl;
+  voices;
+  defaultLang;
+  speed;
+  ws = null;
+  connectPromise = null;
+  flushState = null;
+  /** Default language code for untagged text (e.g. 'en'). */
+  get defaultLanguage() {
+    return this.defaultLang;
+  }
+  constructor(options) {
+    if (!options.serverUrl) {
+      throw new Error("DtelecomTTS requires a serverUrl");
+    }
+    if (!options.voices || Object.keys(options.voices).length === 0) {
+      throw new Error("DtelecomTTS requires at least one voice config");
+    }
+    this.serverUrl = options.serverUrl;
+    this.voices = { ...options.voices };
+    this.defaultLang = options.defaultLanguage ?? Object.keys(this.voices)[0];
+    this.speed = options.speed ?? 1;
+  }
+  /** Pre-connect WebSocket to TTS server. */
+  async warmup() {
+    log6.info("Warming up TTS connection...");
+    const start = performance.now();
+    try {
+      await this.ensureConnection();
+      log6.info(`TTS warmup complete in ${(performance.now() - start).toFixed(0)}ms`);
+    } catch (err) {
+      log6.warn("TTS warmup failed (non-fatal):", err);
+    }
+  }
+  /** Close WebSocket connection. */
+  close() {
+    if (this.ws) {
+      log6.debug("Closing TTS WebSocket");
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connectPromise = null;
+    this.flushState = null;
+  }
+  /** Strip SSML lang tags from text for display/events. */
+  cleanText(text) {
+    return parseLangSegments(text, this.defaultLang).map((s) => s.text).join(" ").replace(/\s+/g, " ").trim();
+  }
+  async *synthesize(text, signal) {
+    if (signal?.aborted) return;
+    const segments = parseLangSegments(text, this.defaultLang);
+    const silenceBytes = Math.round(48e3 * 0.2) * 2;
+    const silence = Buffer.alloc(silenceBytes);
+    let prevLang = null;
+    for (const segment of segments) {
+      if (signal?.aborted) break;
+      if (!segment.text.trim()) continue;
+      const lang = this.voices[segment.lang] ? segment.lang : this.defaultLang;
+      if (prevLang !== null && lang !== prevLang) {
+        yield silence;
+      }
+      prevLang = lang;
+      yield* this.synthesizeSegment(lang, segment.text, signal);
+    }
+  }
+  async *synthesizeSegment(lang, text, signal) {
+    log6.debug(`Synthesizing [${lang}]: "${text.slice(0, 60)}"`);
+    await this.ensureConnection();
+    const ws = this.ws;
+    if (!ws || ws.readyState !== import_ws5.default.OPEN) {
+      throw new Error("dTelecom TTS WebSocket not connected");
+    }
+    const state = { chunks: [], done: false, cleared: false, error: null, wake: null };
+    this.flushState = state;
+    const onAbort = () => {
+      state.done = true;
+      state.wake?.();
+      if (ws.readyState === import_ws5.default.OPEN) {
+        try {
+          ws.send(JSON.stringify({ type: "clear" }));
+        } catch {
+        }
+      }
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    const voiceConfig = this.voices[lang];
+    const msg = { text };
+    if (voiceConfig) {
+      msg.voice = voiceConfig.voice;
+      msg.lang_code = voiceConfig.langCode;
+      msg.speed = this.speed;
+    }
+    ws.send(JSON.stringify(msg));
+    try {
+      while (true) {
+        if (signal?.aborted) break;
+        if (state.error) throw state.error;
+        if (state.chunks.length > 0) {
+          yield state.chunks.shift();
+          continue;
+        }
+        if (state.done) break;
+        await new Promise((resolve) => {
+          state.wake = resolve;
+        });
+        state.wake = null;
+      }
+      while (state.chunks.length > 0) {
+        yield state.chunks.shift();
+      }
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
+      this.flushState = null;
+    }
+  }
+  /** Ensure a WebSocket connection exists and is open. */
+  ensureConnection() {
+    if (this.ws && this.ws.readyState === import_ws5.default.OPEN) {
+      return Promise.resolve();
+    }
+    if (this.connectPromise) return this.connectPromise;
+    this.connectPromise = new Promise((resolve, reject) => {
+      log6.debug(`Connecting to dTelecom TTS: ${this.serverUrl}`);
+      const ws = new import_ws5.default(this.serverUrl);
+      ws.on("open", () => {
+        this.ws = ws;
+        this.connectPromise = null;
+        const defaultVoice = this.voices[this.defaultLang];
+        if (defaultVoice) {
+          ws.send(JSON.stringify({
+            config: {
+              voice: defaultVoice.voice,
+              lang_code: defaultVoice.langCode,
+              speed: this.speed
+            }
+          }));
+        }
+        log6.info("dTelecom TTS WebSocket connected");
+        resolve();
+      });
+      ws.on("message", (data, isBinary) => {
+        const state = this.flushState;
+        if (!state) return;
+        if (isBinary) {
+          const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+          const resampled = resample24to48(buf);
+          state.chunks.push(resampled);
+          state.wake?.();
+        } else {
+          try {
+            const msg = JSON.parse(data.toString());
+            if (msg.type === "done") {
+              state.done = true;
+              state.wake?.();
+            } else if (msg.type === "cleared") {
+              state.cleared = true;
+              state.done = true;
+              state.wake?.();
+            } else if (msg.type === "generating") {
+              log6.debug(`TTS generating: "${msg.text?.slice(0, 40)}"`);
+            } else if (msg.type === "error") {
+              const errorMsg = msg.message || "Unknown TTS error";
+              log6.error(`dTelecom TTS error: ${errorMsg}`);
+              state.error = new Error(errorMsg);
+              state.wake?.();
+            }
+          } catch {
+            log6.warn("Failed to parse dTelecom TTS message");
+          }
+        }
+      });
+      ws.on("error", (err) => {
+        const error = err instanceof Error ? err : new Error(String(err));
+        log6.error("dTelecom TTS WebSocket error:", error);
+        const state = this.flushState;
+        if (state) {
+          state.error = error;
+          state.wake?.();
+        }
+        this.ws = null;
+        this.connectPromise = null;
+        reject(error);
+      });
+      ws.on("close", (code, reason) => {
+        log6.debug(`dTelecom TTS WebSocket closed: ${code} ${reason.toString()}`);
+        this.ws = null;
+        this.connectPromise = null;
+        const state = this.flushState;
+        if (state) {
+          state.done = true;
+          state.wake?.();
+        }
+      });
+    });
+    return this.connectPromise;
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CartesiaTTS,
   DeepgramSTT,
   DeepgramTTS,
+  DtelecomSTT,
+  DtelecomTTS,
   OpenRouterLLM
 });
 //# sourceMappingURL=index.js.map