clawmoney 0.12.2 → 0.13.0

package/dist/commands/antigravity.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `clawmoney antigravity login` — OAuth browser flow for Google Antigravity IDE.
+ *
+ * Antigravity is Google's agentic IDE. Its quota pool is separate from Gemini
+ * CLI's, so a provider who pairs an Antigravity daemon with a Gemini CLI
+ * daemon on the same Google account gets 2× Gemini capacity. More importantly,
+ * Antigravity is the only path that exposes Claude models to non-Anthropic-
+ * subscribed Google Ultra users.
+ *
+ * Flow:
+ *   1. Generate PKCE verifier + challenge.
+ *   2. Start a short-lived HTTP server on localhost:51121.
+ *   3. Print the Google consent URL (and try to open it in the browser).
+ *   4. Wait for Google to redirect back with ?code=....
+ *   5. Exchange the code for refresh + access tokens.
+ *   6. Resolve the cloudaicompanionProject via loadCodeAssist.
+ *   7. Persist to ~/.clawmoney/antigravity-accounts.json.
+ *
+ * The implementation borrows heavily from the opencode-antigravity-auth
+ * reference project — same client id, same scopes, same PKCE + state payload
+ * format, so tokens issued by this flow are interchangeable with that plugin.
+ */
+export declare function antigravityLoginCommand(): Promise<void>;
+export declare function antigravityStatusCommand(): Promise<void>;

package/dist/commands/antigravity.js

