@dtelecom/agents-js 0.1.13 → 0.1.15

package/dist/providers/index.mjs

@@ -815,10 +815,402 @@ var DeepgramTTS = class {
     return promise;
   }
 };
+
+// src/providers/dtelecom-stt.ts
+import WebSocket4 from "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 === WebSocket4.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 === WebSocket4.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 WebSocket4(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 === WebSocket4.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 === WebSocket4.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
+import WebSocket5 from "ws";
+import { resample } from "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 = 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 !== WebSocket5.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 === WebSocket5.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 === WebSocket5.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 WebSocket5(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;
+  }
+};
 export {
   CartesiaTTS,
   DeepgramSTT,
   DeepgramTTS,
+  DtelecomSTT,
+  DtelecomTTS,
   OpenRouterLLM
 };
 //# sourceMappingURL=index.mjs.map