@dtelecom/agents-js 0.2.1 → 0.3.0

package/dist/index.mjs

@@ -621,6 +621,49 @@ var AUDIO_DRAIN_MS = 800;
 function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function prefetchTTS(tts, text, signal) {
+  const buffer = [];
+  let done = false;
+  let error = null;
+  let wake = null;
+  const notify = () => {
+    if (wake) {
+      const w = wake;
+      wake = null;
+      w();
+    }
+  };
+  void (async () => {
+    try {
+      const stream = tts.synthesize(text, signal);
+      for await (const chunk of stream) {
+        if (signal?.aborted) break;
+        buffer.push(chunk);
+        notify();
+      }
+    } catch (e) {
+      if (!(e instanceof Error && e.name === "AbortError")) error = e;
+    } finally {
+      done = true;
+      notify();
+    }
+  })();
+  return async function* () {
+    let index = 0;
+    while (true) {
+      if (signal?.aborted) return;
+      if (error) throw error;
+      if (index < buffer.length) {
+        yield buffer[index++];
+        continue;
+      }
+      if (done) return;
+      await new Promise((r) => {
+        wake = r;
+      });
+    }
+  };
+}
 var Pipeline = class extends EventEmitter {
   stt;
   llm;
@@ -635,6 +678,7 @@ var Pipeline = class extends EventEmitter {
   nameVariants;
   beforeRespond;
   memory;
+  tools;
   /** Strip provider-specific markup (e.g. SSML lang tags) for display. */
   cleanText(text) {
     return this.tts?.cleanText ? this.tts.cleanText(text) : text;
@@ -657,6 +701,7 @@ var Pipeline = class extends EventEmitter {
     this.nameVariants = (options.nameVariants ?? []).map((n) => n.toLowerCase());
     this.beforeRespond = options.beforeRespond;
     this.memory = options.memory;
+    this.tools = options.tools;
     this.context = new ContextManager({
       instructions: options.instructions,
       maxContextTokens: options.maxContextTokens
@@ -673,28 +718,18 @@ var Pipeline = class extends EventEmitter {
       this.splitter.reset();
       this.setAgentState("idle");
     };
-    this._warmupPromise = this.warmup(options.instructions);
+    this._ttsWarmupPromise = this.tts?.warmup ? this.tts.warmup().catch((err) => {
+      log7.warn("TTS warmup failed (non-fatal):", err);
+    }) : Promise.resolve();
+    this._llmWarmupPromise = this.llm.warmup ? this.llm.warmup(options.instructions).catch((err) => {
+      log7.warn("LLM warmup failed (non-fatal):", err);
+    }) : Promise.resolve();
+    this._warmupPromise = Promise.all([this._ttsWarmupPromise, this._llmWarmupPromise]).then(() => {
+    });
   }
-  /** One-shot warmup — safe to call from constructor, resolves when both LLM and TTS are ready. */
   _warmupPromise;
-  async warmup(instructions) {
-    const tasks = [];
-    if (this.llm.warmup) {
-      tasks.push(
-        this.llm.warmup(instructions).catch((err) => {
-          log7.warn("LLM warmup failed:", err);
-        })
-      );
-    }
-    if (this.tts?.warmup) {
-      tasks.push(
-        this.tts.warmup().catch((err) => {
-          log7.warn("TTS warmup failed:", err);
-        })
-      );
-    }
-    await Promise.all(tasks);
-  }
+  _ttsWarmupPromise;
+  _llmWarmupPromise;
   get processing() {
     return this._processing;
   }
@@ -870,7 +905,7 @@ var Pipeline = class extends EventEmitter {
             segBuf.length = 0;
             pushSentence(combined);
           };
-          const llmStream = this.llm.chat(messages, signal);
+          const llmStream = this.llm.chat(messages, signal, { tools: this.tools });
           try {
             while (!signal.aborted) {
               const { value: chunk, done } = await llmStream.next();
@@ -899,6 +934,9 @@ var Pipeline = class extends EventEmitter {
                 for (const sentence of sentences) {
                   pushSentence(sentence);
                 }
+              } else if (chunk.type === "tool_call" && chunk.toolCall) {
+                log7.info(`Tool call: ${chunk.toolCall.name}(${chunk.toolCall.arguments})`);
+                this.emit("toolCall", chunk.toolCall);
               }
             }
           } finally {
@@ -921,29 +959,55 @@ var Pipeline = class extends EventEmitter {
       };
       const consumer = async () => {
         this.audioOutput.beginResponse();
+        const state = { prefetched: null };
         try {
           while (true) {
             if (signal.aborted) break;
-            if (sentenceQueue.length > 0) {
-              const sentence = sentenceQueue.shift();
+            let sentence;
+            let existingStream;
+            if (state.prefetched) {
+              sentence = state.prefetched.sentence;
+              existingStream = state.prefetched.streamFn();
+              state.prefetched = null;
+            } else if (sentenceQueue.length > 0) {
+              sentence = sentenceQueue.shift();
               if (!/\w/.test(sentence)) {
                 log7.debug(`Skipping non-word sentence: "${sentence}"`);
                 continue;
               }
+              existingStream = void 0;
+            } else if (producerDone) {
+              break;
+            } else {
+              await new Promise((resolve) => {
+                wakeConsumer = resolve;
+              });
+              wakeConsumer = null;
+              continue;
+            }
+            const tryPrefetch = () => {
+              if (state.prefetched || !this.tts) return;
+              if (sentenceQueue.length > 0) {
+                const next = sentenceQueue.shift();
+                if (/\w/.test(next)) {
+                  state.prefetched = { sentence: next, streamFn: prefetchTTS(this.tts, next, signal) };
+                }
+              }
+            };
+            tryPrefetch();
+            try {
               await this.synthesizeAndPlay(sentence, signal, (t) => {
                 if (!tFirstAudioPlayed) {
                   tFirstAudioPlayed = t;
                   this.setAgentState("speaking");
                 }
                 this.emit("sentence", this.cleanText(sentence), sentence);
-              });
-              continue;
+                tryPrefetch();
+              }, existingStream);
+            } catch (ttsErr) {
+              if (ttsErr instanceof Error && ttsErr.name === "AbortError") throw ttsErr;
+              log7.warn(`TTS error for sentence (skipping): "${sentence.slice(0, 40)}"`, ttsErr);
             }
-            if (producerDone) break;
-            await new Promise((resolve) => {
-              wakeConsumer = resolve;
-            });
-            wakeConsumer = null;
           }
         } finally {
           if (!signal.aborted) {
@@ -996,7 +1060,7 @@ var Pipeline = class extends EventEmitter {
       return;
     }
     this._processing = true;
-    await this._warmupPromise;
+    await this._ttsWarmupPromise;
     log7.info(`say(): "${text.slice(0, 60)}"`);
     try {
       const signal = this.bargeIn.startCycle();
@@ -1033,7 +1097,7 @@ var Pipeline = class extends EventEmitter {
       }
     }
   }
-  async synthesizeAndPlay(text, signal, onFirstAudio) {
+  async synthesizeAndPlay(text, signal, onFirstAudio, existingStream) {
     if (!this.tts || signal.aborted) {
       log7.info(`[Agent says]: ${text}`);
       return;
@@ -1042,7 +1106,7 @@ var Pipeline = class extends EventEmitter {
       const ttsStart = performance.now();
       let firstChunk = true;
       let ttsChunkCount = 0;
-      const ttsStream = this.tts.synthesize(text, signal);
+      const ttsStream = existingStream ?? this.tts.synthesize(text, signal);
       const measuredStream = async function* () {
         for await (const chunk of ttsStream) {
           ttsChunkCount++;
@@ -1150,12 +1214,14 @@ var VoiceAgent = class extends EventEmitter2 {
       agentName: this.config.agentName,
       nameVariants: this.config.nameVariants,
       memory: this.memory ?? void 0,
-      maxContextTokens: this.config.maxContextTokens
+      maxContextTokens: this.config.maxContextTokens,
+      tools: this.config.tools
     });
     this.pipeline.on("transcription", (result) => this.emit("transcription", result));
     this.pipeline.on("sentence", (text, raw) => this.emit("sentence", text, raw));
     this.pipeline.on("response", (text) => this.emit("response", text));
     this.pipeline.on("agentState", (state) => this.emit("agentState", state));
+    this.pipeline.on("toolCall", (tc) => this.emit("toolCall", tc));
     this.pipeline.on("error", (error) => this.emit("error", error));
     for (const participant of this.connection.room.remoteParticipants.values()) {
       for (const [, pub] of participant.trackPublications) {