autonomo-sdk 0.1.1 → 0.1.3

package/README.md

@@ -73,8 +73,27 @@ asks before paying; `--yes` skips the question, and scripts are never asked. The
 receipt to stderr, so piping into `jq` works, and `--json` prints `{ data, receipt }` as one object. Exit codes: 0
 done, 1 failed, 2 bad usage, 3 over a limit, 4 can't pay, 5 payment refused, 6 no such API.
 
-After `npm install -g autonomo-sdk` the command is `autonomo`. (`npx autonomo` is someone else's package.) Private
-Gloam payments aren't in the command yet; use the SDK for those.
+After `npm install -g autonomo-sdk` the command is `autonomo`. (`npx autonomo` is someone else's package.)
+
+### Paying privately from the terminal
+
+```bash
+npx autonomo-sdk risk 0x86b57bcb9d249cf096cf8e21426c9dc9cafdec49 --private --dry-run   # the private price
+npx autonomo-sdk risk 0x86b57bcb9d249cf096cf8e21426c9dc9cafdec49 --private             # pay from Gloam
+```
+
+`--private` pays from your private Gloam balance, so the payment doesn't link to a wallet. The command starts Gloam's
+own server (`npx -y @gloamtrade/mcp`) on your machine for that one payment and stops it afterwards.
+
+- Set Gloam up once: its key and limits go in `~/.gloam/agent.env` and USDG goes into its private balance (see
+  [Pay privately with Gloam](https://autonomo.fun/docs/sdk#pay-privately-with-gloam)). The command never reads
+  Gloam's key, and Gloam's server is never given `AUTONOMO_WALLET_KEY`.
+- No `AUTONOMO_WALLET_KEY` is needed for private calls.
+- The price includes Gloam's fee and counts against `--max` and `--daily`. It can't be combined with `--pay-with`
+  or `--borro`.
+- Paying can take a few minutes, since Gloam builds the payment's proofs on your machine.
+- If Gloam paid but the API didn't answer, the error prints a payment header: run the same command again with
+  `--retry-header <header>` to get the answer without paying twice.
 
 ## Limits
 
@@ -126,6 +145,11 @@ When the wallet can't afford a call, the SDK asks Borro's MCP server to prepare
 sends it from the wallet (this needs a little ETH for gas), waits for the USDG and pays. The line needs x402 bills
 turned on; see [Pay with a Borro credit line](https://autonomo.fun/docs/borro). Borro's own daily limit still applies.
 
+Borro's answer is checked before anything is signed. The SDK sends only one transaction: a `borrow` on your own credit
+line, into this wallet, with no ETH attached, of no more than the call's price. Anything else in the answer, such as a
+transfer, an approval or a second transaction, is refused with `borro_unsafe` and nothing is sent. The call's price is
+still checked against your caps first.
+
 ## The receipt
 
 | Field | |

package/dist/cli.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { type GloamSession } from "./gloam.js";
 import { type SpendStore } from "./index.js";
 /** Everything the CLI touches outside itself, so tests can swap it. */
 export type Io = {
@@ -10,6 +11,8 @@ export type Io = {
     confirm: (question: string) => Promise<boolean>;
     fetch?: typeof fetch;
     spendStore?: SpendStore;
+    /** Starts Gloam's server for --private. The default runs `npx -y @gloamtrade/mcp`. */
+    startGloam?: () => Promise<GloamSession>;
 };
 export declare const EXIT: {
     readonly ok: 0;

package/dist/cli.js

@@ -4,56 +4,68 @@
 //   npx autonomo-sdk find "wallet holdings"            look, free
 //   npx autonomo-sdk risk 0x… --dry-run                the price, without paying
 //   AUTONOMO_WALLET_KEY=0x… npx autonomo-sdk risk 0x…  pay and print the answer
+//   npx autonomo-sdk risk 0x… --private                pay from a private Gloam balance instead
 //
 // The answer goes to stdout and everything else (the receipt, questions, errors) to stderr, so `autonomo … | jq`
 // works. The wallet key is only ever read from AUTONOMO_WALLET_KEY, never from a flag, so it stays out of shell
-// history. The SDK's per-call cap and daily budget apply to every paid call.
+// history. The SDK's per-call cap and daily budget apply to every paid call. With --private the payment is made by
+// Gloam's own server, started on this machine with its own key and limits (see gloam.ts); no wallet key is needed.
 import { realpathSync } from "node:fs";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 import { formatUnits } from "viem";
+import { startGloam } from "./gloam.js";
 import { Autonomo, AutonomoError, DEFAULT_LIMITS, TOKENS, VERSION, fileStore } from "./index.js";
 export const EXIT = { ok: 0, failed: 1, usage: 2, overLimit: 3, cannotPay: 4, refused: 5, notFound: 6 };
-const HELP = `Autonomo CLI ${VERSION}: find and pay for APIs on autonomo.fun
-
-Usage
-  autonomo find [words] [input]     List APIs, best matches first. Free.
-  autonomo quote <words> [input]    The API a call would use and its prices. Free.
-  autonomo call <words> [input]     Find the right API, pay for one call, print the answer.
-  autonomo spend                    Today's spending against your limits.
-
-Shortcuts for the official APIs
-  autonomo price [token address]    $AUTONOMO's price, or any launchpad token's
-  autonomo launches [how many]      Newest token launches
-  autonomo risk <token address>     Rug-risk check
-  autonomo tx <transaction hash>    A transaction in plain words
-  autonomo portfolio <wallet>       What a wallet holds
-  autonomo read <https link>        A web page's text
-  autonomo offers <what you need>   Matching offers on Ostrapad
-
-Options
-  --max <usdg>              Most to pay for one call (default ${DEFAULT_LIMITS.perCall.usdg})
-  --daily <usdg>            Most to spend per UTC day (default ${DEFAULT_LIMITS.daily.usdg})
-  --max-autonomo <amount>   The same two limits when paying in $AUTONOMO
-  --daily-autonomo <amount> (defaults ${DEFAULT_LIMITS.perCall.autonomo} and ${DEFAULT_LIMITS.daily.autonomo})
-  --pay-with <token>        usdg, autonomo or auto (default: USDG, then $AUTONOMO)
-  --borro <credit line>     Borrow from this Borro line when the wallet is short of USDG
-  --slug <api> --path <p>   With call or quote: use this API and path, skipping the search
-  --dry-run                 Show the price instead of paying
-  --yes                     Don't ask before paying
-  --json                    One JSON object on stdout: { data, receipt }
-  --help, --version
-
-Wallet
-  Set AUTONOMO_WALLET_KEY to the private key of a wallet made just for the agent, holding only what it may spend.
-  find, quote, spend and --dry-run need no wallet.
-
-Exit codes
+const HELP = `Autonomo CLI ${VERSION}: find and pay for APIs on autonomo.fun
+
+Usage
+  autonomo find [words] [input]     List APIs, best matches first. Free.
+  autonomo quote <words> [input]    The API a call would use and its prices. Free.
+  autonomo call <words> [input]     Find the right API, pay for one call, print the answer.
+  autonomo spend                    Today's spending against your limits.
+
+Shortcuts for the official APIs
+  autonomo price [token address]    $AUTONOMO's price, or any launchpad token's
+  autonomo launches [how many]      Newest token launches
+  autonomo risk <token address>     Rug-risk check
+  autonomo tx <transaction hash>    A transaction in plain words
+  autonomo portfolio <wallet>       What a wallet holds
+  autonomo read <https link>        A web page's text
+  autonomo offers <what you need>   Matching offers on Ostrapad
+
+Options
+  --max <usdg>              Most to pay for one call (default ${DEFAULT_LIMITS.perCall.usdg})
+  --daily <usdg>            Most to spend per UTC day (default ${DEFAULT_LIMITS.daily.usdg})
+  --max-autonomo <amount>   The same two limits when paying in $AUTONOMO
+  --daily-autonomo <amount> (defaults ${DEFAULT_LIMITS.perCall.autonomo} and ${DEFAULT_LIMITS.daily.autonomo})
+  --pay-with <token>        usdg, autonomo or auto (default: USDG, then $AUTONOMO)
+  --borro <credit line>     Borrow from this Borro line when the wallet is short of USDG
+  --private                 Pay from your private Gloam balance, so the payment doesn't link to a wallet
+  --retry-header <header>   With --private: finish a call Gloam paid for but the API didn't answer, without paying again
+  --slug <api> --path <p>   With call or quote: use this API and path, skipping the search
+  --dry-run                 Show the price instead of paying
+  --yes                     Don't ask before paying
+  --json                    One JSON object on stdout: { data, receipt }
+  --help, --version
+
+Wallet
+  Set AUTONOMO_WALLET_KEY to the private key of a wallet made just for the agent, holding only what it may spend.
+  find, quote, spend and --dry-run need no wallet.
+
+Private payments
+  --private starts Gloam's own server on this machine (npx @gloamtrade/mcp) and has it pay in USDG. It needs no
+  AUTONOMO_WALLET_KEY: Gloam uses its own key and limits from ~/.gloam/agent.env, and that key is never read by
+  this command. Deposit USDG into Gloam's private balance first. The price includes Gloam's fee, counts against
+  --max and --daily, and paying can take a few minutes. Setup: autonomo.fun/docs/sdk#pay-privately-with-gloam
+
+Exit codes
   0 done   1 failed   2 bad usage   3 over a limit   4 can't pay   5 payment refused   6 no such API`;
 const ADDRESS = /^0x[0-9a-fA-F]{40}$/;
 const TX_HASH = /^0x[0-9a-fA-F]{64}$/;
 const AMOUNT = /^\d+(\.\d+)?$/;
+const GLOAM_SETUP = "Gloam needs its own key and limits in ~/.gloam/agent.env: autonomo.fun/docs/sdk#pay-privately-with-gloam";
 class UsageError extends Error {
 }
 const usage = (message) => {
@@ -114,7 +126,7 @@ function exitFor(e) {
     // cannot_pay covers both a limit and an empty wallet; the limit ones say "cap" or "budget".
     if (e.code === "cannot_pay")
         return /per-call cap|budget/.test(e.message) && !/the wallet holds/.test(e.message) ? EXIT.overLimit : EXIT.cannotPay;
-    if (e.code === "no_wallet" || e.code === "bad_key")
+    if (e.code === "no_wallet" || e.code === "bad_key" || e.code === "no_gloam" || e.code === "no_private_option")
         return EXIT.cannotPay;
     if (e.code === "payment_refused" || e.code === "paid_not_served")
         return EXIT.refused;
@@ -136,6 +148,8 @@ export async function run(argv, io) {
                 "daily-autonomo": { type: "string" },
                 "pay-with": { type: "string" },
                 borro: { type: "string" },
+                private: { type: "boolean" },
+                "retry-header": { type: "string" },
                 slug: { type: "string" },
                 path: { type: "string" },
                 "dry-run": { type: "boolean" },
@@ -172,6 +186,14 @@ export async function run(argv, io) {
         const borro = values.borro ?? io.env.AUTONOMO_BORRO_ACCOUNT;
         if (borro !== undefined && !ADDRESS.test(borro))
             usage("--borro takes the credit line's address.");
+        const retryHeader = values["retry-header"];
+        if (values.private && (values["pay-with"] !== undefined || values.borro !== undefined)) {
+            usage("--private pays in USDG from your Gloam balance, so it can't be combined with --pay-with or --borro.");
+        }
+        if (retryHeader !== undefined && !values.private)
+            usage("--retry-header goes with --private: it finishes a call Gloam already paid for.");
+        if (retryHeader !== undefined && !retryHeader.trim())
+            usage("--retry-header takes the paymentHeader from the earlier result.");
         const store = io.spendStore ?? fileStore();
         const client = (withWallet) => new Autonomo({
             privateKey: withWallet ? io.env.AUTONOMO_WALLET_KEY || undefined : undefined,
@@ -251,6 +273,69 @@ export async function run(argv, io) {
                 io.out(`  ${o.amount} ${o.token}${o.private ? "  private, through Gloam" : ""}`);
             return EXIT.ok;
         }
+        if (values.private) {
+            // Gloam's server is only started once a payment is really going to be made, and always stopped afterwards.
+            let session;
+            const gloam = async (notice) => {
+                if (session)
+                    return session;
+                if (!json)
+                    io.err(notice);
+                try {
+                    return (session = await (io.startGloam ?? (() => startGloam(io.env, undefined, VERSION)))());
+                }
+                catch (e) {
+                    throw new AutonomoError(`${e instanceof Error ? e.message : String(e)} ${GLOAM_SETUP}`, "no_gloam");
+                }
+            };
+            try {
+                const autonomo = new Autonomo({
+                    limits,
+                    spendStore: store,
+                    fetch: io.fetch,
+                    gloam: { fetchPaid: async (args) => (await gloam("Paying privately through Gloam. This can take a few minutes…")).fetchPaid(args) },
+                });
+                if (retryHeader !== undefined) {
+                    const q = await autonomo.quote(words, opts);
+                    const r = await (await gloam("Asking Gloam to present the earlier payment…")).fetchPaid({ url: q.url, paymentHeader: retryHeader.trim(), prefer: "gloam-cashout" });
+                    if (r.status !== "ok") {
+                        throw new AutonomoError(`Not answered yet: ${r.message ?? r.error ?? r.code ?? r.status}. Nothing more was paid; try again with the same --retry-header.`, "paid_not_served");
+                    }
+                    let data = r.body ?? "";
+                    try {
+                        data = JSON.parse(String(data));
+                    }
+                    catch {
+                        // Plain text is fine.
+                    }
+                    if (json)
+                        return print({ data, receipt: null }), EXIT.ok;
+                    print(data);
+                    io.err(`Answered by ${q.api.name} with the earlier payment. Nothing more was paid.`);
+                    return EXIT.ok;
+                }
+                if (io.interactive && !values.yes) {
+                    const q = await autonomo.quote(words, opts);
+                    const offer = q.offers.find((o) => o.private);
+                    if (!offer)
+                        throw new AutonomoError(`${q.api.name} doesn't offer private payment.`, "no_private_option");
+                    const question = `${q.api.name} costs ${offer.amount} ${offer.token} privately through Gloam, its fee included. Pay from your Gloam balance? [y/N] `;
+                    if (!(await io.confirm(question)))
+                        return io.err("Not paid."), EXIT.ok;
+                }
+                const { data, receipt } = await autonomo.call(words, { ...opts, private: true });
+                if (json)
+                    return print({ data, receipt }), EXIT.ok;
+                print(data);
+                io.err(`Paid ${receipt.amount} ${receipt.token} privately through Gloam to ${receipt.api.name}. Today: ${receipt.spentToday}.`);
+                if (receipt.explorer)
+                    io.err(receipt.explorer);
+                return EXIT.ok;
+            }
+            finally {
+                await session?.close().catch(() => { });
+            }
+        }
         const autonomo = client(true);
         if (!autonomo.address) {
             throw new AutonomoError("No wallet set. Put the agent wallet's private key in AUTONOMO_WALLET_KEY, or add --dry-run to see the price.", "no_wallet");

package/dist/gloam.d.ts

@@ -0,0 +1,23 @@
+import type { GloamFetchPaid, GloamResult } from "./index.js";
+/** A running Gloam server. */
+export type GloamSession = {
+    /** Pays for one request from the private balance, or presents a payment made earlier (`paymentHeader`). */
+    fetchPaid: (args: Parameters<GloamFetchPaid>[0] | {
+        url: string;
+        paymentHeader: string;
+        prefer: "gloam-cashout";
+    }) => Promise<GloamResult>;
+    close: () => Promise<void>;
+};
+export type GloamServer = {
+    command: string;
+    args: string[];
+};
+/** `npx -y @gloamtrade/mcp`. On Windows npx is a script, so it's started through cmd. */
+export declare const defaultGloamServer: () => GloamServer;
+/** What Gloam's server is started with: everything it may need, but never Autonomo's own wallet key or settings. */
+export declare function gloamEnv(env: Record<string, string | undefined>): Record<string, string>;
+export declare function startGloam(env: Record<string, string | undefined>, server?: GloamServer, version?: string, timeouts?: {
+    start: number;
+    pay: number;
+}): Promise<GloamSession>;

package/dist/gloam.js

@@ -0,0 +1,118 @@
+// Gloam for the CLI's --private: starts Gloam's own MCP server on this machine and calls its paid-fetch tool.
+//
+// The Gloam key never comes near Autonomo's code. Gloam's server reads it, with its own spending limits, from
+// ~/.gloam/agent.env (see autonomo.fun/docs/sdk#pay-privately-with-gloam). This file only speaks the MCP stdio
+// protocol to that server: one JSON-RPC message per line. It is written out here instead of using an MCP client
+// library so `npx autonomo-sdk` stays a small download.
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+/** `npx -y @gloamtrade/mcp`. On Windows npx is a script, so it's started through cmd. */
+export const defaultGloamServer = () => process.platform === "win32" ? { command: "cmd", args: ["/c", "npx", "-y", "@gloamtrade/mcp"] } : { command: "npx", args: ["-y", "@gloamtrade/mcp"] };
+// The first run downloads Gloam's server, and a private payment builds its proofs on this machine.
+const START_MS = 120_000;
+const PAY_MS = 300_000;
+/** What Gloam's server is started with: everything it may need, but never Autonomo's own wallet key or settings. */
+export function gloamEnv(env) {
+    return Object.fromEntries(Object.entries(env).filter((e) => e[1] !== undefined && !/^AUTONOMO_/i.test(e[0])));
+}
+export async function startGloam(env, server = defaultGloamServer(), version = "0", timeouts = { start: START_MS, pay: PAY_MS }) {
+    let child;
+    try {
+        child = spawn(server.command, server.args, { env: gloamEnv(env), stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+    }
+    catch (e) {
+        throw new Error(`Gloam's server couldn't be started: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // The tail of what the server printed, for when it stops before answering.
+    let tail = "";
+    child.stderr?.on("data", (chunk) => {
+        tail = (tail + chunk.toString("utf8")).slice(-400);
+    });
+    let nextId = 1;
+    let stopped = null;
+    const waiting = new Map();
+    const stop = (why) => {
+        stopped ??= why;
+        for (const w of waiting.values())
+            w.reject(new Error(stopped));
+        waiting.clear();
+    };
+    child.on("error", (e) => stop(`Gloam's server couldn't be started: ${e.message}`));
+    child.on("exit", (code) => stop(`Gloam's server stopped${code === null ? "" : ` (exit ${code})`}${tail.trim() ? `: ${tail.trim().split(/\r?\n/).at(-1)}` : "."}`));
+    // A write to a server that has gone must not crash the CLI: the exit handler reports it.
+    child.stdin?.on("error", () => { });
+    const send = (message) => child.stdin?.write(`${JSON.stringify(message)}\n`);
+    createInterface({ input: child.stdout }).on("line", (line) => {
+        let m;
+        try {
+            m = JSON.parse(line);
+        }
+        catch {
+            return; // Not protocol: a stray log line.
+        }
+        if (m.method !== undefined) {
+            // A request from the server: answer pings, decline anything else. Notifications need no answer.
+            if (m.id !== undefined)
+                send(m.method === "ping" ? { jsonrpc: "2.0", id: m.id, result: {} } : { jsonrpc: "2.0", id: m.id, error: { code: -32601, message: "Not supported" } });
+            return;
+        }
+        const w = m.id !== undefined ? waiting.get(m.id) : undefined;
+        if (!w)
+            return;
+        waiting.delete(m.id);
+        if (m.error)
+            w.reject(new Error(`Gloam: ${m.error.message ?? "request failed"}`));
+        else
+            w.resolve(m.result);
+    });
+    const request = (method, params, ms, what) => new Promise((resolve, reject) => {
+        if (stopped)
+            return reject(new Error(stopped));
+        const id = nextId++;
+        const timer = setTimeout(() => {
+            waiting.delete(id);
+            reject(new Error(`${what} took over ${Math.round(ms / 1000)} seconds.`));
+        }, ms);
+        waiting.set(id, {
+            resolve: (v) => (clearTimeout(timer), resolve(v)),
+            reject: (e) => (clearTimeout(timer), reject(e)),
+        });
+        send({ jsonrpc: "2.0", id, method, params });
+    });
+    const close = async () => {
+        if (child.exitCode !== null || child.signalCode !== null)
+            return;
+        const gone = new Promise((resolve) => child.once("exit", () => resolve()));
+        child.stdin?.end(); // An MCP server exits when its input closes.
+        const waited = await Promise.race([gone.then(() => true), new Promise((r) => setTimeout(() => r(false), 3000).unref())]);
+        if (waited)
+            return;
+        // Still there: stop it, and on Windows everything cmd started with it.
+        if (process.platform === "win32" && child.pid)
+            spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true }).on("error", () => { });
+        else
+            child.kill();
+    };
+    try {
+        await request("initialize", { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: "autonomo-cli", version } }, timeouts.start, "Starting Gloam's server");
+        send({ jsonrpc: "2.0", method: "notifications/initialized" });
+    }
+    catch (e) {
+        await close();
+        throw e;
+    }
+    return {
+        close,
+        fetchPaid: async (args) => {
+            const out = await request("tools/call", { name: "gloam_fetch_paid", arguments: args }, timeouts.pay, "The private payment");
+            const text = out.content?.find((c) => typeof c.text === "string")?.text ?? "";
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                // Gloam answers errors, such as a missing key or an empty balance, in plain words.
+                return { status: "error", message: text.slice(0, 500) || "Gloam gave no answer." };
+            }
+        },
+    };
+}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { type Hex } from "viem";
-export declare const VERSION = "0.1.1";
+export declare const VERSION = "0.1.3";
 export type TokenName = "usdg" | "autonomo";
 type Token = {
     name: TokenName;
@@ -242,6 +242,25 @@ export declare function permit2TypedData(auth: {
         };
     };
 };
+/**
+ * The one transaction an honest Borro `credit_bill` answer holds: "one unsigned borrow of just what it is short, from the
+ * line to the wallet itself". Anything else is refused before it is signed: another target, ETH value, another function,
+ * another recipient, more than the call's price, or more than one transaction. A borrow's USDG lands in the agent's own
+ * wallet, so the caps on the call still bound what can be spent.
+ */
+export declare function checkBorrow(txs: Array<{
+    to: string;
+    data: string;
+    value?: string;
+}>, opts: {
+    line: string;
+    wallet: string;
+    most: bigint;
+}): {
+    to: Hex;
+    data: Hex;
+    amount: bigint;
+};
 /** Every transaction ({ to, data }) inside a tool result, in order. */
 export declare function findTransactions(value: unknown): Array<{
     to: string;

package/dist/index.js

@@ -13,9 +13,9 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { createPublicClient, createWalletClient, defineChain, erc20Abi, formatUnits, getAddress, http, maxUint256, parseUnits, toHex, } from "viem";
+import { createPublicClient, createWalletClient, defineChain, erc20Abi, formatEther, formatUnits, getAddress, http, maxUint256, parseUnits, toHex, } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
-export const VERSION = "0.1.1";
+export const VERSION = "0.1.3";
 const NETWORK = "eip155:4663";
 const CHAIN_ID = 4663;
 const EXPLORER = "https://robinhoodchain.blockscout.com";
@@ -451,24 +451,22 @@ export class Autonomo {
             payment_required: raw,
             max_usdg: formatUnits(this.perCall.usdg, 6),
         });
-        const txs = findTransactions(result);
-        const wallet = createWalletClient({ account, chain: this.chain, transport: http(this.rpc) });
-        const hashes = [];
-        for (const t of txs) {
-            const hash = await wallet.sendTransaction({ to: getAddress(t.to), data: t.data, value: t.value ? BigInt(t.value) : 0n });
-            const r = await pub.waitForTransactionReceipt({ hash });
-            if (r.status !== "success")
-                fail("borrow_failed", `Borro's borrow transaction failed: ${EXPLORER}/tx/${hash}`);
-            hashes.push(hash);
-        }
         const need = BigInt(offer.amount);
+        // Borro's answer is checked before anything is signed: it may only borrow, on this line, into this wallet, at most the price.
+        const tx = checkBorrow(findTransactions(result), { line: borro.account, wallet: account.address, most: need });
+        const wallet = createWalletClient({ account, chain: this.chain, transport: http(this.rpc) });
+        const hash = await wallet.sendTransaction({ to: tx.to, data: tx.data, value: 0n });
+        const link = `${EXPLORER}/tx/${hash}`;
+        const r = await pub.waitForTransactionReceipt({ hash });
+        if (r.status !== "success")
+            fail("borrow_failed", `The borrow on your Borro line failed, so nothing was borrowed and the API isn't paid: ${link}`);
         for (let i = 0; i < 20; i++) {
             const bal = await pub.readContract({ address: TOKENS.usdg.address, abi: erc20Abi, functionName: "balanceOf", args: [account.address] });
             if (bal >= need)
-                return hashes;
+                return [hash];
             await sleep(1000);
         }
-        return fail("borrow_failed", "The borrowed USDG hasn't reached the wallet yet. Nothing was paid; try again shortly.");
+        return fail("borrow_failed", `Borrowed ${formatUnits(tx.amount, 6)} USDG on your Borro line (${link}), but it hasn't reached the wallet yet. The API isn't paid; try again shortly.`);
     }
 }
 // ---------- Helpers ----------
@@ -561,6 +559,50 @@ async function mcpCall(f, url, name, args) {
         return out;
     }
 }
+/** borrow(uint256 amount, address to) on a Borro credit line. */
+const BORROW_SELECTOR = "0x4b3fd148";
+/**
+ * The one transaction an honest Borro `credit_bill` answer holds: "one unsigned borrow of just what it is short, from the
+ * line to the wallet itself". Anything else is refused before it is signed: another target, ETH value, another function,
+ * another recipient, more than the call's price, or more than one transaction. A borrow's USDG lands in the agent's own
+ * wallet, so the caps on the call still bound what can be spent.
+ */
+export function checkBorrow(txs, opts) {
+    const refuse = (why) => fail("borro_unsafe", `Borro's answer wasn't a plain borrow from your line into this wallet (${why}), so nothing was signed or sent.`);
+    if (txs.length === 0)
+        refuse("it held no borrow transaction");
+    if (txs.length > 1)
+        refuse(`it held ${txs.length} transactions, and a borrow is one`);
+    const [t] = txs;
+    if (!sameAddr(t.to, opts.line))
+        refuse(`it goes to ${t.to}, not your credit line ${opts.line}`);
+    let value;
+    try {
+        value = t.value === undefined || t.value === "" ? 0n : BigInt(t.value);
+    }
+    catch {
+        return refuse(`its value "${t.value}" isn't a number`);
+    }
+    if (value !== 0n)
+        refuse(`it sends ${formatEther(value)} ETH`);
+    const data = t.data.toLowerCase();
+    if (!data.startsWith(BORROW_SELECTOR))
+        refuse(`it calls ${data.slice(0, 10)}, not borrow`);
+    if (data.length !== 10 + 128)
+        refuse("its borrow arguments aren't an amount and a recipient");
+    const amount = BigInt(`0x${data.slice(10, 74)}`);
+    const word = data.slice(74);
+    if (!/^0{24}/.test(word))
+        refuse("its recipient isn't an address");
+    const to = `0x${word.slice(24)}`;
+    if (!sameAddr(to, opts.wallet))
+        refuse(`it borrows into ${getAddress(to)}, not this wallet`);
+    if (amount === 0n)
+        refuse("it borrows nothing");
+    if (amount > opts.most)
+        refuse(`it borrows ${formatUnits(amount, 6)} USDG, more than the call's ${formatUnits(opts.most, 6)}`);
+    return { to: getAddress(t.to), data: data, amount };
+}
 /** Every transaction ({ to, data }) inside a tool result, in order. */
 export function findTransactions(value) {
     const out = [];

package/package.json

@@ -1,50 +1,50 @@
-{
-  "name": "autonomo-sdk",
-  "version": "0.1.1",
-  "description": "One call for AI agents: find the right paid API on Autonomo, pay in USDG or $AUTONOMO (privately through Gloam, or on Borro credit), within spending caps, and get a receipt.",
-  "homepage": "https://autonomo.fun",
-  "author": "Autonomo (https://autonomo.fun)",
-  "license": "MIT",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "build": "tsc -p .",
-    "test": "node --test test/*.test.mjs"
-  },
-  "keywords": [
-    "x402",
-    "autonomo",
-    "ai-agents",
-    "robinhood-chain",
-    "usdg",
-    "payments",
-    "gloam",
-    "borro"
-  ],
-  "dependencies": {
-    "viem": "2.57.12"
-  },
-  "devDependencies": {
-    "@modelcontextprotocol/sdk": "^1.32.1",
-    "@types/node": "26.6.5",
-    "typescript": "7.0.2"
-  },
-  "bin": {
-    "autonomo": "dist/cli.js"
-  }
-}
+{
+  "name": "autonomo-sdk",
+  "version": "0.1.3",
+  "description": "One call for AI agents: find the right paid API on Autonomo, pay in USDG or $AUTONOMO (privately through Gloam, or on Borro credit), within spending caps, and get a receipt.",
+  "homepage": "https://autonomo.fun",
+  "author": "Autonomo (https://autonomo.fun)",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p .",
+    "test": "node --test test/*.test.mjs"
+  },
+  "keywords": [
+    "x402",
+    "autonomo",
+    "ai-agents",
+    "robinhood-chain",
+    "usdg",
+    "payments",
+    "gloam",
+    "borro"
+  ],
+  "dependencies": {
+    "viem": "2.57.12"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "@types/node": "26.6.5",
+    "typescript": "7.0.2"
+  },
+  "bin": {
+    "autonomo": "dist/cli.js"
+  }
+}