@dtelecom/agents-js 0.2.0 → 0.2.2

package/dist/index.d.mts

@@ -121,9 +121,9 @@ declare class Pipeline extends EventEmitter {
     /** Queued turn while current one is still processing */
     private pendingTurn;
     constructor(options: PipelineOptions);
-    /** One-shot warmup — safe to call from constructor, resolves when both LLM and TTS are ready. */
-    private _warmupPromise;
-    private warmup;
+    private readonly _warmupPromise;
+    private readonly _ttsWarmupPromise;
+    private readonly _llmWarmupPromise;
     get processing(): boolean;
     get running(): boolean;
     get agentState(): AgentState;

package/dist/index.d.ts

@@ -121,9 +121,9 @@ declare class Pipeline extends EventEmitter {
     /** Queued turn while current one is still processing */
     private pendingTurn;
     constructor(options: PipelineOptions);
-    /** One-shot warmup — safe to call from constructor, resolves when both LLM and TTS are ready. */
-    private _warmupPromise;
-    private warmup;
+    private readonly _warmupPromise;
+    private readonly _ttsWarmupPromise;
+    private readonly _llmWarmupPromise;
     get processing(): boolean;
     get running(): boolean;
     get agentState(): AgentState;

package/dist/index.js

@@ -1151,6 +1151,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 import_events.EventEmitter {
   stt;
   llm;
@@ -1203,28 +1246,18 @@ var Pipeline = class extends import_events.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;
   }
@@ -1451,29 +1484,50 @@ var Pipeline = class extends import_events.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;
               }
-              await this.synthesizeAndPlay(sentence, signal, (t) => {
-                if (!tFirstAudioPlayed) {
-                  tFirstAudioPlayed = t;
-                  this.setAgentState("speaking");
-                }
-                this.emit("sentence", this.cleanText(sentence), sentence);
+              existingStream = void 0;
+            } else if (producerDone) {
+              break;
+            } else {
+              await new Promise((resolve) => {
+                wakeConsumer = resolve;
               });
+              wakeConsumer = null;
               continue;
             }
-            if (producerDone) break;
-            await new Promise((resolve) => {
-              wakeConsumer = resolve;
-            });
-            wakeConsumer = null;
+            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();
+            await this.synthesizeAndPlay(sentence, signal, (t) => {
+              if (!tFirstAudioPlayed) {
+                tFirstAudioPlayed = t;
+                this.setAgentState("speaking");
+              }
+              this.emit("sentence", this.cleanText(sentence), sentence);
+              tryPrefetch();
+            }, existingStream);
           }
         } finally {
           if (!signal.aborted) {
@@ -1526,7 +1580,7 @@ var Pipeline = class extends import_events.EventEmitter {
       return;
     }
     this._processing = true;
-    await this._warmupPromise;
+    await this._ttsWarmupPromise;
     log7.info(`say(): "${text.slice(0, 60)}"`);
     try {
       const signal = this.bargeIn.startCycle();
@@ -1563,7 +1617,7 @@ var Pipeline = class extends import_events.EventEmitter {
       }
     }
   }
-  async synthesizeAndPlay(text, signal, onFirstAudio) {
+  async synthesizeAndPlay(text, signal, onFirstAudio, existingStream) {
     if (!this.tts || signal.aborted) {
       log7.info(`[Agent says]: ${text}`);
       return;
@@ -1572,7 +1626,7 @@ var Pipeline = class extends import_events.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++;