open-agents-ai 0.184.71 → 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" }
@@ -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,
@@ -50202,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,
@@ -65099,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.71",
+  "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",