@@ -0,0 +1,218 @@
+/**
+ * `clawmoney antigravity login` — OAuth browser flow for Google Antigravity IDE.
+ *
+ * Antigravity is Google's agentic IDE. Its quota pool is separate from Gemini
+ * CLI's, so a provider who pairs an Antigravity daemon with a Gemini CLI
+ * daemon on the same Google account gets 2× Gemini capacity. More importantly,
+ * Antigravity is the only path that exposes Claude models to non-Anthropic-
+ * subscribed Google Ultra users.
+ *
+ * Flow:
+ *   1. Generate PKCE verifier + challenge.
+ *   2. Start a short-lived HTTP server on localhost:51121.
+ *   3. Print the Google consent URL (and try to open it in the browser).
+ *   4. Wait for Google to redirect back with ?code=....
+ *   5. Exchange the code for refresh + access tokens.
+ *   6. Resolve the cloudaicompanionProject via loadCodeAssist.
+ *   7. Persist to ~/.clawmoney/antigravity-accounts.json.
+ *
+ * The implementation borrows heavily from the opencode-antigravity-auth
+ * reference project — same client id, same scopes, same PKCE + state payload
+ * format, so tokens issued by this flow are interchangeable with that plugin.
+ */
+import { createServer } from "node:http";
+import { createHash, randomBytes } from "node:crypto";
+import { exec } from "node:child_process";
+import chalk from "chalk";
+import ora from "ora";
+import { ANTIGRAVITY_CLIENT_ID, ANTIGRAVITY_SCOPES, ANTIGRAVITY_REDIRECT_URI, exchangeAntigravityAuthCode, fetchAntigravityUserEmail, storeNewAntigravityAccount, ANTIGRAVITY_ACCOUNTS_FILE, loadAccounts, } from "../relay/upstream/antigravity-api.js";
+const CALLBACK_PORT = 51121;
+const CALLBACK_PATH = "/oauth-callback";
+const CALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
+function base64Url(input) {
+    return input
+        .toString("base64")
+        .replace(/=/g, "")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_");
+}
+function generatePkce() {
+    // RFC 7636: verifier is 43–128 chars of [A-Z / a-z / 0-9 / "-" / "." / "_" / "~"].
+    // We use 32 random bytes → 43-char base64url, matching @openauthjs/openauth.
+    const verifier = base64Url(randomBytes(32));
+    const challenge = base64Url(createHash("sha256").update(verifier).digest());
+    return { verifier, challenge };
+}
+function encodeState(verifier) {
+    return Buffer.from(JSON.stringify({ verifier, projectId: "" }), "utf8").toString("base64url");
+}
+function buildAuthUrl(challenge, state) {
+    const url = new URL("https://accounts.google.com/o/oauth2/v2/auth");
+    url.searchParams.set("client_id", ANTIGRAVITY_CLIENT_ID);
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("redirect_uri", ANTIGRAVITY_REDIRECT_URI);
+    url.searchParams.set("scope", ANTIGRAVITY_SCOPES.join(" "));
+    url.searchParams.set("code_challenge", challenge);
+    url.searchParams.set("code_challenge_method", "S256");
+    url.searchParams.set("state", state);
+    url.searchParams.set("access_type", "offline");
+    // `prompt=consent` forces Google to re-issue a refresh_token even if the
+    // user has already granted the Antigravity scopes before. Without this,
+    // Google silently drops refresh_token from the token response and we'd
+    // store a dead account.
+    url.searchParams.set("prompt", "consent");
+    return url.toString();
+}
+function openInBrowser(url) {
+    const cmd = process.platform === "darwin"
+        ? `open "${url}"`
+        : process.platform === "win32"
+            ? `start "" "${url}"`
+            : `xdg-open "${url}"`;
+    exec(cmd, (err) => {
+        if (err) {
+            // Non-fatal — we already printed the URL for the user to copy.
+        }
+    });
+}
+function waitForCallback() {
+    return new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            if (!req.url || !req.url.startsWith(CALLBACK_PATH)) {
+                res.writeHead(404);
+                res.end();
+                return;
+            }
+            const parsed = new URL(req.url, `http://localhost:${CALLBACK_PORT}`);
+            const error = parsed.searchParams.get("error");
+            if (error) {
+                res.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+                res.end(`<html><body><h1>Login failed</h1><p>${error}</p><p>You can close this tab and re-run <code>clawmoney antigravity login</code>.</p></body></html>`);
+                reject(new Error(`OAuth error: ${error}`));
+                return;
+            }
+            const code = parsed.searchParams.get("code");
+            const state = parsed.searchParams.get("state");
+            if (!code || !state) {
+                res.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+                res.end("<html><body><h1>Missing code or state</h1></body></html>");
+                reject(new Error("OAuth callback missing code/state"));
+                return;
+            }
+            res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+            res.end(`<html><body style="font-family:system-ui;padding:40px;text-align:center;">
+          <h1>✓ ClawMoney is linked to Antigravity</h1>
+          <p>You can close this tab and return to your terminal.</p>
+        </body></html>`);
+            resolve({ result: { code, state }, server });
+        });
+        server.on("error", (err) => reject(err));
+        server.listen(CALLBACK_PORT, "127.0.0.1");
+        setTimeout(() => {
+            reject(new Error(`Timed out waiting for OAuth callback after ${Math.round(CALLBACK_TIMEOUT_MS / 60_000)} minutes.`));
+        }, CALLBACK_TIMEOUT_MS).unref();
+    });
+}
+export async function antigravityLoginCommand() {
+    console.log(chalk.bold("\n  Antigravity OAuth login\n"));
+    console.log(chalk.dim("  This links a Google account's Antigravity IDE quota to your ClawMoney daemon."));
+    console.log(chalk.dim("  Antigravity has a SEPARATE quota pool from Gemini CLI — use both to double your capacity."));
+    console.log("");
+    const { verifier, challenge } = generatePkce();
+    const state = encodeState(verifier);
+    const authUrl = buildAuthUrl(challenge, state);
+    const spinner = ora("Starting local callback server on 127.0.0.1:51121...").start();
+    let callbackPromise;
+    try {
+        callbackPromise = waitForCallback();
+        spinner.succeed("Callback server ready");
+    }
+    catch (err) {
+        spinner.fail(`Failed to bind localhost:${CALLBACK_PORT} — is another clawmoney login already running?`);
+        throw err;
+    }
+    console.log("");
+    console.log(chalk.bold("  Open this URL in your browser to authorize:"));
+    console.log("");
+    console.log("    " + chalk.cyan(authUrl));
+    console.log("");
+    console.log(chalk.dim("  (Attempting to open it automatically. If nothing opens, copy it manually.)"));
+    openInBrowser(authUrl);
+    const waitSpinner = ora("Waiting for Google to redirect back...").start();
+    let code;
+    let server;
+    try {
+        const callback = await callbackPromise;
+        code = callback.result.code;
+        server = callback.server;
+        waitSpinner.succeed("Received authorization code");
+    }
+    catch (err) {
+        waitSpinner.fail(err.message);
+        throw err;
+    }
+    finally {
+        // The HTTP server is single-use; close it regardless of success.
+    }
+    server.close();
+    const exchangeSpinner = ora("Exchanging code for tokens...").start();
+    let tokens;
+    try {
+        tokens = await exchangeAntigravityAuthCode({
+            code,
+            code_verifier: verifier,
+        });
+        exchangeSpinner.succeed("Tokens received");
+    }
+    catch (err) {
+        exchangeSpinner.fail(err.message);
+        throw err;
+    }
+    const emailSpinner = ora("Fetching account email...").start();
+    const email = await fetchAntigravityUserEmail(tokens.access_token);
+    if (email) {
+        emailSpinner.succeed(`Linked account: ${email}`);
+    }
+    else {
+        emailSpinner.warn("Could not fetch account email (not fatal)");
+    }
+    const storeSpinner = ora("Resolving project ID and persisting account...").start();
+    try {
+        const account = await storeNewAntigravityAccount({
+            refresh_token: tokens.refresh_token,
+            access_token: tokens.access_token,
+            expiry_ms: tokens.expiry_ms,
+            email,
+        });
+        storeSpinner.succeed(`Saved to ${ANTIGRAVITY_ACCOUNTS_FILE} (project=${account.project_id})`);
+    }
+    catch (err) {
+        storeSpinner.fail(err.message);
+        throw err;
+    }
+    console.log("");
+    console.log(chalk.green("  Antigravity login complete."));
+    console.log("");
+    console.log(chalk.dim("  Next: register a model and start the daemon. Example:\n" +
+        "    clawmoney relay register --cli antigravity --model antigravity-gemini-3-pro\n" +
+        "    clawmoney relay start --cli antigravity"));
+}
+export async function antigravityStatusCommand() {
+    const file = loadAccounts();
+    if (file.accounts.length === 0) {
+        console.log(chalk.dim("No Antigravity accounts stored."));
+        console.log(chalk.dim(`  Run "clawmoney antigravity login" to add one.`));
+        return;
+    }
+    console.log(chalk.bold("\n  Antigravity accounts\n"));
+    for (let i = 0; i < file.accounts.length; i++) {
+        const a = file.accounts[i];
+        const expiryStr = a.expiry_ms
+            ? new Date(a.expiry_ms).toISOString().replace("T", " ").slice(0, 19)
+            : "unknown";
+        console.log(`  ${i === 0 ? chalk.bold("●") : " "} ${a.email ?? "(email unknown)"}`);
+        console.log(`      project:  ${a.project_id ?? "-"}`);
+        console.log(`      expires:  ${expiryStr}`);
+        console.log("");
+    }
+}

