open-agents-ai 0.55.0 → 0.56.0

package/dist/index.js

@@ -16726,6 +16726,62 @@ transcribe-cli error: ${transcribeCliError}` : "";
         this.pendingText = "";
         return text;
       }
+      /**
+       * Create a standalone transcriber for call sessions.
+       * No microphone capture — just an ASR engine you feed PCM chunks to.
+       * Returns an EventEmitter with .write(pcm: Buffer) and 'transcript' events.
+       * Caller is responsible for calling .stop() when done.
+       */
+      async createCallTranscriber() {
+        let tc = await this.loadTranscribeCli();
+        if (!tc && _bgInstallPromise) {
+          await _bgInstallPromise;
+          this.transcribeCliAvailable = null;
+          tc = await this.loadTranscribeCli();
+        }
+        if (!tc) {
+          try {
+            execSync18("npm i -g transcribe-cli", { stdio: "pipe", timeout: 18e4 });
+            this.transcribeCliAvailable = null;
+            tc = await this.loadTranscribeCli();
+          } catch {
+          }
+        }
+        if (tc?.TranscribeLive) {
+          try {
+            const transcriber = new tc.TranscribeLive({
+              model: this.config.model,
+              sampleRate: 16e3,
+              channels: 1,
+              sampleWidth: 2,
+              chunkDuration: 3
+            });
+            await new Promise((resolve28, reject) => {
+              const timeout = setTimeout(() => reject(new Error("Model load timeout (60s)")), 6e4);
+              transcriber.on("ready", () => {
+                clearTimeout(timeout);
+                resolve28();
+              });
+              transcriber.on("error", (err) => {
+                clearTimeout(timeout);
+                reject(err);
+              });
+            });
+            return transcriber;
+          } catch {
+          }
+        }
+        const scriptPath2 = findLiveWhisperScript();
+        if (!scriptPath2)
+          return null;
+        try {
+          const fallback = new WhisperFallbackTranscriber(this.config.model, scriptPath2);
+          await fallback.start();
+          return fallback;
+        } catch {
+          return null;
+        }
+      }
       /**
        * Transcribe a file (audio or video) using transcribe-cli.
        * Returns the transcription result.
@@ -17284,8 +17340,8 @@ function renderSlashHelp() {
     ["/listen manual", "Manual mode \u2014 press Enter to submit (turns off auto)"],
     ["/listen auto", "Auto-submit after 3s silence (blinking \u25CF indicator)"],
     ["/listen stop", "Stop listening"],
-    ["/call", "Start voice call session (cloudflared tunnel + PCM frontend)"],
-    ["/call stop", "Stop active call session"],
+    ["/call", "Start voice call session (cloudflared tunnel + ASR/TTS)"],
+    ["/hangup", "End active call session"],
     ["/cost", "Show session token cost breakdown"],
     ["/evaluate", "Evaluate last completed task (LLM quality scoring)"],
     ["/task-type", "Set task type (code, document, analysis, plan, general, auto)"],
@@ -17675,6 +17731,7 @@ var init_render = __esm({
       "/voice",
       "/listen",
       "/call",
+      "/hangup",
       "/stream",
       "/verbose",
       "/dream",
@@ -17878,6 +17935,11 @@ function connect() {
     if (typeof evt.data === 'string') {
       try {
         const msg = JSON.parse(evt.data);
+        if (msg.type === 'keepalive') {
+          // Respond to keep connection alive through proxies
+          if (ws.readyState === 1) ws.send(JSON.stringify({ type: 'pong' }));
+          return;
+        }
         if (msg.type === 'transcript') {
           addTranscript(msg.speaker, msg.text);
         } else if (msg.type === 'speaking_start') {
@@ -18002,11 +18064,11 @@ function renderVoiceSessionStart(tunnelUrl) {
   process.stdout.write(`
   ${c2.cyan("\u2601")} ${c2.bold("Live Voice Session")}
 `);
-  process.stdout.write(`    ${c2.dim("\u23BF")} URL: ${c2.cyan(tunnelUrl)}
+  process.stdout.write(`    ${c2.dim("\u23BF")} ${c2.cyan(tunnelUrl)}
 `);
   process.stdout.write(`    ${c2.dim("\u23BF")} Bidirectional PCM audio + live transcription
 `);
