@dtelecom/agents-js 0.1.14 → 0.1.16

package/dist/providers/index.mjs

@@ -296,8 +296,63 @@ var OpenRouterLLM = class {
     let buffer = "";
     const structured = !!this.responseFormat;
     let jsonBuffer = "";
-    let lastSegmentIndex = 0;
-    const segmentRe = /\{"lang"\s*:\s*"(\w+)"\s*,\s*"text"\s*:\s*"((?:[^"\\]|\\.)*)"\s*\}/g;
+    let segmentsYielded = false;
+    let lastUsage;
+    let inSegmentsArray = false;
+    let objectStart = -1;
+    let braceDepth = 0;
+    let scanIndex = 0;
+    let inString = false;
+    let escaped = false;
+    function extractSegments(buf) {
+      const results = [];
+      for (let i = scanIndex; i < buf.length; i++) {
+        const ch = buf[i];
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\" && inString) {
+          escaped = true;
+          continue;
+        }
+        if (ch === '"') {
+          inString = !inString;
+          continue;
+        }
+        if (inString) continue;
+        if (!inSegmentsArray) {
+          if (ch === "[") {
+            const before = buf.slice(0, i).trimEnd();
+            if (before.endsWith(":") && buf.slice(0, i).includes('"segments"')) {
+              inSegmentsArray = true;
+            }
+          }
+          continue;
+        }
+        if (ch === "{") {
+          if (braceDepth === 0) objectStart = i;
+          braceDepth++;
+        } else if (ch === "}") {
+          braceDepth--;
+          if (braceDepth === 0 && objectStart >= 0) {
+            const objStr = buf.slice(objectStart, i + 1);
+            try {
+              const seg = JSON.parse(objStr);
+              if (seg.lang && seg.text) {
+                results.push({ lang: seg.lang, text: seg.text });
+              }
+            } catch {
+            }
+            objectStart = -1;
+          }
+        } else if (ch === "]" && braceDepth === 0) {
+          inSegmentsArray = false;
+        }
+      }
+      scanIndex = buf.length;
+      return results;
+    }
     try {
       while (true) {
         if (signal?.aborted) break;
@@ -310,10 +365,7 @@ var OpenRouterLLM = class {
           const trimmed = line.trim();
           if (!trimmed || !trimmed.startsWith("data: ")) continue;
           const data = trimmed.slice(6);
-          if (data === "[DONE]") {
-            yield { type: "done" };
-            return;
-          }
+          if (data === "[DONE]") break;
           try {
             const parsed = JSON.parse(data);
             const choice = parsed.choices?.[0];
@@ -322,31 +374,20 @@ var OpenRouterLLM = class {
             if (delta?.content) {
               if (structured) {
                 jsonBuffer += delta.content;
-                segmentRe.lastIndex = lastSegmentIndex;
-                let match;
-                while ((match = segmentRe.exec(jsonBuffer)) !== null) {
-                  const lang = match[1];
-                  const text = match[2].replace(/\\(.)/g, (_, c) => {
-                    if (c === "n") return "\n";
-                    if (c === "t") return "	";
-                    return c;
-                  });
-                  lastSegmentIndex = segmentRe.lastIndex;
-                  yield { type: "segment", segment: { lang, text } };
+                const segments = extractSegments(jsonBuffer);
+                for (const seg of segments) {
+                  yield { type: "segment", segment: seg };
+                  segmentsYielded = true;
                 }
               } else {
                 yield { type: "token", token: delta.content };
               }
             }
             if (parsed.usage) {
-              yield {
-                type: "done",
-                usage: {
-                  promptTokens: parsed.usage.prompt_tokens,
-                  completionTokens: parsed.usage.completion_tokens
-                }
+              lastUsage = {
+                promptTokens: parsed.usage.prompt_tokens,
+                completionTokens: parsed.usage.completion_tokens
               };
-              return;
             }
           } catch {
           }
@@ -355,10 +396,10 @@ var OpenRouterLLM = class {
     } finally {
       reader.releaseLock();
     }
-    if (structured && lastSegmentIndex === 0 && jsonBuffer.length > 0) {
-      log2.warn(`Structured response yielded no segments. Raw buffer (first 200 chars): "${jsonBuffer.slice(0, 200)}"`);
+    if (structured && !segmentsYielded && jsonBuffer.length > 0) {
+      log2.warn(`LLM returned no segments. Raw JSON: "${jsonBuffer.slice(0, 300)}"`);
     }
-    yield { type: "done" };
+    yield { type: "done", ...lastUsage ? { usage: lastUsage } : {} };
   }
 };
 
@@ -681,13 +722,21 @@ var DeepgramTTS = class {
   }
   async *synthesize(text, signal) {
     if (signal?.aborted) return;
-    const segments = this.multiLanguage ? parseLangSegments(text, this.defaultLang) : [{ lang: this.defaultLang, text }];
+    const rawSegments = this.multiLanguage ? parseLangSegments(text, this.defaultLang) : [{ lang: this.defaultLang, text }];
+    const segments = [];
+    for (const seg of rawSegments) {
+      if (!seg.text.trim()) continue;
+      if (!/\p{L}/u.test(seg.text) && segments.length > 0) {
+        segments[segments.length - 1].text += seg.text;
+      } else {
+        segments.push(seg);
+      }
+    }
     const silenceBytes = Math.round(this.sampleRate * 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.models[segment.lang] ? segment.lang : this.defaultLang;
       if (prevLang !== null && lang !== prevLang) {
         yield silence;
@@ -815,10 +864,399 @@ 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 errData = msg.error;
+      const errorMsg = msg.message || (typeof errData === "string" ? errData : JSON.stringify(errData)) || "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";
+var log6 = createLogger("DtelecomTTS");
+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 rawSegments = parseLangSegments(text, this.defaultLang);
+    const segments = [];
+    for (const seg of rawSegments) {
+      if (!seg.text.trim()) continue;
+      if (!/\p{L}/u.test(seg.text) && segments.length > 0) {
+        segments[segments.length - 1].text += seg.text;
+      } else {
+        segments.push(seg);
+      }
+    }
+    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;
+      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) {
+    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;
+    }
+    log6.info(`TTS send [${lang}]: voice=${voiceConfig?.voice ?? "default"} lang_code=${voiceConfig?.langCode ?? "default"} "${text.slice(0, 60)}"`);
+    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);
+          state.chunks.push(buf);
+          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