open-agents-ai 0.103.79 → 0.103.81

package/dist/index.js

@@ -19134,7 +19134,8 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
           if (!choice)
             break;
           const msg = choice.message;
-          const isEmptyResponse = (!msg.content || !msg.content.trim()) && (!msg.toolCalls || msg.toolCalls.length === 0);
+          const isThinkOnly = response._thinkOnly === true;
+          const isEmptyResponse = !isThinkOnly && (!msg.content || !msg.content.trim()) && (!msg.toolCalls || msg.toolCalls.length === 0);
           if (isEmptyResponse) {
             consecutiveEmptyResponses++;
             if (consecutiveEmptyResponses >= 2) {
@@ -20970,6 +20971,8 @@ ${transcript}`
         }
         this.emit({ type: "stream_end", content, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
         const cleanContent = content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+        const hadThinking = content.includes("<think>") && content.includes("</think>");
+        const thinkOnlyResponse = hadThinking && !cleanContent;
         const toolCalls = toolCallAccumulators.size > 0 ? Array.from(toolCallAccumulators.values()).map((tc) => {
           let args;
           try {
@@ -20980,10 +20983,20 @@ ${transcript}`
           }
           return { id: tc.id, name: tc.name, arguments: args };
         }) : void 0;
-        return {
-          choices: [{ message: { content: cleanContent || null, toolCalls } }],
+        const resp = {
+          choices: [{
+            message: {
+              // For think-only responses, include a marker so the model knows it already
+              // thought about this (prevents infinite think loops without visible output)
+              content: thinkOnlyResponse ? "[Your previous response was internal reasoning only. Now respond with visible text or a tool call.]" : cleanContent || null,
+              toolCalls
+            }
+          }],
           usage: streamUsage
         };
+        if (thinkOnlyResponse)
+          resp._thinkOnly = true;
+        return resp;
       }
     };
     OllamaAgenticBackend = class {
@@ -38944,6 +38957,19 @@ var init_voice = __esm({
         this.config = null;
         this.mlxActive = false;
         this.luxttsActive = false;
+        if (this._luxttsDaemon && !this._luxttsDaemon.killed) {
+          try {
+            this._luxttsDaemon.stdin.write('{"action":"quit"}\n');
+          } catch {
+          }
+          setTimeout(() => {
+            try {
+              this._luxttsDaemon?.kill();
+            } catch {
+            }
+          }, 2e3);
+        }
+        this._luxttsDaemon = null;
       }
       // -------------------------------------------------------------------------
       // Text chunking for long TTS input
@@ -39471,6 +39497,23 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         if (existsSync34(venvPy)) {
           try {
             execSync27(`${venvPy} -c "import sys; sys.path.insert(0, '${luxttsRepoDir()}'); from zipvoice.luxvoice import LuxTTS; print('ok')"`, { stdio: "pipe", timeout: 3e4 });
+            let hasCudaSys = false;
+            try {
+              execSync27("nvidia-smi", { stdio: "pipe", timeout: 5e3 });
+              hasCudaSys = true;
+            } catch {
+            }
+            if (hasCudaSys) {
+              try {
+                const torchCheck = execSync27(`${venvPy} -c "import torch; print('cuda' if torch.cuda.is_available() else 'cpu')"`, { stdio: "pipe", timeout: 15e3 }).toString().trim();
+                if (torchCheck === "cpu") {
+                  renderWarning("GPU detected but PyTorch is CPU-only. Reinstalling with CUDA support...");
+                  execSync27(`${JSON.stringify(venvPy)} -m pip install --quiet --force-reinstall torch torchaudio --index-url https://download.pytorch.org/whl/cu124`, { stdio: "pipe", timeout: 6e5 });
+                  renderInfo("PyTorch reinstalled with CUDA GPU support.");
+                }
+              } catch {
+              }
+            }
             this.writeLuxttsInferScript();
             this.autoDetectCloneRef();
             return;
@@ -39490,14 +39533,33 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
             throw new Error(`Failed to create venv: ${err instanceof Error ? err.message : String(err)}`);
           }
         }
-        renderInfo("  Installing PyTorch (CPU)...");
+        let hasCuda = false;
         try {
-          execSync27(`${JSON.stringify(venvPy)} -m pip install --quiet torch torchaudio --index-url https://download.pytorch.org/whl/cpu`, { stdio: "pipe", timeout: 6e5 });
-        } catch (err) {
+          execSync27("nvidia-smi", { stdio: "pipe", timeout: 5e3 });
+          hasCuda = true;
+        } catch {
+        }
+        if (hasCuda) {
+          renderInfo("  Installing PyTorch (CUDA GPU)...");
           try {
-            execSync27(`${JSON.stringify(venvPy)} -m pip install --quiet torch torchaudio`, { stdio: "pipe", timeout: 6e5 });
-          } catch (err2) {
-            throw new Error(`Failed to install PyTorch: ${err2 instanceof Error ? err2.message : String(err2)}`);
+            execSync27(`${JSON.stringify(venvPy)} -m pip install --quiet torch torchaudio --index-url https://download.pytorch.org/whl/cu124`, { stdio: "pipe", timeout: 6e5 });
+          } catch {
+            try {
+              execSync27(`${JSON.stringify(venvPy)} -m pip install --quiet torch torchaudio`, { stdio: "pipe", timeout: 6e5 });
+            } catch (err2) {
+              throw new Error(`Failed to install PyTorch (CUDA): ${err2 instanceof Error ? err2.message : String(err2)}`);
+            }
+          }
+        } else {
+          renderInfo("  Installing PyTorch (CPU \u2014 no NVIDIA GPU detected)...");
+          try {
+            execSync27(`${JSON.stringify(venvPy)} -m pip install --quiet torch torchaudio --index-url https://download.pytorch.org/whl/cpu`, { stdio: "pipe", timeout: 6e5 });
+          } catch {
+            try {
+              execSync27(`${JSON.stringify(venvPy)} -m pip install --quiet torch torchaudio`, { stdio: "pipe", timeout: 6e5 });
+            } catch (err2) {
+              throw new Error(`Failed to install PyTorch: ${err2 instanceof Error ? err2.message : String(err2)}`);
+            }
           }
         }
         const repoDir = luxttsRepoDir();
@@ -39561,70 +39623,95 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
           }
         }
       }
