@dtelecom/agents-js 0.1.17 → 0.2.1

package/dist/providers/index.mjs

@@ -403,9 +403,198 @@ var OpenRouterLLM = class {
   }
 };
 
+// src/providers/openai-llm.ts
+var log3 = createLogger("OpenAILLM");
+var OPENAI_URL = "https://api.openai.com/v1/chat/completions";
+var OpenAILLM = class {
+  apiKey;
+  model;
+  maxTokens;
+  temperature;
+  responseFormat;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("OpenAILLM requires an apiKey");
+    }
+    this.apiKey = options.apiKey;
+    this.model = options.model;
+    this.maxTokens = options.maxTokens ?? 512;
+    this.temperature = options.temperature ?? 0.7;
+    this.responseFormat = options.responseFormat;
+  }
+  /**
+   * Warm up the LLM by sending the system prompt and a short message.
+   * Primes the HTTP/TLS connection and model loading on the provider side.
+   */
+  async warmup(systemPrompt) {
+    log3.info("Warming up LLM connection...");
+    const start = performance.now();
+    const messages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: "Hello" }
+    ];
+    try {
+      const gen = this.chat(messages);
+      for await (const chunk of gen) {
+        if (chunk.type === "done") break;
+      }
+      log3.info(`LLM warmup complete in ${(performance.now() - start).toFixed(0)}ms`);
+    } catch (err) {
+      log3.warn("LLM warmup failed (non-fatal):", err);
+    }
+  }
+  async *chat(messages, signal, options) {
+    const body = {
+      model: this.model,
+      messages,
+      max_tokens: this.maxTokens,
+      temperature: this.temperature,
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    if (this.responseFormat && !options?.plainText) {
+      body.response_format = this.responseFormat;
+    }
+    log3.debug(`LLM request: model=${this.model}, messages=${messages.length}`);
+    const response = await fetch(OPENAI_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`OpenAI API error ${response.status}: ${errorText}`);
+    }
+    if (!response.body) {
+      throw new Error("OpenAI response has no body");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const structured = !!this.responseFormat && !options?.plainText;
+    let jsonBuffer = "";
+    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;
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") break;
+          try {
+            const parsed = JSON.parse(data);
+            const choice = parsed.choices?.[0];
+            if (!choice) {
+              if (parsed.usage) {
+                lastUsage = {
+                  promptTokens: parsed.usage.prompt_tokens,
+                  completionTokens: parsed.usage.completion_tokens
+                };
+              }
+              continue;
+            }
+            const delta = choice.delta;
+            if (delta?.content) {
+              if (structured) {
+                jsonBuffer += delta.content;
+                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) {
+              lastUsage = {
+                promptTokens: parsed.usage.prompt_tokens,
+                completionTokens: parsed.usage.completion_tokens
+              };
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    if (structured && !segmentsYielded && jsonBuffer.length > 0) {
+      log3.warn(`LLM returned no segments. Raw JSON: "${jsonBuffer.slice(0, 300)}"`);
+    }
+    yield { type: "done", ...lastUsage ? { usage: lastUsage } : {} };
+  }
+};
+
 // src/providers/cartesia-tts.ts
 import WebSocket2 from "ws";
-var log3 = createLogger("CartesiaTTS");
+var log4 = createLogger("CartesiaTTS");
 var CARTESIA_WS_BASE = "wss://api.cartesia.ai/tts/websocket";
 var DEFAULT_API_VERSION = "2024-06-10";
 var DEFAULT_MODEL = "sonic-3";
@@ -444,7 +633,7 @@ var CartesiaTTS = class {
   /** Close the WebSocket connection to allow clean process exit. */
   close() {
     if (this.ws) {
-      log3.debug("Closing Cartesia WebSocket");
+      log4.debug("Closing Cartesia WebSocket");
       this.ws.close();
       this.ws = null;
     }
@@ -453,17 +642,17 @@ var CartesiaTTS = class {
   }
   /** Pre-connect the WebSocket so first synthesize() doesn't pay connection cost. */
   async warmup() {
-    log3.info("Warming up TTS connection...");
+    log4.info("Warming up TTS connection...");
     const start = performance.now();
     try {
       await this.ensureConnection();
-      log3.info(`TTS warmup complete in ${(performance.now() - start).toFixed(0)}ms`);
+      log4.info(`TTS warmup complete in ${(performance.now() - start).toFixed(0)}ms`);
     } catch (err) {
-      log3.warn("TTS warmup failed (non-fatal):", err);
+      log4.warn("TTS warmup failed (non-fatal):", err);
     }
   }
   async *synthesize(text, signal) {
-    log3.debug(`Synthesizing: "${text.slice(0, 60)}"`);
+    log4.debug(`Synthesizing: "${text.slice(0, 60)}"`);
     await this.ensureConnection();
     if (!this.ws || this.ws.readyState !== WebSocket2.OPEN) {
       throw new Error("Cartesia WebSocket not connected");
@@ -534,12 +723,12 @@ var CartesiaTTS = class {
     if (this.connectPromise) return this.connectPromise;
     this.connectPromise = new Promise((resolve, reject) => {
       const url = `${CARTESIA_WS_BASE}?api_key=${this.apiKey}&cartesia_version=${this.apiVersion}`;
-      log3.debug("Connecting to Cartesia...");
+      log4.debug("Connecting to Cartesia...");
       this.ws = new WebSocket2(url);
       this.ws.on("open", () => {
         this._connected = true;
         this.connectPromise = null;
-        log3.info("Cartesia WebSocket connected");
+        log4.info("Cartesia WebSocket connected");
         resolve();
       });
       this.ws.on("message", (data) => {
@@ -547,12 +736,12 @@ var CartesiaTTS = class {
           const msg = JSON.parse(data.toString());
           this.handleMessage(msg);
         } catch (err) {
-          log3.error("Failed to parse Cartesia message:", err);
+          log4.error("Failed to parse Cartesia message:", err);
         }
       });
       this.ws.on("error", (err) => {
         const error = err instanceof Error ? err : new Error(String(err));
-        log3.error("Cartesia WebSocket error:", error);
+        log4.error("Cartesia WebSocket error:", error);
         for (const ctx of this.contexts.values()) {
           ctx.error = error;
           ctx.wake?.();
@@ -562,7 +751,7 @@ var CartesiaTTS = class {
         reject(error);
       });
       this.ws.on("close", (code, reason) => {
-        log3.debug(`Cartesia WebSocket closed: ${code} ${reason.toString()}`);
+        log4.debug(`Cartesia WebSocket closed: ${code} ${reason.toString()}`);
         this._connected = false;
         this.connectPromise = null;
         for (const ctx of this.contexts.values()) {
@@ -587,12 +776,12 @@ var CartesiaTTS = class {
         ctx.wake?.();
       }
     } else if (type === "done") {
-      log3.debug(`Cartesia synthesis done for ${contextId} (${ctx.chunks.length} chunks pending)`);
+      log4.debug(`Cartesia synthesis done for ${contextId} (${ctx.chunks.length} chunks pending)`);
       ctx.done = true;
       ctx.wake?.();
     } else if (type === "error") {
       const errorMsg = msg.error ?? "Unknown Cartesia error";
-      log3.error(`Cartesia error for ${contextId}: ${errorMsg}`);
+      log4.error(`Cartesia error for ${contextId}: ${errorMsg}`);
       ctx.error = new Error(`Cartesia TTS error: ${errorMsg}`);
       ctx.wake?.();
     }
@@ -601,7 +790,7 @@ var CartesiaTTS = class {
 
 // src/providers/deepgram-tts.ts
 import WebSocket3 from "ws";
-var log4 = createLogger("DeepgramTTS");
+var log5 = createLogger("DeepgramTTS");
 var DEEPGRAM_WS_BASE = "wss://api.deepgram.com/v1/speak";
 var DEFAULT_SAMPLE_RATE2 = 48e3;
 function parseLangSegments(text, defaultLang) {
@@ -698,7 +887,7 @@ var DeepgramTTS = class {
   /** Close all WebSocket connections to allow clean process exit. */
   close() {
     for (const [lang, ws] of this.connections) {
-      log4.debug(`Closing WebSocket for [${lang}]`);
+      log5.debug(`Closing WebSocket for [${lang}]`);
       ws.close();
     }
     this.connections.clear();
@@ -707,13 +896,13 @@ var DeepgramTTS = class {
   }
   /** Pre-connect all language WebSocket connections. */
   async warmup() {
-    log4.info("Warming up TTS connections...");
+    log5.info("Warming up TTS connections...");
     const start = performance.now();
     try {
       await Promise.all(Object.keys(this.models).map((lang) => this.ensureConnection(lang)));
-      log4.info(`TTS warmup complete in ${(performance.now() - start).toFixed(0)}ms`);
+      log5.info(`TTS warmup complete in ${(performance.now() - start).toFixed(0)}ms`);
     } catch (err) {
-      log4.warn("TTS warmup failed (non-fatal):", err);
+      log5.warn("TTS warmup failed (non-fatal):", err);
     }
   }
   /** Strip SSML lang tags from text for display/events. */
@@ -746,7 +935,7 @@ var DeepgramTTS = class {
     }
   }
   async *synthesizeSegment(lang, text, signal) {
-    log4.debug(`Synthesizing [${lang}]: "${text.slice(0, 60)}"`);
+    log5.debug(`Synthesizing [${lang}]: "${text.slice(0, 60)}"`);
     await this.ensureConnection(lang);
     const ws = this.connections.get(lang);
     if (!ws || ws.readyState !== WebSocket3.OPEN) {
@@ -804,7 +993,7 @@ var DeepgramTTS = class {
     }
     const promise = new Promise((resolve, reject) => {
       const url = `${DEEPGRAM_WS_BASE}?model=${encodeURIComponent(model)}&encoding=linear16&sample_rate=${this.sampleRate}`;
-      log4.debug(`Connecting to Deepgram for [${lang}]: ${model}`);
+      log5.debug(`Connecting to Deepgram for [${lang}]: ${model}`);
       const ws = new WebSocket3(url, {
         headers: {
           Authorization: `Token ${this.apiKey}`
@@ -813,7 +1002,7 @@ var DeepgramTTS = class {
       ws.on("open", () => {
         this.connections.set(lang, ws);
         this.connectPromises.delete(lang);
-        log4.info(`Deepgram WebSocket connected for [${lang}] (${model})`);
+        log5.info(`Deepgram WebSocket connected for [${lang}] (${model})`);
         resolve();
       });
       ws.on("message", (data, isBinary) => {
@@ -830,16 +1019,16 @@ var DeepgramTTS = class {
               state.flushed = true;
               state.wake?.();
             } else if (msg.type === "Warning" || msg.type === "Error") {
-              log4.warn(`Deepgram [${lang}] ${msg.type}: ${msg.description || msg.message || JSON.stringify(msg)}`);
+              log5.warn(`Deepgram [${lang}] ${msg.type}: ${msg.description || msg.message || JSON.stringify(msg)}`);
             }
           } catch {
-            log4.warn(`Failed to parse Deepgram message for [${lang}]`);
+            log5.warn(`Failed to parse Deepgram message for [${lang}]`);
           }
         }
       });
       ws.on("error", (err) => {
         const error = err instanceof Error ? err : new Error(String(err));
-        log4.error(`Deepgram WebSocket error [${lang}]:`, error);
+        log5.error(`Deepgram WebSocket error [${lang}]:`, error);
         const state = this.flushStates.get(lang);
         if (state) {
           state.error = error;
@@ -850,7 +1039,7 @@ var DeepgramTTS = class {
         reject(error);
       });
       ws.on("close", (code, reason) => {
-        log4.debug(`Deepgram WebSocket closed [${lang}]: ${code} ${reason.toString()}`);
+        log5.debug(`Deepgram WebSocket closed [${lang}]: ${code} ${reason.toString()}`);
         this.connections.delete(lang);
         this.connectPromises.delete(lang);
         const state = this.flushStates.get(lang);
@@ -867,7 +1056,7 @@ var DeepgramTTS = class {
 
 // src/providers/dtelecom-stt.ts
 import WebSocket4 from "ws";
-var log5 = createLogger("DtelecomSTT");
+var log6 = createLogger("DtelecomSTT");
 var KEEPALIVE_INTERVAL_MS2 = 5e3;
 var DtelecomSTT = class {
   options;
@@ -875,6 +1064,9 @@ var DtelecomSTT = class {
     if (!options.serverUrl) {
       throw new Error("DtelecomSTT requires a serverUrl");
     }
+    if (!options.sessionKey) {
+      throw new Error("DtelecomSTT requires a sessionKey");
+    }
     this.options = options;
   }
   createStream(options) {
@@ -885,6 +1077,7 @@ var DtelecomSTT = class {
 var DtelecomSTTStream = class extends BaseSTTStream {
   ws = null;
   serverUrl;
+  sessionKey;
   forceWhisper;
   _ready = false;
   _closed = false;
@@ -894,6 +1087,7 @@ var DtelecomSTTStream = class extends BaseSTTStream {
   constructor(options, language) {
     super();
     this.serverUrl = options.serverUrl;
+    this.sessionKey = options.sessionKey;
     this.language = language;
     this.forceWhisper = options.forceWhisper ?? false;
     this.connect();
@@ -921,7 +1115,7 @@ var DtelecomSTTStream = class extends BaseSTTStream {
     }
     if (this.ws?.readyState === WebSocket4.OPEN) {
       this.ws.send(JSON.stringify(config));
-      log5.info(`Reconfiguring STT: language=${language}${options?.forceWhisper ? ", model=whisper" : ""}`);
+      log6.info(`Reconfiguring STT: language=${language}${options?.forceWhisper ? ", model=whisper" : ""}`);
     }
   }
   async close() {
@@ -934,14 +1128,20 @@ var DtelecomSTTStream = class extends BaseSTTStream {
       this.ws.close();
       this.ws = null;
     }
-    log5.debug("DtelecomSTT stream closed");
+    log6.debug("DtelecomSTT stream closed");
   }
   connect() {
-    log5.debug(`Connecting to dTelecom STT: ${this.serverUrl}`);
-    this.ws = new WebSocket4(this.serverUrl);
+    const url = this.serverUrl.replace(/\/$/, "") + "/v1/stream";
+    const wsUrl = url.replace("https://", "wss://").replace("http://", "ws://");
+    log6.debug(`Connecting to dTelecom STT: ${wsUrl}`);
+    this.ws = new WebSocket4(wsUrl);
     this.ws.on("open", () => {
-      log5.info("dTelecom STT WebSocket connected");
-      const config = { type: "config", language: this.language };
+      log6.info("dTelecom STT WebSocket connected");
+      const config = {
+        type: "config",
+        language: this.language,
+        session_key: this.sessionKey
+      };
       if (this.forceWhisper) {
         config.model = "whisper";
       }
@@ -953,19 +1153,19 @@ var DtelecomSTTStream = class extends BaseSTTStream {
         const msg = JSON.parse(data.toString());
         this.handleMessage(msg);
       } catch (err) {
-        log5.error("Failed to parse dTelecom STT message:", err);
+        log6.error("Failed to parse dTelecom STT message:", err);
       }
     });
     this.ws.on("error", (err) => {
-      log5.error("dTelecom STT WebSocket error:", err);
+      log6.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()}`);
+      log6.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...");
+        log6.info("dTelecom STT connection lost, reconnecting in 1s...");
         setTimeout(() => {
           if (!this._closed) this.connect();
         }, 1e3);
@@ -984,14 +1184,14 @@ var DtelecomSTTStream = class extends BaseSTTStream {
     } 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}`);
+      log6.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}`);
+    log6.info(`dTelecom STT ready: client_id=${clientId}, language=${lang}`);
     this._ready = true;
     for (const buf of this.pendingAudio) {
       if (this.ws?.readyState === WebSocket4.OPEN) {
@@ -1008,7 +1208,7 @@ var DtelecomSTTStream = class extends BaseSTTStream {
     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)}"`);
+      log6.info(`stt_final: ${latencyMs.toFixed(0)}ms "${text.slice(0, 50)}"`);
     }
     this.emit("transcription", {
       text,
@@ -1019,7 +1219,7 @@ var DtelecomSTTStream = class extends BaseSTTStream {
   }
   handleVadEvent(msg) {
     const event = msg.event;
-    log5.debug(`VAD event: ${event}`);
+    log6.debug(`VAD event: ${event}`);
     if (event === "speech_start") {
       this.emit("transcription", {
         text: "",
@@ -1045,9 +1245,10 @@ var DtelecomSTTStream = class extends BaseSTTStream {
 
 // src/providers/dtelecom-tts.ts
 import WebSocket5 from "ws";
-var log6 = createLogger("DtelecomTTS");
+var log7 = createLogger("DtelecomTTS");
 var DtelecomTTS = class {
   serverUrl;
+  sessionKey;
   voices;
   defaultLang;
   speed;
@@ -1062,29 +1263,33 @@ var DtelecomTTS = class {
     if (!options.serverUrl) {
       throw new Error("DtelecomTTS requires a serverUrl");
     }
+    if (!options.sessionKey) {
+      throw new Error("DtelecomTTS requires a sessionKey");
+    }
     if (!options.voices || Object.keys(options.voices).length === 0) {
       throw new Error("DtelecomTTS requires at least one voice config");
     }
     this.serverUrl = options.serverUrl;
+    this.sessionKey = options.sessionKey;
     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...");
+    log7.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`);
+      log7.info(`TTS warmup complete in ${(performance.now() - start).toFixed(0)}ms`);
     } catch (err) {
-      log6.warn("TTS warmup failed (non-fatal):", err);
+      log7.warn("TTS warmup failed (non-fatal):", err);
     }
   }
   /** Close WebSocket connection. */
   close() {
     if (this.ws) {
-      log6.debug("Closing TTS WebSocket");
+      log7.debug("Closing TTS WebSocket");
       this.ws.close();
       this.ws = null;
     }
@@ -1146,7 +1351,7 @@ var DtelecomTTS = class {
       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)}"`);
+    log7.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) {
@@ -1177,22 +1382,26 @@ var DtelecomTTS = class {
     }
     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);
+      const url = this.serverUrl.replace(/\/$/, "") + "/v1/stream";
+      const wsUrl = url.replace("https://", "wss://").replace("http://", "ws://");
+      log7.debug(`Connecting to dTelecom TTS: ${wsUrl}`);
+      const ws = new WebSocket5(wsUrl);
       ws.on("open", () => {
         this.ws = ws;
         this.connectPromise = null;
         const defaultVoice = this.voices[this.defaultLang];
+        const msg = {
+          session_key: this.sessionKey
+        };
         if (defaultVoice) {
-          ws.send(JSON.stringify({
-            config: {
-              voice: defaultVoice.voice,
-              lang_code: defaultVoice.langCode,
-              speed: this.speed
-            }
-          }));
+          msg.config = {
+            voice: defaultVoice.voice,
+            lang_code: defaultVoice.langCode,
+            speed: this.speed
+          };
         }
-        log6.info("dTelecom TTS WebSocket connected");
+        ws.send(JSON.stringify(msg));
+        log7.info("dTelecom TTS WebSocket connected");
         resolve();
       });
       ws.on("message", (data, isBinary) => {
@@ -1213,21 +1422,21 @@ var DtelecomTTS = class {
               state.done = true;
               state.wake?.();
             } else if (msg.type === "generating") {
-              log6.debug(`TTS generating: "${msg.text?.slice(0, 40)}"`);
+              log7.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}`);
+              log7.error(`dTelecom TTS error: ${errorMsg}`);
               state.error = new Error(errorMsg);
               state.wake?.();
             }
           } catch {
-            log6.warn("Failed to parse dTelecom TTS message");
+            log7.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);
+        log7.error("dTelecom TTS WebSocket error:", error);
         const state = this.flushState;
         if (state) {
           state.error = error;
@@ -1238,7 +1447,7 @@ var DtelecomTTS = class {
         reject(error);
       });
       ws.on("close", (code, reason) => {
-        log6.debug(`dTelecom TTS WebSocket closed: ${code} ${reason.toString()}`);
+        log7.debug(`dTelecom TTS WebSocket closed: ${code} ${reason.toString()}`);
         this.ws = null;
         this.connectPromise = null;
         const state = this.flushState;
@@ -1257,6 +1466,7 @@ export {
   DeepgramTTS,
   DtelecomSTT,
   DtelecomTTS,
+  OpenAILLM,
   OpenRouterLLM
 };
 //# sourceMappingURL=index.mjs.map