open-agents-ai 0.184.69 → 0.184.71

package/dist/index.js

@@ -11949,7 +11949,7 @@ function formatTime(seconds) {
   const s = Math.floor(seconds % 60);
   return `${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
 }
-var AUDIO_EXTS, VIDEO_EXTS, _tcModule, _tcChecked, TranscribeFileTool, TranscribeUrlTool;
+var AUDIO_EXTS, VIDEO_EXTS, _tcModule, _tcChecked, TranscribeFileTool, TranscribeUrlTool, YouTubeDownloadTool;
 var init_transcribe_tool = __esm({
   "packages/execution/dist/tools/transcribe-tool.js"() {
     "use strict";
@@ -12267,6 +12267,90 @@ ${result.output}`,
         }
       }
     };
+    YouTubeDownloadTool = class {
+      name = "youtube_download";
+      description = "Download video or audio from YouTube. Saves mp4 (video) or mp3 (audio) to the working directory. Uses yt-dlp (auto-installed). Supports youtube.com/watch, youtu.be, shorts, live URLs.";
+      parameters = {
+        type: "object",
+        properties: {
+          url: {
+            type: "string",
+            description: "YouTube URL (youtube.com/watch?v=..., youtu.be/..., etc.)"
+          },
+          format: {
+            type: "string",
+            enum: ["mp3", "mp4"],
+            description: "Output format: 'mp3' for audio only, 'mp4' for video (default: mp3)"
+          },
+          output_dir: {
+            type: "string",
+            description: "Directory to save the file (default: current working directory)"
+          }
+        },
+        required: ["url"]
+      };
+      workingDir;
+      constructor(workingDir) {
+        this.workingDir = workingDir;
+      }
+      async execute(args) {
+        const start = Date.now();
+        const url = String(args.url ?? "").trim();
+        const format = String(args.format ?? "mp3").toLowerCase();
+        const outputDir = String(args.output_dir ?? this.workingDir);
+        if (!url) {
+          return { success: false, output: "", error: "URL is required", durationMs: Date.now() - start };
+        }
+        if (!isYouTubeUrl(url)) {
+          return { success: false, output: "", error: "Not a recognized YouTube URL. Supported: youtube.com/watch, youtu.be, shorts, live, embed", durationMs: Date.now() - start };
+        }
+        if (!ensureYtDlp()) {
+          return { success: false, output: "", error: "yt-dlp not available and auto-install failed. Install manually: pip install yt-dlp", durationMs: Date.now() - start };
+        }
+        mkdirSync7(outputDir, { recursive: true });
+        try {
+          let title = "download";
+          try {
+            title = execSync10(`yt-dlp --get-title "${url}"`, { timeout: 15e3, stdio: "pipe" }).toString().trim().replace(/[<>:"/\\|?*]/g, "_").slice(0, 100);
+          } catch {
+          }
+          if (format === "mp4") {
+            const outPath = join19(outputDir, `${title}.mp4`);
+            const outTemplate = join19(outputDir, `${title}.%(ext)s`);
+            execSync10(`yt-dlp -f "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best" --merge-output-format mp4 -o "${outTemplate}" "${url}"`, { timeout: 6e5, stdio: "pipe", cwd: outputDir });
+            const actualPath = existsSync16(outPath) ? outPath : outTemplate.replace("%(ext)s", "mp4");
+            return {
+              success: true,
+              output: `Downloaded video: ${actualPath}
+Title: ${title}
+Format: mp4`,
+              durationMs: Date.now() - start
+            };
+          } else {
+            const outPath = join19(outputDir, `${title}.mp3`);
+            const outTemplate = join19(outputDir, `${title}.%(ext)s`);
+            execSync10(`yt-dlp -x --audio-format mp3 --audio-quality 0 -o "${outTemplate}" "${url}"`, { timeout: 6e5, stdio: "pipe", cwd: outputDir });
+            const actualPath = existsSync16(outPath) ? outPath : outTemplate.replace("%(ext)s", "mp3");
+            return {
+              success: true,
+              output: `Downloaded audio: ${actualPath}
+Title: ${title}
+Format: mp3`,
+              durationMs: Date.now() - start
+            };
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          const stderr = err?.stderr?.toString?.()?.slice(0, 500) ?? "";
+          return {
+            success: false,
+            output: "",
+            error: `YouTube download failed: ${msg}${stderr ? "\n" + stderr : ""}`,
+            durationMs: Date.now() - start
+          };
+        }
+      }
+    };
   }
 });
 