-      /** Write the LuxTTS inference helper Python script */
+      /** Persistent LuxTTS daemon process — keeps model warm in GPU memory */
+      _luxttsDaemon = null;
+      _luxttsPending = /* @__PURE__ */ new Map();
+      _luxttsBuffer = "";
+      /** Write the LuxTTS persistent daemon Python script */
       writeLuxttsInferScript() {
         const script = `#!/usr/bin/env python3
-"""LuxTTS inference helper for open-agents voice engine.
-Called by voice.ts via execSync with JSON args.
+"""LuxTTS persistent daemon for open-agents voice engine.
+Keeps model warm in GPU memory. Reads JSON requests from stdin, writes JSON responses to stdout.
 """
-import sys, json, os, wave, struct
+import sys, json, os, wave, signal
 import numpy as np
 
 def main():
-    args = json.loads(sys.argv[1])
-    action = args.get('action', 'synthesize')
-
-    repo_path = args.get('repo_path', '')
+    repo_path = os.environ.get('LUXTTS_REPO_PATH', '')
     if repo_path:
         sys.path.insert(0, repo_path)
 
-    if action == 'check':
+    import torch
+    from zipvoice.luxvoice import LuxTTS
+
+    # Auto-detect best device
+    if torch.cuda.is_available():
+        device = 'cuda'
+    elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
+        device = 'mps'
+    else:
+        device = 'cpu'
+
+    # Load model ONCE \u2014 stays warm in GPU/CPU memory
+    tts = LuxTTS(model_path='YatharthS/LuxTTS', device=device, threads=4)
+    sys.stdout.write(json.dumps({'type': 'ready', 'device': device}) + '\\n')
+    sys.stdout.flush()
+
+    # Cache encoded prompts by clone_ref path (avoid re-encoding same voice)
+    prompt_cache = {}
+
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
         try:
-            from zipvoice.luxvoice import LuxTTS
-            print(json.dumps({'ok': True}))
+            req = json.loads(line)
         except Exception as e:
-            print(json.dumps({'ok': False, 'error': str(e)}))
-        return
-
-    if action == 'synthesize':
-        import torch
-        from zipvoice.luxvoice import LuxTTS
-
-        text = args['text']
-        clone_ref = args['clone_ref']
-        output_path = args['output_path']
-        speed = args.get('speed', 1.0)
-
-        # Auto-detect best device
-        if torch.cuda.is_available():
-            device = 'cuda'
-        elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
-            device = 'mps'
-        else:
-            device = 'cpu'
-
-        threads = 4 if device == 'cpu' else 4
-        tts = LuxTTS(model_path='YatharthS/LuxTTS', device=device, threads=threads)
-        encoded = tts.encode_prompt(clone_ref, duration=5, rms=0.001)
-        wav_tensor = tts.generate_speech(text, encoded, num_steps=4, guidance_scale=3.0, t_shift=0.5, speed=speed)
-        wav_np = wav_tensor.cpu().numpy().squeeze()
-
-        # Write as 48kHz 16-bit mono WAV using stdlib
-        int16_data = (np.clip(wav_np, -1.0, 1.0) * 32767).astype(np.int16)
-        with wave.open(output_path, 'wb') as wf:
-            wf.setnchannels(1)
-            wf.setsampwidth(2)
-            wf.setframerate(48000)
-            wf.writeframes(int16_data.tobytes())
-
-        print(json.dumps({
-            'ok': True,
-            'path': output_path,
-            'sample_rate': 48000,
-            'device': device,
-            'samples': len(int16_data),
-        }))
-        return
+            sys.stdout.write(json.dumps({'type': 'error', 'id': '', 'error': str(e)}) + '\\n')
+            sys.stdout.flush()
+            continue
+
+        req_id = req.get('id', '')
+
+        if req.get('action') == 'check':
+            sys.stdout.write(json.dumps({'type': 'result', 'id': req_id, 'ok': True}) + '\\n')
+            sys.stdout.flush()
+            continue
+
+        if req.get('action') == 'quit':
+            break
+
+        if req.get('action') == 'synthesize':
+            try:
+                text = req['text']
+                clone_ref = req['clone_ref']
+                output_path = req['output_path']
+                speed = req.get('speed', 1.0)
+
+                # Use cached prompt encoding if available
+                if clone_ref not in prompt_cache:
+                    prompt_cache[clone_ref] = tts.encode_prompt(clone_ref, duration=5, rms=0.001)
+                encoded = prompt_cache[clone_ref]
+
+                wav_tensor = tts.generate_speech(text, encoded, num_steps=4, guidance_scale=3.0, t_shift=0.5, speed=speed)
+                wav_np = wav_tensor.cpu().numpy().squeeze()
+
+                int16_data = (np.clip(wav_np, -1.0, 1.0) * 32767).astype(np.int16)
+                with wave.open(output_path, 'wb') as wf:
+                    wf.setnchannels(1)
+                    wf.setsampwidth(2)
+                    wf.setframerate(48000)
+                    wf.writeframes(int16_data.tobytes())
+
+                sys.stdout.write(json.dumps({
+                    'type': 'result', 'id': req_id, 'ok': True,
+                    'path': output_path, 'sample_rate': 48000,
+                    'device': device, 'samples': len(int16_data),
+                }) + '\\n')
+                sys.stdout.flush()
+            except Exception as e:
+                sys.stdout.write(json.dumps({'type': 'error', 'id': req_id, 'error': str(e)}) + '\\n')
+                sys.stdout.flush()
 
 if __name__ == '__main__':
     main()
@@ -39633,6 +39720,84 @@ if __name__ == '__main__':
         mkdirSync14(voiceDir(), { recursive: true });
         writeFileSync14(scriptPath2, script);
       }
+      /** Ensure the LuxTTS daemon is running, spawn if needed */
+      async ensureLuxttsDaemon() {
+        if (this._luxttsDaemon && !this._luxttsDaemon.killed)
+          return true;
+        const venvPy = luxttsVenvPy();
+        if (!existsSync34(venvPy))
+          return false;
+        return new Promise((resolve31) => {
+          const env = { ...process.env, LUXTTS_REPO_PATH: luxttsRepoDir() };
+          const daemon = nodeSpawn(venvPy, [luxttsInferScript()], {
+            stdio: ["pipe", "pipe", "pipe"],
+            cwd: tmpdir6(),
+            env
+          });
+          this._luxttsDaemon = daemon;
+          this._luxttsBuffer = "";
+          daemon.stdout.on("data", (chunk) => {
+            this._luxttsBuffer += chunk.toString();
+            const lines = this._luxttsBuffer.split("\n");
+            this._luxttsBuffer = lines.pop();
+            for (const line of lines) {
+              if (!line.trim())
+                continue;
+              try {
+                const msg = JSON.parse(line);
+                if (msg.type === "ready") {
+                  resolve31(true);
+                } else if (msg.type === "result" || msg.type === "error") {
+                  const pending = this._luxttsPending.get(msg.id);
+                  if (pending) {
+                    this._luxttsPending.delete(msg.id);
+                    if (msg.type === "error")
+                      pending.reject(new Error(msg.error));
+                    else
+                      pending.resolve(line);
+                  }
+                }
+              } catch {
+              }
+            }
+          });
+          daemon.on("exit", () => {
+            this._luxttsDaemon = null;
+            for (const [, p] of this._luxttsPending) {
+              p.reject(new Error("LuxTTS daemon exited"));
+            }
+            this._luxttsPending.clear();
+          });
+          daemon.on("error", () => {
+            this._luxttsDaemon = null;
+            resolve31(false);
+          });
+          setTimeout(() => {
+            if (this._luxttsDaemon === daemon && !this._luxttsPending.has("__ready__")) {
+              resolve31(false);
+            }
+          }, 6e4);
+        });
+      }
+      /** Send a request to the LuxTTS daemon and await the response */
+      luxttsRequest(req) {
+        return new Promise((resolve31, reject) => {
+          if (!this._luxttsDaemon || this._luxttsDaemon.killed) {
+            reject(new Error("LuxTTS daemon not running"));
+            return;
+          }
+          const id = `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          req.id = id;
+          this._luxttsPending.set(id, { resolve: resolve31, reject });
+          this._luxttsDaemon.stdin.write(JSON.stringify(req) + "\n");
+          setTimeout(() => {
+            if (this._luxttsPending.has(id)) {
+              this._luxttsPending.delete(id);
+              reject(new Error("LuxTTS synthesis timeout"));
+            }
+          }, 12e4);
+        });
+      }
       /**
        * Synthesize and play audio using LuxTTS voice cloning.
        * Speed is passed natively to LuxTTS. Pitch is post-processed via resampling.
@@ -39645,20 +39810,18 @@ if __name__ == '__main__':
         const cleaned = text.replace(/\*/g, "").trim();
         if (!cleaned)
           return;
