open-agents-ai 0.54.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",
@@ -17692,6 +17749,7 @@ var init_render = __esm({
 // packages/cli/dist/tui/voice-session.js
 import { createServer } from "node:http";
 import { spawn as spawn10, execSync as execSync19 } from "node:child_process";
+import { createHash } from "node:crypto";
 import { EventEmitter as EventEmitter2 } from "node:events";
 function parseWebSocketFrame(buf) {
   if (buf.length < 2)
@@ -17846,26 +17904,42 @@ let scriptProcessor = null;
 let micActive = false;
 let playbackQueue = [];
 let isPlaying = false;
+let reconnectDelay = 1000;
+let reconnectTimer = null;
 
 // Connect WebSocket
 function connect() {
+  if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
   const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
   ws = new WebSocket(proto + '//' + location.host + '/ws');
   ws.binaryType = 'arraybuffer';
 
   ws.onopen = () => {
     statusEl.innerHTML = '<span class="connected">Connected</span>';
+    reconnectDelay = 1000; // Reset backoff on successful connection
+  };
+
+  ws.onerror = () => {
+    // Error fires before close \u2014 just update status, close handler does reconnect
+    statusEl.innerHTML = '<span class="disconnected">Connection error</span>';
   };
 
   ws.onclose = () => {
     statusEl.innerHTML = '<span class="disconnected">Disconnected \u2014 reconnecting...</span>';
-    setTimeout(connect, 2000);
+    // Exponential backoff: 1s, 2s, 4s, max 10s
+    reconnectTimer = setTimeout(connect, reconnectDelay);
+    reconnectDelay = Math.min(reconnectDelay * 2, 10000);
   };
 
   ws.onmessage = (evt) => {
     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') {
@@ -17990,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)
 
 `);
 }
@@ -18011,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"() {
@@ -18022,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 */
@@ -18056,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);
@@ -18081,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.
@@ -18094,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));
@@ -18184,9 +18274,11 @@ var init_voice_session = __esm({
           socket.destroy();
           return;
         }
-        const crypto2 = __require("node:crypto");
         const magic = "258EAFA5-E914-47DA-95CA-5AB9DC085B62";
-        const accept = crypto2.createHash("sha1").update(key + magic).digest("base64");
+        const accept = createHash("sha1").update(key + magic).digest("base64");
+        socket.setNoDelay(true);
+        socket.setKeepAlive(true, 1e4);
+        socket.setTimeout(0);
         socket.write(`HTTP/1.1 101 Switching Protocols\r
 Upgrade: websocket\r
 Connection: Upgrade\r
@@ -18197,6 +18289,23 @@ 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 {
+        }
+        const pingInterval = setInterval(() => {
+          if (socket.destroyed) {
+            clearInterval(pingInterval);
+            return;
+          }
+          try {
+            socket.write(createWebSocketFrame(9, Buffer.from("keepalive")));
+            socket.write(createWebSocketFrame(1, Buffer.from(JSON.stringify({ type: "keepalive" }))));
+          } catch {
+            clearInterval(pingInterval);
+          }
+        }, 5e3);
         let frameBuffer = Buffer.alloc(0);
         socket.on("data", (data) => {
           frameBuffer = Buffer.concat([frameBuffer, data]);
@@ -18218,10 +18327,15 @@ Sec-WebSocket-Accept: ${accept}\r
             const consumed = headerLen + (masked ? 4 : 0) + payloadLen;
             frameBuffer = frameBuffer.subarray(consumed);
             if (frame.opcode === 8) {
+              try {
+                socket.write(createWebSocketFrame(8, Buffer.alloc(0)));
+              } catch {
+              }
               socket.end();
               return;
             } else if (frame.opcode === 9) {
               socket.write(createWebSocketFrame(10, frame.payload));
+            } else if (frame.opcode === 10) {
             } else if (frame.opcode === 1) {
               try {
                 const msg = JSON.parse(frame.payload.toString());
@@ -18229,7 +18343,6 @@ Sec-WebSocket-Accept: ${accept}\r
                   const entry = this.state.connectedUsers.get(clientId);
                   if (entry)
                     entry.username = msg.username;
-                  this.emit("userConnected", clientId, msg.username);
                 }
               } catch {
               }
@@ -18241,14 +18354,17 @@ Sec-WebSocket-Accept: ${accept}\r
           }
         });
         socket.on("close", () => {
+          clearInterval(pingInterval);
           this.wsClients.delete(clientId);
-          const user = this.state.connectedUsers.get(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);
@@ -18291,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) => {
@@ -20749,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();
@@ -23135,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;
@@ -23366,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);
@@ -27257,6 +27421,10 @@ function convertMarkdownToTelegramHTML(md) {
   return html;
 }
 function formatIntermediateState(event) {
+  if (event.type === "tool_call" && event.toolName === "task_complete")
+    return null;
+  if (event.type === "tool_result" && event.toolName === "task_complete")
+    return null;
   if (event.type === "tool_call") {
     const argsPreview = event.toolArgs ? JSON.stringify(event.toolArgs).slice(0, 60) : "";
     return `\u{1F527} <code>${event.toolName || "tool"}</code>(${argsPreview.length > 57 ? argsPreview.slice(0, 57) + "..." : argsPreview})`;
@@ -27456,6 +27624,10 @@ with summary "no_reply" to silently skip without responding.
       commandHandler = null;
       /** Callback to get active call session URL (wired from interactive.ts) */
       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 */
@@ -27495,6 +27667,14 @@ with summary "no_reply" to silently skip without responding.
       setCallUrlGetter(getter) {
         this.callUrlGetter = getter;
       }
+      /** Register callback to start a call session (returns URL or null) */
+      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;
@@ -27655,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) {
@@ -27665,6 +27855,20 @@ with summary "no_reply" to silently skip without responding.
             await this.sendMessage(msg.chatId, "No active call session. Ask the admin to start one with /call.");
             return;
           }
+          if (this.callStarter) {
+            try {
+              const newUrl = await this.callStarter();
+              if (newUrl) {
+                await this.sendCallButton(msg.chatId, newUrl);
+              } else {
+                await this.sendMessage(msg.chatId, "Failed to start call session.");
+              }
+            } catch (err) {
+              await this.sendMessage(msg.chatId, `Call error: ${err instanceof Error ? err.message : String(err)}`).catch(() => {
+              });
+            }
+            return;
+          }
         }
         if (isAdminDM && msg.text.startsWith("/") && this.commandHandler) {
           const cmdName = msg.text.split(/\s+/)[0].slice(1).toLowerCase();
@@ -30796,6 +31000,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         telegramBridge.voiceEnabled = true;
       }
       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;
@@ -30963,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)) {
@@ -30987,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;
       }
@@ -30997,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() {
@@ -31472,13 +31727,13 @@ NEW TASK: ${fullInput}`;
       writeContent(() => renderError(errMsg));
       if (failureStore) {
         try {
-          const { createHash: createHash2 } = await import("node:crypto");
+          const { createHash: createHash3 } = await import("node:crypto");
           failureStore.insert({
             taskId: "",
             sessionId: `${Date.now()}`,
             repoRoot,
             failureType: "runtime-error",
-            fingerprint: createHash2("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
+            fingerprint: createHash3("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
             filePath: null,
             errorMessage: errMsg.slice(0, 500),
             context: null,
@@ -31739,7 +31994,7 @@ var init_run = __esm({
 import { glob } from "glob";
 import ignore from "ignore";
 import { readFile as readFile14, stat as stat4 } from "node:fs/promises";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { join as join41, relative as relative3, extname as extname10, basename as basename15 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
@@ -31805,7 +32060,7 @@ var init_codebase_indexer = __esm({
             if (fileStat.size > this.config.maxFileSize)
               continue;
             const content = await readFile14(fullPath);
-            const hash = createHash("sha256").update(content).digest("hex");
+            const hash = createHash2("sha256").update(content).digest("hex");
             const ext = extname10(relativePath);
             indexed.push({
               path: fullPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.54.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",