clawmoney 0.13.10 → 0.13.13

package/dist/relay/pricing.js

@@ -57,8 +57,12 @@ export const API_PRICES = {
     "antigravity-gemini-3-pro": { input: 2, output: 12 },
     "antigravity-gemini-3.1-pro": { input: 2, output: 12 },
     "antigravity-gemini-3-flash": { input: 0.50, output: 3 },
-    "antigravity-claude-sonnet-4-6": { input: 3, output: 15 },
+    "antigravity-gemini-2.5-pro": { input: 1.25, output: 10 },
+    "antigravity-gemini-2.5-flash": { input: 0.30, output: 2.50 },
+    "antigravity-claude-opus-4-6": { input: 5, output: 25 },
     "antigravity-claude-opus-4-6-thinking": { input: 5, output: 25 },
+    "antigravity-claude-sonnet-4-6": { input: 3, output: 15 },
+    "antigravity-claude-sonnet-4-5": { input: 3, output: 15 },
     // ── Google (Gemini) ──
     // Verified against LiteLLM pricing DB.
     "gemini-3.1-pro-preview": { input: 2, output: 12 },

package/dist/relay/provider.js

@@ -97,8 +97,30 @@ function loadRelayConfig(cliOverride) {
         agent_id: raw.agent_id,
         agent_slug: raw.agent_slug,
         relay,
+        proxy: typeof raw.proxy === "string" ? raw.proxy : undefined,
     };
 }
