open-agents-ai 0.184.70 → 0.184.72

package/dist/index.js

@@ -560,6 +560,10 @@ var init_normalizeUrl = __esm({
     "use strict";
     PROVIDERS = [
       // --- Cloud providers (specific domains) ---
+      {
+        match: (u) => /api\.anthropic\.com/i.test(u),
+        info: { id: "anthropic", label: "Anthropic (Claude)", local: false, authRequired: true, keyPrefix: "sk-ant-", modelsPath: "/v1/models" }
+      },
       {
         match: (u) => /api\.openai\.com/i.test(u),
         info: { id: "openai", label: "OpenAI", local: false, authRequired: true, keyPrefix: "sk-", modelsPath: "/v1/models" }
@@ -11949,7 +11953,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 +12271,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 +22691,7 @@ __export(dist_exports, {
   WebFetchTool: () => WebFetchTool,
   WebSearchTool: () => WebSearchTool,
   WorkingNotesTool: () => WorkingNotesTool,
+  YouTubeDownloadTool: () => YouTubeDownloadTool,
   applyPatch: () => applyPatch,
   buildCompactDiff: () => buildCompactDiff,
   buildCustomTools: () => buildCustomTools,
@@ -28402,11 +28491,14 @@ ${transcript}`
       /** Multi-key pool — round-robin rotation per request for load distribution */
       _keyPool = [];
       _keyIndex = 0;
+      /** Whether this backend targets Anthropic's Messages API */
+      _isAnthropic = false;
       constructor(baseUrl, model, apiKey, thinking) {
         this.baseUrl = normalizeBaseUrl(baseUrl);
         this.model = model;
         this.apiKey = apiKey ?? "";
         this.thinking = thinking ?? true;
+        this._isAnthropic = /api\.anthropic\.com/i.test(baseUrl);
       }
       /** Set multiple API keys for round-robin rotation per request */
       setKeyPool(keys) {
@@ -28417,7 +28509,7 @@ ${transcript}`
       setAbortSignal(signal) {
         this._abortSignal = signal;
       }
-      /** Build auth headers — all providers use standard Bearer token auth.
+      /** Build auth headers — adapts to provider (Bearer for most, x-api-key for Anthropic).
        *  When a key pool is set, round-robins through keys per request. */
       authHeaders() {
         const headers = { "Content-Type": "application/json" };
@@ -28427,11 +28519,19 @@ ${transcript}`
           this._keyIndex++;
         }
         if (key) {
-          headers["Authorization"] = `Bearer ${key}`;
+          if (this._isAnthropic) {
+            headers["x-api-key"] = key;
+            headers["anthropic-version"] = "2023-06-01";
+          } else {
+            headers["Authorization"] = `Bearer ${key}`;
+          }
         }
         return headers;
       }
       async chatCompletion(request) {
+        if (this._isAnthropic) {
+          return this._anthropicChatCompletion(request);
+        }
         const body = {
           model: this.model,
           messages: request.messages,
@@ -28489,6 +28589,106 @@ ${transcript}`
           } : void 0
         };
       }
+      /** Anthropic Messages API translation — converts our standard format to/from Anthropic's. */
+      async _anthropicChatCompletion(request) {
+        const systemMsgs = request.messages.filter((m) => m.role === "system");
+        const nonSystemMsgs = request.messages.filter((m) => m.role !== "system");
+        const systemText = systemMsgs.map((m) => typeof m.content === "string" ? m.content : "").join("\n\n");
+        const anthropicMessages = [];
+        for (const msg of nonSystemMsgs) {
+          if (msg.role === "tool") {
+            anthropicMessages.push({
+              role: "user",
+              content: [{
+                type: "tool_result",
+                tool_use_id: msg.tool_call_id ?? "",
+                content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+              }]
+            });
+          } else if (msg.role === "assistant" && msg.tool_calls?.length > 0) {
+            const blocks = [];
+            if (typeof msg.content === "string" && msg.content) {
+              blocks.push({ type: "text", text: msg.content });
+            }
+            for (const tc of msg.tool_calls) {
+              blocks.push({
+                type: "tool_use",
+                id: tc.id,
+                name: tc.function?.name ?? tc.name,
+                input: typeof tc.function?.arguments === "string" ? (() => {
+                  try {
+                    return JSON.parse(tc.function.arguments);
+                  } catch {
+                    return {};
+                  }
+                })() : tc.function?.arguments ?? {}
+              });
+            }
+            anthropicMessages.push({ role: "assistant", content: blocks });
+          } else {
+            anthropicMessages.push({
+              role: msg.role === "user" ? "user" : "assistant",
+              content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content ?? "")
+            });
+          }
+        }
+        const anthropicTools = (request.tools ?? []).filter((t) => t.type === "function" && t.function).map((t) => ({
+          name: t.function.name,
+          description: t.function.description,
+          input_schema: t.function.parameters
+        }));
+        const body = {
+          model: this.model,
+          messages: anthropicMessages,
+          max_tokens: request.maxTokens ?? 8192,
+          temperature: request.temperature
+        };
+        if (systemText)
+          body.system = systemText;
+        if (anthropicTools.length > 0)
+          body.tools = anthropicTools;
+        const fetchOpts = {
+          method: "POST",
+          headers: this.authHeaders(),
+          body: JSON.stringify(body)
+        };
+        if (this._abortSignal)
+          fetchOpts.signal = this._abortSignal;
+        const resp = await fetch(`${this.baseUrl}/v1/messages`, fetchOpts);
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          throw new Error(`Anthropic HTTP ${resp.status}: ${text.slice(0, 300)}`);
+        }
+        const data = await resp.json();
+        const contentBlocks = data.content ?? [];
+        const usage = data.usage;
+        let textContent = "";
+        const toolCalls = [];
+        for (const block of contentBlocks) {
+          if (block.type === "text") {
+            textContent += block.text ?? "";
+          } else if (block.type === "tool_use") {
+            toolCalls.push({
+              id: block.id || crypto.randomUUID(),
+              name: block.name,
+              arguments: block.input ?? {}
+            });
+          }
+        }
+        return {
+          choices: [{
+            message: {
+              content: textContent || null,
+              toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+            }
+          }],
+          usage: usage ? {
+            totalTokens: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0),
+            promptTokens: usage.input_tokens,
+            completionTokens: usage.output_tokens
+          } : void 0
+        };
+      }
       /**
        * SSE streaming variant — yields StreamChunks as tokens arrive.
        * Uses `stream: true` and the current thinking setting.
@@ -38528,9 +38728,15 @@ async function fetchOllamaModels(baseUrl) {
 async function fetchOpenAIModels(baseUrl, apiKey) {
   const normalized = normalizeBaseUrl(baseUrl);
   const url = `${normalized}/v1/models`;
+  const isAnthropic = /api\.anthropic\.com/i.test(baseUrl);
   const headers = {};
   if (apiKey) {
-    headers["Authorization"] = `Bearer ${apiKey}`;
+    if (isAnthropic) {
+      headers["x-api-key"] = apiKey;
+      headers["anthropic-version"] = "2023-06-01";
+    } else {
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    }
   }
   const resp = await fetch(url, {
     headers,
@@ -45959,26 +46165,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)}`);
@@ -50098,7 +50323,12 @@ async function handleEndpoint(arg, ctx, local = false) {
     const healthUrl = `${normalizedUrl}${provider.modelsPath}`;
     const headers = {};
     if (apiKey) {
-      headers["Authorization"] = `Bearer ${apiKey}`;
+      if (provider.id === "anthropic") {
+        headers["x-api-key"] = apiKey;
+        headers["anthropic-version"] = "2023-06-01";
+      } else {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
     }
     const resp = await fetch(healthUrl, {
       headers,
@@ -63749,9 +63979,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)
@@ -64994,6 +65225,7 @@ async function startInteractive(config, repoPath) {
   initOaDirectory(repoRoot);
   const savedSettings = resolveSettings(repoRoot);
   if (process.stdout.isTTY) {
+    process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
     process.stdout.write("\x1B[?1002l\x1B[?1003l\x1B[?1006l\x1B[?1015l\x1B[?1049h\x1B[48;5;233m\x1B[2J\x1B[3J\x1B[H\x1B[?25l");
     const restoreScreen = () => {
       process.stdout.write("\x1B[?1002l\x1B[?1003l\x1B[?1006l\x1B[?1015l\x1B[?25h\x1B[?1049l");

package/package.json

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