@@ -22603,6 +22687,7 @@ __export(dist_exports, {
   WebFetchTool: () => WebFetchTool,
   WebSearchTool: () => WebSearchTool,
   WorkingNotesTool: () => WorkingNotesTool,
+  YouTubeDownloadTool: () => YouTubeDownloadTool,
   applyPatch: () => applyPatch,
   buildCompactDiff: () => buildCompactDiff,
   buildCustomTools: () => buildCustomTools,
@@ -28399,21 +28484,35 @@ ${transcript}`
       thinking;
       /** Abort signal — set by the runner so /stop can cancel in-flight requests */
       _abortSignal = null;
+      /** Multi-key pool — round-robin rotation per request for load distribution */
+      _keyPool = [];
+      _keyIndex = 0;
       constructor(baseUrl, model, apiKey, thinking) {
         this.baseUrl = normalizeBaseUrl(baseUrl);
         this.model = model;
         this.apiKey = apiKey ?? "";
         this.thinking = thinking ?? true;
       }
+      /** Set multiple API keys for round-robin rotation per request */
+      setKeyPool(keys) {
+        this._keyPool = keys.filter((k) => k.length > 0);
+        this._keyIndex = 0;
+      }
       /** Set the abort signal from the runner (called at run start) */
       setAbortSignal(signal) {
         this._abortSignal = signal;
       }
-      /** Build auth headers — all providers use standard Bearer token auth. */
+      /** Build auth headers — all providers use standard Bearer token auth.
+       *  When a key pool is set, round-robins through keys per request. */
       authHeaders() {
         const headers = { "Content-Type": "application/json" };
-        if (this.apiKey) {
-          headers["Authorization"] = `Bearer ${this.apiKey}`;
+        let key = this.apiKey;
+        if (this._keyPool.length > 0) {
+          key = this._keyPool[this._keyIndex % this._keyPool.length];
+          this._keyIndex++;
+        }
+        if (key) {
+          headers["Authorization"] = `Bearer ${key}`;
         }
         return headers;
       }
@@ -45945,26 +46044,45 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         const isArm = process.arch === "arm64" || process.arch === "arm";
         if (isArm) {
           renderInfo("  ARM device detected \u2014 installing build prerequisites then deps individually.");
+          const isMac = process.platform === "darwin";
           try {
             const { spawnSync } = await import("node:child_process");
-            renderInfo("  System build tools needed (llvm, gcc). Requesting sudo access...");
-            const sudoCheck = spawnSync("sudo", ["-v"], { stdio: "inherit", timeout: 6e4 });
-            if (sudoCheck.status === 0) {
-              renderInfo("  Installing system build dependencies (this may take a minute)...");
-              spawnSync("sudo", [
-                "apt-get",
-                "install",
-                "-y",
-                "--no-install-recommends",
-                "llvm-dev",
-                "gcc",
-                "g++",
-                "gfortran",
-                "libopenblas-dev",
-                "libsndfile1-dev"
-              ], { stdio: "inherit", timeout: 12e4 });
+            if (isMac) {
+              renderInfo("  macOS ARM detected \u2014 installing build deps via Homebrew...");
+              const brewCheck = spawnSync("which", ["brew"], { stdio: "pipe", timeout: 5e3 });
+              if (brewCheck.status === 0) {
+                spawnSync("brew", ["install", "llvm", "gcc", "openblas", "libsndfile"], {
+                  stdio: "inherit",
+                  timeout: 3e5
+                });
+                const llvmPrefix = spawnSync("brew", ["--prefix", "llvm"], { stdio: "pipe", timeout: 5e3 });
+                if (llvmPrefix.stdout) {
+                  process.env.LLVM_CONFIG = `${llvmPrefix.stdout.toString().trim()}/bin/llvm-config`;
+                }
+              } else {
+                renderWarning("  Homebrew not found. Install it: https://brew.sh");
+                renderWarning("  Then run: brew install llvm gcc openblas libsndfile");
+              }
             } else {
-              renderWarning("  sudo not available \u2014 skipping system build deps. librosa/lhotse may fail to compile.");
+              renderInfo("  System build tools needed (llvm, gcc). Requesting sudo access...");
+              const sudoCheck = spawnSync("sudo", ["-v"], { stdio: "inherit", timeout: 6e4 });
+              if (sudoCheck.status === 0) {
+                renderInfo("  Installing system build dependencies (this may take a minute)...");
+                spawnSync("sudo", [
+                  "apt-get",
+                  "install",
+                  "-y",
+                  "--no-install-recommends",
+                  "llvm-dev",
+                  "gcc",
+                  "g++",
+                  "gfortran",
+                  "libopenblas-dev",
+                  "libsndfile1-dev"
+                ], { stdio: "inherit", timeout: 12e4 });
+              } else {
+                renderWarning("  sudo not available \u2014 skipping system build deps. librosa/lhotse may fail to compile.");
+              }
             }
           } catch (err) {
             renderWarning(`  Could not install system build deps: ${err instanceof Error ? err.message : String(err)}`);
@@ -49969,6 +50087,85 @@ async function handleEndpoint(arg, ctx, local = false) {
     await handleSponsoredEndpoint(ctx, local);
     return;
   }
+  if (arg.startsWith("add ")) {
+    const addArg = arg.slice(4).replace(/\u2014/g, "--").replace(/\u2013/g, "--");
+    const addParts = addArg.split(/\s+/);
+    const addUrl = addParts[0];
+    const addAuthIdx = addParts.indexOf("--auth") !== -1 ? addParts.indexOf("--auth") : addParts.indexOf("-auth");
+    const addKey = addAuthIdx !== -1 && addParts[addAuthIdx + 1] ? addParts[addAuthIdx + 1] : "";
+    if (!addKey) {
+      renderError("Usage: /endpoint add <url> --auth <key>");
+      return;
+    }
+    const normalizedAddUrl = normalizeBaseUrl(addUrl);
+    const suffix = addKey.slice(-4);
+    const provider2 = detectProvider(addUrl);
+    const settings = resolveSettings(ctx.repoRoot);
+    const pool = settings.endpointKeys ?? [];
+    if (pool.some((k) => k.suffix === suffix)) {
+      renderWarning(`Key ending ...${suffix} is already in the pool.`);
+      return;
+    }
+    pool.push({ key: addKey, suffix });
+    const backendType2 = provider2.id === "ollama" ? "ollama" : "vllm";
+    ctx.setEndpoint(normalizedAddUrl, backendType2, addKey);
+    setConfigValue("backendUrl", normalizedAddUrl);
+    setConfigValue("backendType", backendType2);
+    setConfigValue("apiKey", addKey);
+    ctx.saveSettings({ backendUrl: normalizedAddUrl, backendType: backendType2, apiKey: addKey, endpointKeys: pool });
+    saveGlobalSettings({ endpointKeys: pool });
+    if (ctx.setKeyPool)
+      ctx.setKeyPool(pool.map((k) => k.key));
+    recordUsage("endpoint", normalizedAddUrl, {
+      meta: { provider: provider2.label, backendType: backendType2, authHint: addKey.slice(0, 4) + "...", authKey: addKey }
+    });
+    renderInfo(`Added key ...${suffix} to pool (${pool.length} key${pool.length > 1 ? "s" : ""} total)`);
+    for (const k of pool) {
+      process.stdout.write(`    ${c2.dim("\u25CF")} ${provider2.label}-${k.suffix}  ${c2.dim(k.key.slice(0, 4) + "..." + k.key.slice(-4))}
+`);
+    }
+    process.stdout.write("\n");
+    return;
+  }
+  if (arg === "keys" || arg === "pool") {
+    const settings = resolveSettings(ctx.repoRoot);
+    const pool = settings.endpointKeys ?? [];
+    if (pool.length === 0) {
+      renderInfo("No key pool configured. Use /endpoint add <url> --auth <key> to add keys.");
+      return;
+    }
+    const provider2 = detectProvider(ctx.config.backendUrl);
+    renderInfo(`Key pool for ${c2.bold(ctx.config.backendUrl)} (${pool.length} key${pool.length > 1 ? "s" : ""}):`);
+    for (const k of pool) {
+      process.stdout.write(`    ${c2.green("\u25CF")} ${provider2.label}-${k.suffix}  ${c2.dim(k.key.slice(0, 4) + "..." + k.key.slice(-4))}
+`);
+    }
+    process.stdout.write(`
+  ${c2.dim("Remove: /endpoint remove <suffix>")}
+
+`);
+    return;
+  }
+  if (arg.startsWith("remove ") || arg.startsWith("rm ")) {
+    const suffix = arg.split(/\s+/)[1];
+    const settings = resolveSettings(ctx.repoRoot);
+    const pool = settings.endpointKeys ?? [];
+    const idx = pool.findIndex((k) => k.suffix === suffix);
+    if (idx === -1) {
+      renderError(`No key with suffix "${suffix}" in the pool.`);
+      return;
+    }
+    pool.splice(idx, 1);
+    ctx.saveSettings({ endpointKeys: pool });
+    saveGlobalSettings({ endpointKeys: pool });
+    if (ctx.setKeyPool)
+      ctx.setKeyPool(pool.map((k) => k.key));
+    renderInfo(`Removed key ...${suffix} from pool (${pool.length} remaining).`);
+    if (pool.length === 0) {
+      renderInfo("Pool empty \u2014 using single API key from config.");
+    }
+    return;
+  }
   const normalizedArg = arg.replace(/\u2014/g, "--").replace(/\u2013/g, "--");
   const parts = normalizedArg.split(/\s+/);
   const url = parts[0];
@@ -63656,9 +63853,10 @@ function buildTools(repoRoot, config, contextWindowSize) {
     // Skill system (AIWG skills — discovery and execution)
     new SkillListTool(repoRoot),
     new SkillExecuteTool(repoRoot),
-    // Transcription tools (transcribe-cli / faster-whisper)
+    // Transcription + media download tools (transcribe-cli / faster-whisper / yt-dlp)
     new TranscribeFileTool(repoRoot),
     new TranscribeUrlTool(repoRoot),
+    new YouTubeDownloadTool(repoRoot),
     // Structured file generation (CSV, JSON, Markdown, Excel-compatible)
     new StructuredFileTool(repoRoot),
     // Code sandbox (isolated code execution)
@@ -64049,6 +64247,10 @@ ${lines.join("\n")}
     backend = new NexusAgenticBackend(sendFn, config.model, targetPeer, config.apiKey, thinkingEnabled);
   } else {
     backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey, thinkingEnabled);
+    const poolKeys = config._keyPool;
+    if (poolKeys && poolKeys.length > 0 && backend instanceof OllamaAgenticBackend) {
+      backend.setKeyPool(poolKeys);
+    }
   }
   try {
     const endpointHistory = loadUsageHistory("endpoint", repoRoot);
@@ -64934,6 +65136,9 @@ async function startInteractive(config, repoPath) {
   }
   if (savedSettings.apiKey)
     config = { ...config, apiKey: savedSettings.apiKey };
+  if (savedSettings.endpointKeys && savedSettings.endpointKeys.length > 0) {
+    config._keyPool = savedSettings.endpointKeys.map((k) => k.key);
+  }
   if (savedSettings.verbose !== void 0)
     config = { ...config, verbose: savedSettings.verbose };
   if (savedSettings.maxRetries !== void 0)
@@ -65982,6 +66187,14 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
         statusBar.stopRemoteMetricsPolling();
       }
     },
+    setKeyPool(keys) {
+      if (activeTask) {
+        const backend = activeTask.runner._backend;
+        if (backend?.setKeyPool)
+          backend.setKeyPool(keys);
+      }
+      currentConfig._keyPool = keys;
+    },
     clearScreen() {
       if (isNeovimActive()) {
         writeToNeovimOutput("[screen cleared]\n");

package/package.json

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