+/**
+ * Export the config's `proxy` setting into process.env so every downstream
+ * module (claude-api, codex-api, gemini-api, antigravity-api) that already
+ * reads HTTPS_PROXY at startup picks it up without any per-module changes.
+ * Silently no-ops if the env var is already set by the user's shell.
+ */
+function applyProxyFromConfig(config) {
+    if (!config.proxy)
+        return;
+    const alreadySet = process.env.HTTPS_PROXY ||
+        process.env.https_proxy ||
+        process.env.HTTP_PROXY ||
+        process.env.http_proxy;
+    if (alreadySet) {
+        logger.info(`[provider] shell HTTPS_PROXY=${alreadySet} overrides config.yaml proxy=${config.proxy}`);
+        return;
+    }
+    process.env.HTTPS_PROXY = config.proxy;
+    process.env.HTTP_PROXY = config.proxy;
+    logger.info(`[provider] using config.yaml proxy=${config.proxy}`);
+}
 // ── Request handler ──
 function messagesToPrompt(messages) {
     return messages.map((m) => String(m.content ?? "")).join("\n");
@@ -239,6 +261,10 @@ export function runRelayProvider(cliOverride) {
         process.exit(1);
     }
     const config = loadRelayConfig(cliOverride);
+    // Make the config-level proxy visible to every upstream module that reads
+    // process.env.HTTPS_PROXY / http_proxy at init time. Must run BEFORE any
+    // preflight call so the first outbound request already goes through it.
+    applyProxyFromConfig(config);
     // Prepare relay sandbox assets once at startup.
     ensureEmptyMcpConfig();
     ensureSandboxDir();

package/dist/relay/types.d.ts

@@ -87,4 +87,14 @@ export interface RelayProviderConfig {
     agent_id?: string;
     agent_slug?: string;
     relay: RelayProviderSettings;
+    /**
+     * Upstream HTTPS proxy. When set, the daemon exports HTTPS_PROXY /
+     * HTTP_PROXY before running any fetch, so providers on GFW-side machines
+     * don't have to remember to `export https_proxy=` in every shell. Only
+     * plain HTTP(S) proxies are supported (SOCKS is ignored with a warning).
+     *
+     * Example:
+     *     proxy: http://127.0.0.1:7897
+     */
+    proxy?: string;
 }

package/dist/relay/upstream/antigravity-api.js

@@ -79,7 +79,11 @@ const ANTIGRAVITY_LOAD_ENDPOINTS = [
     ANTIGRAVITY_ENDPOINT_PROD,
     ANTIGRAVITY_ENDPOINT_DAILY,
 ];
-const GENERATE_PATH = "/v1internal:generateContent";
+// Antigravity upstream only supports streamGenerateContent — the non-stream
+// variant returns a generic 500 "Unknown Error" for every model we tested.
+// Documented in sub2api/backend/internal/service/antigravity_gateway_service.go:1409
+// ("Antigravity 上游只支持流式请求"). We parse the ?alt=sse response inline.
+const GENERATE_PATH = "/v1internal:streamGenerateContent?alt=sse";
 /**
  * Map our `antigravity-*` market-facing model IDs to the real model names
  * Google's v1internal endpoint accepts. The `antigravity-` prefix only
@@ -90,8 +94,11 @@ const GENERATE_PATH = "/v1internal:generateContent";
  * names.
  */
 const ANTIGRAVITY_MODEL_MAP = {
-    "antigravity-gemini-3-pro": "gemini-3-pro-high",
-    "antigravity-gemini-3.1-pro": "gemini-3-pro-high",
+    // Gemini 3 Pro was retired in April 2026 — Google now returns a plain-text
+    // "no longer available, switch to Gemini 3.1 Pro" body if you ask for it.
+    // Route both the 3-pro and 3.1-pro market IDs to 3.1-pro-high.
+    "antigravity-gemini-3-pro": "gemini-3.1-pro-high",
+    "antigravity-gemini-3.1-pro": "gemini-3.1-pro-high",
     "antigravity-gemini-3-flash": "gemini-3-flash",
     "antigravity-gemini-2.5-pro": "gemini-2.5-pro",
     "antigravity-gemini-2.5-flash": "gemini-2.5-flash",
@@ -589,8 +596,7 @@ async function doCallAntigravityApi(opts) {
             throw err;
         }
         if (resp.ok) {
-            const data = (await resp.json());
-            const parsed = parseAntigravityResponse(data, opts.model);
+            const parsed = await parseAntigravitySseResponse(resp, opts.model);
             recordAntigravitySpend(parsed, opts.model);
             return parsed;
         }
@@ -640,23 +646,89 @@ function recordAntigravitySpend(parsed, model) {
     const cost = calculateCost(model, input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens);
     rateGuard.recordSpend(cost.apiCost);
 }
-function parseAntigravityResponse(data, fallbackModel) {
-    const response = data.response ?? {};
-    const candidates = response.candidates ?? [];
-    const firstCandidate = candidates[0];
-    const text = (firstCandidate?.content?.parts ?? [])
-        .map((p) => p.text ?? "")
-        .join("");
-    const usage = response.usageMetadata ?? {};
-    const cached = usage.cachedContentTokenCount ?? 0;
+/**
+ * Parse Antigravity's streamGenerateContent?alt=sse response. Google sends
+ * Server-Sent Events where each line is `data: {json}`; the JSON shape
+ * matches a single `V1InternalGenerateResponse` chunk. Text parts accumulate
+ * across chunks, and usageMetadata is usually on the last chunk.
+ *
+ * Note: unlike vanilla Gemini API, Antigravity wraps each chunk's body in a
+ * top-level `response` field (mirroring the non-stream shape), so we unwrap.
+ */
+async function parseAntigravitySseResponse(resp, fallbackModel) {
+    const reader = resp.body?.getReader();
+    if (!reader) {
+        throw new Error("Antigravity streamGenerateContent returned no body");
+    }
+    const decoder = new TextDecoder("utf-8");
+    let buffer = "";
+    let text = "";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cachedTokens = 0;
+    const processChunk = (jsonStr) => {
+        const trimmed = jsonStr.trim();
+        if (!trimmed || trimmed === "[DONE]")
+            return;
+        let chunk;
+        try {
+            chunk = JSON.parse(trimmed);
+        }
+        catch {
+            return;
+        }
+        // Antigravity SSE sometimes emits chunks with fields at the top level
+        // (without the `response` wrapper). Handle both shapes.
+        const body = chunk.response ??
+            chunk;
+        const candidates = body?.candidates ?? [];
+        for (const cand of candidates) {
+            for (const part of cand.content?.parts ?? []) {
+                if (part.text)
+                    text += part.text;
+            }
+        }
+        const usage = body?.usageMetadata;
+        if (usage) {
+            if (typeof usage.promptTokenCount === "number") {
+                inputTokens = usage.promptTokenCount;
+            }
+            if (typeof usage.candidatesTokenCount === "number") {
+                outputTokens = usage.candidatesTokenCount;
+            }
+            if (typeof usage.cachedContentTokenCount === "number") {
+                cachedTokens = usage.cachedContentTokenCount;
+            }
+        }
+    };
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        let newlineIdx;
+        while ((newlineIdx = buffer.indexOf("\n")) >= 0) {
+            const line = buffer.slice(0, newlineIdx).replace(/\r$/, "");
+            buffer = buffer.slice(newlineIdx + 1);
+            if (!line)
+                continue;
+            if (line.startsWith("data:")) {
+                processChunk(line.slice(5));
+            }
+        }
+    }
+    // Flush tail (unlikely but safe)
+    if (buffer.startsWith("data:")) {
+        processChunk(buffer.slice(5));
+    }
     return {
         text,
         sessionId: "",
         usage: {
-            input_tokens: Math.max(0, (usage.promptTokenCount ?? 0) - cached),
-            output_tokens: usage.candidatesTokenCount ?? 0,
+            input_tokens: Math.max(0, inputTokens - cachedTokens),
+            output_tokens: outputTokens,
             cache_creation_tokens: 0,
-            cache_read_tokens: cached,
+            cache_read_tokens: cachedTokens,
         },
         model: fallbackModel,
         costUsd: 0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmoney",
-  "version": "0.13.10",
+  "version": "0.13.13",
   "description": "ClawMoney CLI -- Earn rewards with your AI agent",
   "type": "module",
   "bin": {