-  process.stdout.write(`    ${c2.dim("\u23BF")} Use /listen stop to end session
+  process.stdout.write(`    ${c2.dim("\u23BF")} /hangup to end session (auto-closes after 1 min idle)
 
 `);
 }
@@ -18023,6 +18085,12 @@ function renderVoiceSessionUser(action, username) {
   process.stdout.write(`    ${c2.dim("\u23BF")} ${c2.cyan("\u2601")} ${icon} ${username} ${action}
 `);
 }
+function renderVoiceSessionTranscript(speaker, text) {
+  const label = speaker === "user" ? c2.yellow("user") : c2.cyan("agent");
+  const preview = text.length > 80 ? text.slice(0, 77) + "..." : text;
+  process.stdout.write(`    ${c2.dim("\u23BF")} ${c2.cyan("\u2601")} [${label}] ${preview}
+`);
+}
 var VoiceSession;
 var init_voice_session = __esm({
   "packages/cli/dist/tui/voice-session.js"() {
@@ -18034,7 +18102,10 @@ var init_voice_session = __esm({
       cloudflaredProcess = null;
       wsClients = /* @__PURE__ */ new Map();
       runtimeTimer = null;
+      idleTimer = null;
       ttsSpeaking = false;
+      /** Idle timeout before auto-closing (ms). Default 60s — no users connected → session ends. */
+      idleTimeoutMs = 6e4;
       /** Callback invoked when user audio chunk arrives (PCM 16kHz 16-bit mono) */
       onUserAudio = null;
       /** Callback invoked when user speech is transcribed */
@@ -18068,6 +18139,8 @@ var init_voice_session = __esm({
         const port = await this.findFreePort();
         this.state.localPort = port;
         this.server = createServer((req, res) => this.handleHTTP(req, res));
+        this.server.timeout = 0;
+        this.server.keepAliveTimeout = 0;
         this.server.on("upgrade", (req, socket, head) => {
           if (req.url === "/ws") {
             this.handleWebSocketUpgrade(req, socket, head);
@@ -18093,7 +18166,8 @@ var init_voice_session = __esm({
           this.emit("tick", this.runtime);
         }, 1e3);
         this.emit("started", this.state.tunnelUrl);
-        return `Voice session started: ${this.state.tunnelUrl}`;
+        this.resetIdleTimer();
+        return this.state.tunnelUrl;
       }
       /**
        * Stop the voice session.
@@ -18106,6 +18180,10 @@ var init_voice_session = __esm({
           clearInterval(this.runtimeTimer);
           this.runtimeTimer = null;
         }
+        if (this.idleTimer) {
+          clearTimeout(this.idleTimer);
+          this.idleTimer = null;
+        }
         for (const [id, socket] of this.wsClients) {
           try {
             const closeFrame = createWebSocketFrame(8, Buffer.alloc(0));
@@ -18199,7 +18277,8 @@ var init_voice_session = __esm({
         const magic = "258EAFA5-E914-47DA-95CA-5AB9DC085B62";
         const accept = createHash("sha1").update(key + magic).digest("base64");
         socket.setNoDelay(true);
-        socket.setKeepAlive(true, 3e4);
+        socket.setKeepAlive(true, 1e4);
+        socket.setTimeout(0);
         socket.write(`HTTP/1.1 101 Switching Protocols\r
 Upgrade: websocket\r
 Connection: Upgrade\r
@@ -18210,6 +18289,7 @@ Sec-WebSocket-Accept: ${accept}\r
         this.wsClients.set(clientId, socket);
         this.state.connectedUsers.set(clientId, { username: "web-user", connectedAt: Date.now() });
         this.emit("userConnected", clientId, "web-user");
+        this.resetIdleTimer();
         try {
           socket.write(createWebSocketFrame(9, Buffer.from("keepalive")));
         } catch {
@@ -18221,10 +18301,11 @@ Sec-WebSocket-Accept: ${accept}\r
           }
           try {
             socket.write(createWebSocketFrame(9, Buffer.from("keepalive")));
+            socket.write(createWebSocketFrame(1, Buffer.from(JSON.stringify({ type: "keepalive" }))));
           } catch {
             clearInterval(pingInterval);
           }
-        }, 25e3);
+        }, 5e3);
         let frameBuffer = Buffer.alloc(0);
         socket.on("data", (data) => {
           frameBuffer = Buffer.concat([frameBuffer, data]);
@@ -18277,11 +18358,13 @@ Sec-WebSocket-Accept: ${accept}\r
           this.wsClients.delete(clientId);
           this.state.connectedUsers.delete(clientId);
           this.emit("userDisconnected", clientId);
+          this.resetIdleTimer();
         });
         socket.on("error", () => {
           clearInterval(pingInterval);
           this.wsClients.delete(clientId);
           this.state.connectedUsers.delete(clientId);
+          this.resetIdleTimer();
         });
         if (head.length > 0) {
           socket.emit("data", head);
@@ -18324,6 +18407,27 @@ Sec-WebSocket-Accept: ${accept}\r
           });
         });
       }