package/dist/commands/relay.js

@@ -6,26 +6,63 @@ import ora from "ora";
 import { requireConfig } from "../utils/config.js";
 import { apiGet, apiPost } from "../utils/api.js";
 import { readRelayPid, isRelayPidAlive, removeRelayPid } from "../relay/provider.js";
+import { API_PRICES, RELAY_DISCOUNT } from "../relay/pricing.js";
 const LOG_FILE = join(homedir(), ".clawmoney", "relay.log");
 export async function relayRegisterCommand(options) {
     const config = requireConfig();
     // Validate CLI type
-    const validClis = ["claude", "codex", "gemini"];
+    const validClis = ["claude", "codex", "gemini", "antigravity"];
     if (!validClis.includes(options.cli)) {
         console.error(chalk.red(`Invalid CLI type "${options.cli}". Must be one of: ${validClis.join(", ")}`));
         process.exit(1);
     }
-    // Verify CLI is installed
-    const spinner = ora(`Checking if ${options.cli} is installed...`).start();
-    try {
-        execSync(`which ${options.cli}`, { stdio: "pipe" });
-        spinner.succeed(`${options.cli} is available`);
+    // Antigravity is api-only — there is no local CLI binary. For the other
+    // types we still probe `which` so misconfigured boxes fail fast.
+    if (options.cli === "antigravity") {
+        const spinner = ora("Checking Antigravity OAuth token...").start();
+        try {
+            const { loadAccounts } = await import("../relay/upstream/antigravity-api.js");
+            const file = loadAccounts();
+            if (file.accounts.length === 0) {
+                spinner.fail(chalk.red("No Antigravity accounts found."));
+                console.log(chalk.dim(`  Run "clawmoney antigravity login" first to link a Google account.`));
+                process.exit(1);
+            }
+            spinner.succeed(`Antigravity linked (${file.accounts[0].email ?? "email unknown"})`);
+        }
+        catch (err) {
+            spinner.fail(chalk.red(`Antigravity token check failed: ${err.message}`));
+            process.exit(1);
+        }
+    }
+    else {
+        const spinner = ora(`Checking if ${options.cli} is installed...`).start();
+        try {
+            execSync(`which ${options.cli}`, { stdio: "pipe" });
+            spinner.succeed(`${options.cli} is available`);
+        }
+        catch {
+            spinner.fail(chalk.red(`${options.cli} is not installed or not in PATH`));
+            console.log(chalk.dim(`  Make sure ${options.cli} CLI is installed and accessible.`));
+            process.exit(1);
+        }
     }
-    catch {
-        spinner.fail(chalk.red(`${options.cli} is not installed or not in PATH`));
-        console.log(chalk.dim(`  Make sure ${options.cli} CLI is installed and accessible.`));
+    // Auto-populate prices from the LiteLLM-sourced pricing table. Providers
+    // register at the FULL official API price; the Hub applies RELAY_DISCOUNT
+    // at charge time so buyers pay a fixed fraction across all platforms.
+    const known = API_PRICES[options.model];
+    if (!known && (options.priceInput == null || options.priceOutput == null)) {
+        console.error(chalk.red(`Unknown model "${options.model}". Pricing table has no entry.`));
+        console.log(chalk.dim(`  Either add it to clawmoney-cli/src/relay/pricing.ts, or pass both ` +
+            `--price-input and --price-output explicitly.`));
         process.exit(1);
     }
+    const priceInput = options.priceInput != null
+        ? parseFloat(options.priceInput)
+        : known.input;
+    const priceOutput = options.priceOutput != null
+        ? parseFloat(options.priceOutput)
+        : known.output;
     const regSpinner = ora("Registering as relay provider...").start();
     try {
         const body = {
@@ -34,8 +71,8 @@ export async function relayRegisterCommand(options) {
             mode: options.mode ?? "chat",
             concurrency: parseInt(options.concurrency ?? "5", 10),
             daily_limit_usd: parseFloat(options.dailyLimit ?? "20"),
-            price_input_per_m: parseFloat(options.priceInput ?? "5"),
-            price_output_per_m: parseFloat(options.priceOutput ?? "25"),
+            price_input_per_m: priceInput,
+            price_output_per_m: priceOutput,
         };
         const resp = await apiPost("/api/v1/relay/providers", body, config.api_key);
         if (!resp.ok) {
@@ -55,8 +92,10 @@ export async function relayRegisterCommand(options) {
         console.log(`  ${chalk.bold("Mode:")}          ${options.mode ?? "chat"}`);
         console.log(`  ${chalk.bold("Concurrency:")}   ${body.concurrency}`);
         console.log(`  ${chalk.bold("Daily Limit:")}   $${body.daily_limit_usd}`);
-        console.log(`  ${chalk.bold("Input Price:")}   $${body.price_input_per_m}/1M tokens`);
-        console.log(`  ${chalk.bold("Output Price:")}  $${body.price_output_per_m}/1M tokens`);
+        console.log(`  ${chalk.bold("Input Price:")}   $${body.price_input_per_m}/1M tokens (official API)`);
+        console.log(`  ${chalk.bold("Output Price:")}  $${body.price_output_per_m}/1M tokens (official API)`);
+        const discountPct = Math.round(RELAY_DISCOUNT * 100);
+        console.log(chalk.dim(`  Buyers pay ${discountPct}% of the official API price — a ${100 - discountPct}% discount applied by the Hub.`));
         console.log("");
         console.log(chalk.dim(`  Next: run "clawmoney relay start" to begin accepting requests.`));
     }

package/dist/index.js

@@ -9,6 +9,7 @@ import { tweetCommand } from './commands/tweet.js';
 import { gigCreateCommand, gigBrowseCommand, gigDetailCommand, gigAcceptCommand, gigDeliverCommand, gigApproveCommand, gigDisputeCommand, } from './commands/gig.js';
 import { hubStartCommand, hubStopCommand, hubStatusCommand, hubSearchCommand, hubCallCommand, hubRegisterCommand, hubSkillsCommand, hubOrderCommand, hubHistoryCommand, } from './commands/hub.js';
 import { relayRegisterCommand, relayStartCommand, relayStopCommand, relayStatusCommand, relayModelsCommand, relayCreditsCommand, } from './commands/relay.js';
+import { antigravityLoginCommand, antigravityStatusCommand, } from './commands/antigravity.js';
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
@@ -389,7 +390,7 @@ const relay = program
 relay
     .command('register')
     .description('Register as a relay provider')
-    .requiredOption('--cli <type>', 'Backend CLI: claude, codex, gemini')
+    .requiredOption('--cli <type>', 'Backend CLI: claude, codex, gemini, antigravity')
     .requiredOption('--model <model>', 'Model to offer (e.g., claude-opus-4-6)')
     .option('--mode <mode>', 'Safety mode: chat, search, code, full', 'chat')
     .option('--concurrency <n>', 'Max concurrent requests', '5')
@@ -408,7 +409,7 @@ relay
 relay
     .command('start')
     .description('Start accepting relay requests')
-    .option('--cli <type>', 'Override CLI type (claude, codex, gemini)')
+    .option('--cli <type>', 'Override CLI type (claude, codex, gemini, antigravity)')
     .action(async (options) => {
     try {
         await relayStartCommand(options);
@@ -466,4 +467,32 @@ relay
         process.exit(1);
     }
 });
+// antigravity (Google Antigravity IDE OAuth — separate quota pool + Claude access)
+const antigravity = program
+    .command('antigravity')
+    .description('Google Antigravity IDE OAuth: link a Google account so the relay daemon can serve Claude + Gemini via the Antigravity quota pool');
+antigravity
+    .command('login')
+    .description('OAuth browser flow to link a Google account')
+    .action(async () => {
+    try {
+        await antigravityLoginCommand();
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+antigravity
+    .command('status')
+    .description('Show linked Antigravity accounts')
+    .action(async () => {
+    try {
+        await antigravityStatusCommand();
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
 program.parse();

package/dist/relay/daemon.js

@@ -5,6 +5,16 @@
  * It runs the relay provider main loop (WS + Executor).
  */
 import { runRelayProvider } from "./provider.js";
+import { relayLogger as logger } from "./logger.js";
+// Process-level safety net: an unhandled promise rejection anywhere in the
+// async reconnect / request path must NOT silently kill the daemon. Log it
+// loudly and keep running — the reconnect loop will self-heal any broken WS.
+process.on("unhandledRejection", (reason) => {
+    logger.error("Unhandled promise rejection (daemon continues running):", reason instanceof Error ? reason.stack ?? reason.message : reason);
+});
+process.on("uncaughtException", (err) => {
+    logger.error("Uncaught exception (daemon continues running):", err.stack ?? err.message);
+});
 // Parse CLI args passed from the parent
 let cliType;
 const args = process.argv.slice(2);

package/dist/relay/pricing.d.ts

@@ -1,16 +1,26 @@
 /**
  * API pricing per million tokens (USD).
- * Source: Official pricing pages (April 2026)
- * - Anthropic: https://platform.claude.com/docs/en/docs/about-claude/pricing
- * - OpenAI: https://developers.openai.com/api/docs/pricing
- * - Google: https://ai.google.dev/gemini-api/docs/pricing
+ *
+ * Source: cross-referenced against the LiteLLM community pricing database
+ * (`backend/resources/model-pricing/model_prices_and_context_window.json`
+ * inside sub2api at commit ~April 2026). LiteLLM is the most actively
+ * maintained open pricing source for AI models and stays in sync with
+ * Anthropic / OpenAI / Google public pricing pages.
+ *
+ * When a model appears in a CLI's supported list but is absent from LiteLLM
+ * (typically pre-release or deprecated models), we either fall back to the
+ * closest known variant (documented in `resolveFallback()`) or keep the
+ * last manually-verified number and mark it with a comment.
+ *
+ * If you update these values, also update the LiteLLM reference timestamp
+ * in the header above so future ops know when the last sync happened.
  */
 export interface ModelPricing {
     input: number;
     output: number;
 }
 export declare const API_PRICES: Record<string, ModelPricing>;
-export declare const RELAY_DISCOUNT = 0.3;
+export declare const RELAY_DISCOUNT = 0.2;
 export declare const PLATFORM_FEE = 0.05;
 export declare function getModelPricing(model: string): ModelPricing;
 export interface CostBreakdown {

package/dist/relay/pricing.js

@@ -1,37 +1,109 @@
 /**
  * API pricing per million tokens (USD).
- * Source: Official pricing pages (April 2026)
- * - Anthropic: https://platform.claude.com/docs/en/docs/about-claude/pricing
- * - OpenAI: https://developers.openai.com/api/docs/pricing
- * - Google: https://ai.google.dev/gemini-api/docs/pricing
+ *
+ * Source: cross-referenced against the LiteLLM community pricing database
+ * (`backend/resources/model-pricing/model_prices_and_context_window.json`
+ * inside sub2api at commit ~April 2026). LiteLLM is the most actively
+ * maintained open pricing source for AI models and stays in sync with
+ * Anthropic / OpenAI / Google public pricing pages.
+ *
+ * When a model appears in a CLI's supported list but is absent from LiteLLM
+ * (typically pre-release or deprecated models), we either fall back to the
+ * closest known variant (documented in `resolveFallback()`) or keep the
+ * last manually-verified number and mark it with a comment.
+ *
+ * If you update these values, also update the LiteLLM reference timestamp
+ * in the header above so future ops know when the last sync happened.
  */
 export const API_PRICES = {
     // ── Anthropic (Claude) ──
+    // Verified against LiteLLM pricing DB. cache_read = 0.1x input,
+    // cache_write = 1.25x input (Anthropic ephemeral cache).
     "claude-opus-4-6": { input: 5, output: 25 },
     "claude-opus-4-5": { input: 5, output: 25 },
     "claude-sonnet-4-6": { input: 3, output: 15 },
     "claude-sonnet-4-5": { input: 3, output: 15 },
     "claude-haiku-4-5": { input: 1, output: 5 },
-    // ── OpenAI ──
+    // ── OpenAI (ChatGPT Plus / Codex subscriptions) ──
+    // Verified against LiteLLM. Codex CLI may expose any of these depending
+    // on the user's subscription tier and which models ChatGPT enables.
     "gpt-5.4": { input: 2.50, output: 15 },
     "gpt-5.4-mini": { input: 0.75, output: 4.50 },
     "gpt-5.4-nano": { input: 0.20, output: 1.25 },
+    // gpt-5.4-pro is not in LiteLLM as of April 2026. Keeping the manually
+    // verified values from OpenAI's enterprise pricing page.
     "gpt-5.4-pro": { input: 30, output: 180 },
     "gpt-5.3-codex": { input: 1.75, output: 14 },
-    "o3": { input: 5, output: 20 },
-    "o4-mini": { input: 4, output: 16 },
+    // gpt-5.3-codex-spark is not in LiteLLM — sub2api falls back to
+    // gpt-5.1-codex pricing (see pricing_service.go SparkBilling handling).
+    "gpt-5.3-codex-spark": { input: 1.25, output: 10 },
+    "gpt-5.2": { input: 1.75, output: 14 },
+    "gpt-5.2-codex": { input: 1.75, output: 14 },
+    "gpt-5.1": { input: 1.25, output: 10 },
+    "gpt-5.1-codex": { input: 1.25, output: 10 },
+    "gpt-5.1-codex-mini": { input: 0.25, output: 2 },
+    "gpt-5.1-codex-max": { input: 1.25, output: 10 },
+    "gpt-5": { input: 1.25, output: 10 },
+    // Reasoning models (o-series). Previously had incorrect values — LiteLLM
+    // confirms o3 is $2/$8 (not $5/$20) and o4-mini is $1.1/$4.4 (not $4/$16).
+    "o3": { input: 2, output: 8 },
+    "o4-mini": { input: 1.1, output: 4.4 },
+    // ── Google Antigravity (Ultra-bundled IDE quota pool) ──
+    // Antigravity is the only path that exposes Claude to Google-OAuth users.
+    // We price these at the public Anthropic / Google API rates (providers earn
+    // the same per-request as if they were serving via Anthropic/Google direct),
+    // even though their real cost is zero — the quota is a sunk cost of the
+    // Ultra subscription.
+    "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-claude-opus-4-6-thinking": { input: 5, output: 25 },
     // ── Google (Gemini) ──
+    // Verified against LiteLLM pricing DB.
+    "gemini-3.1-pro-preview": { input: 2, output: 12 },
+    "gemini-3-pro-preview": { input: 2, output: 12 },
+    // gemini-3.1-flash-preview is not in LiteLLM — fall back to
+    // gemini-3-flash-preview pricing.
+    "gemini-3.1-flash-preview": { input: 0.50, output: 3 },
+    "gemini-3-flash-preview": { input: 0.50, output: 3 },
     "gemini-2.5-pro": { input: 1.25, output: 10 },
     "gemini-2.5-flash": { input: 0.30, output: 2.50 },
     "gemini-2.5-flash-lite": { input: 0.10, output: 0.40 },
-    "gemini-3-flash-preview": { input: 0.50, output: 3 },
-    "gemini-3.1-pro-preview": { input: 2, output: 12 },
+    "gemini-2.0-flash": { input: 0.10, output: 0.40 },
 };
-// Default fallback for unknown models
+// Default fallback for unknown models. Priced at the Claude Opus rate
+// intentionally — better to over-charge an unknown model than under-charge
+// and lose money. If a Provider sees a real model billed at this rate,
+// they should file a bug to add the model to API_PRICES.
 const DEFAULT_PRICING = { input: 5, output: 25 };
+// ── Relay economics ──────────────────────────────────────────────────────
+//
+// Pricing strategy (April 2026):
+//   1. Buyer pays RELAY_DISCOUNT × API_price  (currently 20% of official
+//      Anthropic / OpenAI / Google API prices — i.e. an 80% discount).
+//   2. ClawMoney platform takes PLATFORM_FEE of what the buyer pays.
+//   3. Provider keeps the rest.
+//
+// Concretely, for a 1M-token Claude Sonnet input+output at default rates:
+//   API price            = 1M × ($3 input + $15 output) = $18
+//   Buyer pays (20%)     = $3.60
+//   Platform fee (5%)    = $0.18
+//   Provider earns       = $3.42
+//
+// Why 20% flat across all platforms:
+//   - The Provider's subscription fee is a sunk cost; their marginal cost
+//     per relayed request is zero (modulo rate-limit guards).
+//   - 80% off the official API is a strong enough discount that most buyers
+//     would rather route through ClawMoney than pay Anthropic/OpenAI/Google
+//     direct.
+//   - Simpler to explain to both sides than a per-platform discount table.
+//
+// If we later see sustained demand-side hesitation or supply-side complaints
+// we can revisit and split into per-cli_type rates.
 // Relay discount: consumers pay this fraction of API price
-export const RELAY_DISCOUNT = 0.30; // 30% of API price
-// Platform fee: this fraction goes to the platform
+export const RELAY_DISCOUNT = 0.20; // 20% of API price (buyer saves 80%)
+// Platform fee: this fraction of what the buyer pays goes to the platform
 export const PLATFORM_FEE = 0.05; // 5%
 export function getModelPricing(model) {
     return API_PRICES[model] ?? DEFAULT_PRICING;

package/dist/relay/provider.js

@@ -7,6 +7,7 @@ import { spawnCli, buildCliArgs, parseCliOutput, ensureEmptyMcpConfig, ensureSan
 import { callClaudeApi, preflightClaudeApi, getRateGuardSnapshot } from "./upstream/claude-api.js";
 import { callCodexApi, preflightCodexApi } from "./upstream/codex-api.js";
 import { callGeminiApi, preflightGeminiApi } from "./upstream/gemini-api.js";
+import { callAntigravityApi, preflightAntigravityApi, } from "./upstream/antigravity-api.js";
 import { calculateCost } from "./pricing.js";
 import { relayLogger as logger } from "./logger.js";
 const CONFIG_DIR = join(homedir(), ".clawmoney");
@@ -108,10 +109,13 @@ async function executeRelayRequest(request, config) {
     const model = request.model ?? config.relay.model;
     const stateful = request.stateful ?? false;
     const cliSessionId = request.cli_session_id ?? undefined;
-    // api mode is supported for claude / codex / gemini; anything else falls
-    // back to spawning the local CLI subprocess.
-    const useApiMode = config.relay.execution_mode === "api" &&
-        (cliType === "claude" || cliType === "codex" || cliType === "gemini");
+    // api mode is supported for claude / codex / gemini / antigravity; anything
+    // else falls back to spawning the local CLI subprocess. Antigravity is
+    // api-only (there is no local CLI to spawn) so execution_mode is ignored
+    // for it and we always route through the direct upstream handler.
+    const useApiMode = (config.relay.execution_mode === "api" &&
+        (cliType === "claude" || cliType === "codex" || cliType === "gemini")) ||
+        cliType === "antigravity";
     // Build prompt from messages
     const prompt = request.messages
         ? messagesToPrompt(request.messages)
@@ -153,6 +157,13 @@ async function executeRelayRequest(request, config) {
                     maxTokens: max_budget_usd ? undefined : 8192,
                 });
             }
+            else if (cliType === "antigravity") {
+                parsed = await callAntigravityApi({
+                    prompt,
+                    model,
+                    maxTokens: max_budget_usd ? undefined : 8192,
+                });
+            }
             else {
                 parsed = await callClaudeApi({
                     prompt,
@@ -235,6 +246,11 @@ export function runRelayProvider(cliOverride) {
     // up-front so we fail fast instead of on the first inbound request. Each
     // cli_type has its own preflight path (different credential file, different
     // fingerprint schema, different rate-guard instance).
+    // Antigravity is always api mode (no CLI to spawn), so force api execution
+    // even if config.yaml says "cli". For the other CLIs, api mode is opt-in.
+    if (config.relay.cli_type === "antigravity") {
+        config.relay.execution_mode = "api";
+    }
     if (config.relay.execution_mode === "api") {
         const preflightFn = config.relay.cli_type === "codex"
             ? preflightCodexApi
@@ -242,7 +258,9 @@ export function runRelayProvider(cliOverride) {
                 ? preflightGeminiApi
                 : config.relay.cli_type === "claude"
                     ? preflightClaudeApi
-                    : null;
+                    : config.relay.cli_type === "antigravity"
+                        ? preflightAntigravityApi
+                        : null;
         if (preflightFn) {
             preflightFn(config.relay.rate_guard).catch((err) => {
                 logger.error(`${config.relay.cli_type} API preflight failed — falling back to CLI mode: ${err.message}`);