-        const venvPy = luxttsVenvPy();
-        if (!existsSync34(venvPy))
+        const ready = await this.ensureLuxttsDaemon();
+        if (!ready)
           return;
         const wavPath = join43(tmpdir6(), `oa-luxtts-${Date.now()}.wav`);
-        const inferArgs = JSON.stringify({
-          action: "synthesize",
-          repo_path: luxttsRepoDir(),
-          text: cleaned,
-          clone_ref: this.luxttsCloneRef,
-          output_path: wavPath,
-          speed: speedFactor
-        });
         try {
-          execSync27(`${JSON.stringify(venvPy)} ${JSON.stringify(luxttsInferScript())} ${JSON.stringify(inferArgs)}`, { stdio: "pipe", timeout: 12e4, cwd: tmpdir6() });
+          await this.luxttsRequest({
+            action: "synthesize",
+            text: cleaned,
+            clone_ref: this.luxttsCloneRef,
+            output_path: wavPath,
+            speed: speedFactor
+          });
         } catch {
           return;
         }
@@ -39721,20 +39884,18 @@ if __name__ == '__main__':
         const cleaned = text.replace(/\*/g, "").trim();
         if (!cleaned)
           return null;
-        const venvPy = luxttsVenvPy();
-        if (!existsSync34(venvPy))
+        const ready = await this.ensureLuxttsDaemon();
+        if (!ready)
           return null;
         const wavPath = join43(tmpdir6(), `oa-luxtts-buf-${Date.now()}.wav`);
-        const inferArgs = JSON.stringify({
-          action: "synthesize",
-          repo_path: luxttsRepoDir(),
-          text: cleaned,
-          clone_ref: this.luxttsCloneRef,
-          output_path: wavPath,
-          speed: 1
-        });
         try {
-          execSync27(`${JSON.stringify(venvPy)} ${JSON.stringify(luxttsInferScript())} ${JSON.stringify(inferArgs)}`, { stdio: "pipe", timeout: 12e4, cwd: tmpdir6() });
+          await this.luxttsRequest({
+            action: "synthesize",
+            text: cleaned,
+            clone_ref: this.luxttsCloneRef,
+            output_path: wavPath,
+            speed: 1
+          });
         } catch {
           return null;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.103.79",
+  "version": "0.103.81",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",