+      // ── Idle timer ───────────────────────────────────────────────────────
+      /**
+       * Reset idle timer. Called when users connect/disconnect.
+       * When no users are connected, starts a countdown to auto-close.
+       * When a user connects, cancels any pending auto-close.
+       */
+      resetIdleTimer() {
+        if (this.idleTimer) {
+          clearTimeout(this.idleTimer);
+          this.idleTimer = null;
+        }
+        if (this.state.connectedUsers.size === 0) {
+          this.idleTimer = setTimeout(() => {
+            if (this.state.active && this.state.connectedUsers.size === 0) {
+              this.emit("idle_timeout");
+              this.stop().catch(() => {
+              });
+            }
+          }, this.idleTimeoutMs);
+        }
+      }
       // ── Helpers ───────────────────────────────────────────────────────────
       findFreePort() {
         return new Promise((resolve28, reject) => {
@@ -20782,6 +20886,19 @@ async function handleSlashCommand(input, ctx) {
       }
       return "handled";
     }
+    case "hangup": {
+      if (!ctx.callStop) {
+        renderWarning("Call mode not available in this context.");
+        return "handled";
+      }
+      if (ctx.isCallActive?.()) {
+        await ctx.callStop();
+        renderInfo("Call session ended.");
+      } else {
+        renderWarning("No active call session.");
+      }
+      return "handled";
+    }
     case "bruteforce":
     case "brute": {
       const isOn = ctx.bruteForceToggle();
@@ -23168,6 +23285,12 @@ var init_voice = __esm({
       enabled = false;
       modelId = "glados";
       ready = false;
+      /**
+       * Callback fired with PCM Int16 data whenever TTS synthesizes audio.
+       * Used by VoiceSession to stream TTS output to WebSocket clients.
+       * Set this to wire TTS → call session broadcast.
+       */
+      onPCMOutput = null;
       session = null;
       // ort.InferenceSession
       ort = null;
@@ -23399,6 +23522,14 @@ var init_voice = __esm({
         const audioData = result["output"].data;
         if (audioData.length === 0)
           return;
+        if (this.onPCMOutput) {
+          const int16 = new Int16Array(audioData.length);
+          for (let i = 0; i < audioData.length; i++) {
+            const s = Math.max(-1, Math.min(1, audioData[i]));
+            int16[i] = s < 0 ? s * 32768 : s * 32767;
+          }
+          this.onPCMOutput(Buffer.from(int16.buffer), this.config.audio.sample_rate);
+        }
         const wavPath = join34(tmpdir6(), `oa-voice-${Date.now()}.wav`);
         this.writeWav(audioData, this.config.audio.sample_rate, wavPath);
         await this.playWav(wavPath);
@@ -27495,6 +27626,8 @@ with summary "no_reply" to silently skip without responding.
       callUrlGetter = null;
       /** Callback to start a call session and return the URL (wired from interactive.ts) */
       callStarter = null;
+      /** Callback to stop a call session (wired from interactive.ts) */
+      callStopper = null;
       /** Callback to write content into the scrollable TUI waterfall area (wired from interactive.ts) */
       writeContent = null;
       /** Media cache — fileUniqueId → cache entry */
@@ -27538,6 +27671,10 @@ with summary "no_reply" to silently skip without responding.
       setCallStarter(starter) {
         this.callStarter = starter;
       }
+      /** Register callback to stop a call session */
+      setCallStopper(stopper) {
+        this.callStopper = stopper;
+      }
       /** Register callback to write content into the scrollable TUI area (status bar guard) */
       setWriteContent(fn) {
         this.writeContent = fn;
@@ -27698,6 +27835,16 @@ with summary "no_reply" to silently skip without responding.
         const isAdmin = this.isAdminUser(msg);
         const toolContext = this.resolveToolContext(msg, isAdmin);
         const isAdminDM = toolContext === "telegram-admin-dm";
+        if (msg.text.trim().toLowerCase() === "/hangup" && isAdmin && this.callStopper) {
+          const callUrl = this.callUrlGetter?.();
+          if (callUrl) {
+            await this.callStopper();
+            await this.sendMessage(msg.chatId, "Call session ended.");
+          } else {
+            await this.sendMessage(msg.chatId, "No active call session.");
+          }
+          return;
+        }
         if (msg.text.trim().toLowerCase() === "/call" && this.callUrlGetter) {
           const callUrl = this.callUrlGetter();
           if (callUrl) {
@@ -30854,6 +31001,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       }
       telegramBridge.setCallUrlGetter(() => voiceSession?.tunnelUrl ?? null);
       telegramBridge.setCallStarter(async () => commandCtx.callStart());
+      telegramBridge.setCallStopper(async () => commandCtx.callStop());
       telegramBridge.setCommandHandler(async (input) => {
         const captured = [];
         const origWrite = process.stdout.write;
@@ -31021,20 +31169,66 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       return text ? `Stopped. Last transcript: "${text}"` : "Stopped listening.";
     },
     // Voice call session — standalone cloudflared tunnel for /call
+    // Wires: WebSocket audio → ASR transcription → agent input → TTS → WebSocket broadcast
     async callStart() {
       if (voiceSession?.isActive) {
         return voiceSession.tunnelUrl;
       }
       voiceSession = new VoiceSession();
+      const callState = { transcriber: null };
+      const engine = getListenEngine();
+      voiceSession.onUserAudio = (pcmChunk, userId) => {
+        if (callState.transcriber)
+          callState.transcriber.write(pcmChunk);
+      };
       voiceSession.on("userConnected", (id, username) => {
         writeContent(() => renderVoiceSessionUser("connected", username));
+        if (!callState.transcriber) {
+          engine.createCallTranscriber().then((t) => {
+            if (!t || !voiceSession?.isActive)
+              return;
+            callState.transcriber = t;
+            callState.transcriber.on("transcript", (evt) => {
+              if (!evt.text?.trim() || !voiceSession?.isActive)
+                return;
+              const text = evt.text.trim();
+              writeContent(() => renderVoiceSessionTranscript("user", text));
+              voiceSession?.sendTranscript("user", text);
+              if (evt.isFinal) {
+                rl.write(text + "\n");
+              }
+            });
+            writeContent(() => renderInfo("Call ASR ready \u2014 listening for speech"));
+          }).catch((err) => {
+            writeContent(() => renderWarning(`Call ASR unavailable: ${err instanceof Error ? err.message : String(err)}`));
+          });
+        }
       });
       voiceSession.on("userDisconnected", (id) => {
         writeContent(() => renderVoiceSessionUser("disconnected", id));
       });
+      voiceSession.on("idle_timeout", () => {
+        writeContent(() => renderWarning("Call session auto-closed (1 min idle \u2014 no users connected)"));
+        if (callState.transcriber) {
+          callState.transcriber.stop();
+          callState.transcriber = null;
+        }
+        voiceSession = null;
+      });
       try {
         const tunnelUrl = await voiceSession.start();
         writeContent(() => renderVoiceSessionStart(tunnelUrl));
+        if (voiceEngine.enabled && voiceEngine.ready) {
+          const session = voiceSession;
+          voiceEngine.onPCMOutput = (pcm, sampleRate) => {
+            if (session?.isActive) {
+              session.sendSpeakingState(true);
+              session.sendAudioToClients(pcm);
+              const durationMs = pcm.length / 2 / sampleRate * 1e3;
+              setTimeout(() => session.sendSpeakingState(false), durationMs);
+            }
+          };
+        }
         if (telegramBridge?.isActive && savedSettings.telegramAdmin) {
           const adminChatId = parseInt(savedSettings.telegramAdmin, 10);
           if (!isNaN(adminChatId)) {
@@ -31045,6 +31239,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         return tunnelUrl;
       } catch (err) {
         writeContent(() => renderWarning(`Voice session failed: ${err instanceof Error ? err.message : String(err)}`));
+        callState.transcriber?.stop();
+        callState.transcriber = null;
         voiceSession = null;
         return null;
       }
@@ -31055,6 +31251,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         await voiceSession.stop();
         writeContent(() => renderVoiceSessionStop(runtime));
         voiceSession = null;
+        voiceEngine.onPCMOutput = null;
       }
     },
     isCallActive() {

package/package.json

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