open-agents-ai 0.184.71 → 0.184.73

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" }
@@ -28487,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) {
@@ -28502,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" };
@@ -28512,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,
@@ -28574,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.
@@ -38613,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,
@@ -46047,17 +46168,31 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
           const isMac = process.platform === "darwin";
           try {
             const { spawnSync } = await import("node:child_process");
+            if (process.stdout.isTTY) {
+              process.stdout.write("\x1B[?1002l\x1B[?1003l\x1B[?1006l");
+            }
             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",
+                const brewResult = spawnSync("brew", ["install", "llvm", "gcc", "openblas", "libsndfile"], {
+                  stdio: "pipe",
                   timeout: 3e5
                 });
+                if (brewResult.stdout)
+                  process.stdout.write(brewResult.stdout);
+                if (brewResult.stderr)
+                  process.stderr.write(brewResult.stderr);
                 const llvmPrefix = spawnSync("brew", ["--prefix", "llvm"], { stdio: "pipe", timeout: 5e3 });
                 if (llvmPrefix.stdout) {
-                  process.env.LLVM_CONFIG = `${llvmPrefix.stdout.toString().trim()}/bin/llvm-config`;
+                  const prefix = llvmPrefix.stdout.toString().trim();
+                  process.env.LLVM_CONFIG = `${prefix}/bin/llvm-config`;
+                  const openblas = spawnSync("brew", ["--prefix", "openblas"], { stdio: "pipe", timeout: 5e3 });
+                  if (openblas.stdout) {
+                    const obPrefix = openblas.stdout.toString().trim();
+                    process.env.LDFLAGS = `${process.env.LDFLAGS ?? ""} -L${obPrefix}/lib`.trim();
+                    process.env.CPPFLAGS = `${process.env.CPPFLAGS ?? ""} -I${obPrefix}/include`.trim();
+                  }
                 }
               } else {
                 renderWarning("  Homebrew not found. Install it: https://brew.sh");
@@ -46068,7 +46203,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
               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", [
+                const aptResult = spawnSync("sudo", [
                   "apt-get",
                   "install",
                   "-y",
@@ -46079,11 +46214,18 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
                   "gfortran",
                   "libopenblas-dev",
                   "libsndfile1-dev"
-                ], { stdio: "inherit", timeout: 12e4 });
+                ], { stdio: "pipe", timeout: 12e4 });
+                if (aptResult.stdout)
+                  process.stdout.write(aptResult.stdout);
+                if (aptResult.stderr)
+                  process.stderr.write(aptResult.stderr);
               } else {
                 renderWarning("  sudo not available \u2014 skipping system build deps. librosa/lhotse may fail to compile.");
               }
             }
+            if (process.stdout.isTTY) {
+              process.stdout.write("\x1B[?1002h\x1B[?1006h");
+            }
           } catch (err) {
             renderWarning(`  Could not install system build deps: ${err instanceof Error ? err.message : String(err)}`);
           }
@@ -46119,8 +46261,10 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
           // Non-fatal (not hard-imported by LuxTTS):
           { cmd: `${pipCmd} -m pip install --quiet piper-phonemize --find-links https://k2-fsa.github.io/icefall/piper_phonemize.html`, fatal: false, label: "piper-phonemize (optional)" },
           { cmd: `${pipCmd} -m pip install --quiet jieba pypinyin cn2an`, fatal: true, label: "Chinese text processing" },
-          // LuxTTS itself:
-          { cmd: `${pipCmd} -m pip install --quiet -e ${JSON.stringify(repoDir)}`, fatal: true, label: "LuxTTS (editable install)" }
+          // LuxTTS itself: use --no-deps on ARM because we installed deps individually above.
+          // Without --no-deps, pip tries to resolve zipvoice's full dependency tree which
+          // includes piper-phonemize — and that has no macOS ARM wheel, causing fatal failure.
+          { cmd: `${pipCmd} -m pip install --quiet --no-deps -e ${JSON.stringify(repoDir)}`, fatal: true, label: "LuxTTS (editable install)" }
         ] : [
           // x86_64: all-in-one (fast, all wheels available)
           {
@@ -50202,7 +50346,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,
@@ -65099,6 +65248,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");
@@ -69957,9 +70107,40 @@ async function main() {
 }
 var scriptPath = process.argv[1] ?? "";
 var isMain = scriptPath.endsWith("index.js") || scriptPath.endsWith("index.ts") || scriptPath.endsWith("open-agents-bin") || scriptPath.includes("open-agents") || scriptPath.includes("/oa");
+function crashLog(label, err) {
+  const msg = err instanceof Error ? err.stack ?? err.message : String(err);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const logLine = `[${timestamp}] ${label}: ${msg}
+`;
+  try {
+    const { appendFileSync: appendFileSync5, mkdirSync: mkdirSync30 } = __require("node:fs");
+    const { join: join76 } = __require("node:path");
+    const { homedir: homedir20 } = __require("node:os");
+    const logDir = join76(homedir20(), ".open-agents");
+    mkdirSync30(logDir, { recursive: true });
+    appendFileSync5(join76(logDir, "crash.log"), logLine);
+  } catch {
+  }
+  try {
+    process.stdout.write("\x1B[?1002l\x1B[?1003l\x1B[?1006l\x1B[?25h\x1B[?1049l\x1B[0m\n");
+    process.stderr.write(`\x1B[31m\u2716 ${label}:\x1B[0m ${msg}
+`);
+    process.stderr.write(`\x1B[2m  Crash log: ~/.open-agents/crash.log\x1B[0m
+`);
+  } catch {
+  }
+}
+process.on("uncaughtException", (err) => {
+  crashLog("Uncaught exception", err);
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+  crashLog("Unhandled rejection", reason);
+  process.exit(1);
+});
 if (isMain && !process.env.__OPEN_AGENTS_NO_AUTO_RUN) {
   await main().catch((err) => {
-    printError(err instanceof Error ? err.message : String(err));
+    crashLog("Fatal error", err);
     process.exit(1);
   });
 }

package/package.json

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