gage-mcp 0.5.1 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.6.0
+
+- **Mainnet is the default.** Without `GAGE_NETWORK` the server and `init` serve Robinhood Chain (4663);
+  `GAGE_NETWORK=testnet` serves the testnet, and `init` there prints the commands that name it. Breaking: a setup that
+  relied on the testnet default must set `GAGE_NETWORK=testnet`.
+- **The owner may lift a spend limit with `off`**, one setting at a time: `GAGE_MAX_BORROW_USDG=off` and the rest. The
+  mainnet defaults (100 USDG an action, 250 in 24 hours) stay where nothing is set.
+- Built on exactly gage-sdk 0.6.0.
+
 ## 0.5.1
 
 - Built on exactly gage-sdk 0.5.1: a loan the private lane opened stays out of `gage_loan`, `gage_portfolio` and

package/README.md

@@ -2,16 +2,17 @@
 
 gage's MCP server for an AI agent that holds its own money: it borrows and earns on [gage](https://gage.cash),
 fixed-cost loans with no liquidation (a loan is never closed early because a price moves; unpaid at the end of its term,
-the lenders keep the collateral and nothing else is taken). **Robinhood Chain testnet (46630)**, and Robinhood Chain
-(4663) under spend limits (see Mainnet).
+the lenders keep the collateral and nothing else is taken). **Robinhood Chain (4663)**, under spend limits you may
+lift, and its testnet (46630, see Testnet).
 
 ```bash
 npx -y gage-mcp init
 ```
 
-`init` makes the agent's own wallet on this computer: its key in `~/.gage/agent-46630.key`, readable only by this user,
-made once and never overwritten. On the testnet it funds it from gage's faucet. It prints the address and how to add
-the server, never the key. Then add the server to the agent:
+`init` makes the agent's own wallet on this computer: its key in `~/.gage/agent-4663.key`, readable only by this user,
+made once and never overwritten. It prints the address, its spend limits and how to add the server, never the key.
+Nobody funds it but you: send it only what the agent may use, and a little ETH for gas. Then add the server to the
+agent:
 
 ```bash
 claude mcp add gage -- npx -y gage-mcp     # Claude Code
@@ -24,8 +25,8 @@ Any client with an `mcpServers` file (Claude Desktop, Cursor, Hermes, …):
 { "mcpServers": { "gage": { "command": "npx", "args": ["-y", "gage-mcp"] } } }
 ```
 
-With the wallet `init` made, the server has 24 tools on the testnet, and 33 on mainnet under spend limits (rolling
-over, `gage_limits` and the rating, see Mainnet):
+With the wallet `init` made, the server has 33 tools on mainnet (`gage_limits`, rolling over and the rating among
+them), and 24 on the testnet:
 - seven reads (`gage_capabilities`, `gage_assets`, `gage_borrow_quote`, `gage_leverage_quote`, `gage_loan`,
   `gage_portfolio`, `gage_earn_vaults`) and `gage_wallet`;
 - a preview that sends nothing for each action (`gage_prepare_*`);
@@ -56,29 +57,27 @@ borrow, and on Earn the asset each vault takes. Leverage stays USDG's.
 Without a key it keeps the reads and the previews: the agent prepares, and you sign elsewhere. For a person who signs
 every step on gage.cash, the hosted server is the one to use (Steward, /agents/steward on gage.cash).
 
-## Mainnet
+## Testnet
 
-`GAGE_NETWORK=mainnet` serves Robinhood Chain with gage.cash's own services. Without a key it reads and previews,
-for your own wallet to sign. With one it signs under spend limits:
+`GAGE_NETWORK=testnet` serves Robinhood Chain testnet, with test assets only:
 
 ```bash
-GAGE_NETWORK=mainnet npx -y gage-mcp init
+GAGE_NETWORK=testnet npx -y gage-mcp init
 ```
 
-makes the agent's mainnet wallet (`~/.gage/agent-4663.key`, apart from the testnet's) and prints its address, never
-its key. Nobody funds it but you: send it only what the agent may use, and a little ETH for gas. Then add the server,
-told its network:
+makes the agent's testnet wallet (`~/.gage/agent-46630.key`, apart from the mainnet one) and funds it from gage's
+faucet. Then add the server, told its network:
 
 ```bash
-claude mcp add gage -e GAGE_NETWORK=mainnet -- npx -y gage-mcp     # Claude Code
-codex mcp add gage --env GAGE_NETWORK=mainnet -- npx -y gage-mcp    # Codex
+claude mcp add gage -e GAGE_NETWORK=testnet -- npx -y gage-mcp     # Claude Code
+codex mcp add gage --env GAGE_NETWORK=testnet -- npx -y gage-mcp    # Codex
 ```
 
 ```json
-{ "mcpServers": { "gage": { "command": "npx", "args": ["-y", "gage-mcp"], "env": { "GAGE_NETWORK": "mainnet" } } } }
+{ "mcpServers": { "gage": { "command": "npx", "args": ["-y", "gage-mcp"], "env": { "GAGE_NETWORK": "testnet" } } } }
 ```
 
-### Spend limits
+## Spend limits
 
 | Setting | On mainnet unless set | |
 |---|---|---|
@@ -87,8 +86,9 @@ codex mcp add gage --env GAGE_NETWORK=mainnet -- npx -y gage-mcp    # Codex
 | `GAGE_MAX_DEPOSIT_USDG` | 100 | the most one deposit puts into a partner vault |
 | `GAGE_MAX_DEPOSIT_DAY_USDG` | 250 | the most deposits put in in any 24 hours |
 
-Amounts of USDG, whole or with up to six decimals; 0 stops that kind of action, and a setting that is not an amount
-stops the server from starting. On the testnet only the limits you set apply. Repaying, cashing out, withdrawing,
+Amounts of USDG, whole or with up to six decimals; 0 stops that kind of action, `off` lifts that limit, and any other
+setting stops the server from starting. Whether the agent signs under limits is your choice: with all four `off` it
+signs without any. On the testnet only the limits you set apply. Repaying, cashing out, withdrawing,
 cancelling and collecting are not limited: they bring money or collateral back to the wallet. A roll counts only what
 it borrows beyond the loan it repays, and the server rolls at the same size, so nothing; leaving a loan to roll by
 itself, or ending that, moves nothing. Nor are actions in an asset other than USDG limited, nor a rating of gage, which
@@ -110,7 +110,7 @@ An agent that already keeps its own wallet's key in a file can sign here with th
 | `GAGE_PRIVATE_KEY_FILE` | a key of your own instead of `init`'s: a file holding only the 0x-prefixed key, mode 600 (the server warns on stderr when other users can read it) |
 | `GAGE_PRIVATE_KEY` | the key itself, when a file is not possible; removed from the environment once read |
 | `GAGE_HOME` | where `init` keeps the wallet and the limits keep their record; `~/.gage` when unset. It must be yours, writable by no one else, and the wallet's key a file of yours only you can read: otherwise the key is refused (`KEY_FILE_UNSAFE`) and so is a limited action (`LIMITS_UNSAFE`, or `LIMITS_UNREADABLE` when the record cannot be read) |
-| `GAGE_NETWORK` | `testnet` (the default) or `mainnet` (see Mainnet) |
+| `GAGE_NETWORK` | `mainnet` (the default) or `testnet` (see Testnet) |
 | `GAGE_MAX_BORROW_USDG`, `GAGE_MAX_BORROW_DAY_USDG`, `GAGE_MAX_DEPOSIT_USDG`, `GAGE_MAX_DEPOSIT_DAY_USDG` | the spend limits (see Spend limits) |
 | `GAGE_RPC_URL`, `GAGE_INDEXER_URL`, `GAGE_RATES_URL`, `GAGE_VALUATION_URL`, `GAGE_FAUCET_URL` | elsewhere than the network's own services |
 
@@ -124,7 +124,7 @@ An agent that already keeps its own wallet's key in a file can sign here with th
   injected into a page or a token name cannot make it pay someone; an aggregator's call is decoded before it is used.
 - **Clients ask before acting.** The signing tools carry MCP's destructive hint, so a client asks before each one
   unless you allow it.
-- **On mainnet, never past its spend limits**, checked with each action's plan before anything is sent.
+- **Never past the spend limits it keeps**, checked with each action's plan before anything is sent.
 - **Private loans** are never read or acted on.
 - **Logs go to stderr.** stdout carries MCP messages only.
 

package/dist/cli.js

@@ -6,9 +6,9 @@
  * - `gage-mcp` serves the tools. Without a key it reads gage and prepares unsigned transactions. With one it also
  *   signs and sends gage's own planned transactions, and the key never leaves this process. The key comes from
  *   GAGE_PRIVATE_KEY_FILE, GAGE_PRIVATE_KEY, or the wallet `init` made.
- * GAGE_NETWORK=mainnet serves Robinhood Chain (4663, D260). There a key signs only under spend limits (D225, D297): the
- * owner's GAGE_MAX_BORROW_USDG, GAGE_MAX_BORROW_DAY_USDG, GAGE_MAX_DEPOSIT_USDG and GAGE_MAX_DEPOSIT_DAY_USDG, else 100
- * USDG an action and 250 in 24 hours (limits.ts); on the testnet only those set. GAGE_RPC_URL, GAGE_INDEXER_URL, GAGE_RATES_URL,
+ * It serves Robinhood Chain (4663, D260) unless GAGE_NETWORK=testnet (D311). There a key signs under spend limits (D297):
+ * the owner's GAGE_MAX_BORROW_USDG, GAGE_MAX_BORROW_DAY_USDG, GAGE_MAX_DEPOSIT_USDG and GAGE_MAX_DEPOSIT_DAY_USDG (`off`
+ * lifts one, D311), else 100 USDG an action and 250 in 24 hours (limits.ts); on the testnet only those set. GAGE_RPC_URL, GAGE_INDEXER_URL, GAGE_RATES_URL,
  * GAGE_VALUATION_URL and GAGE_FAUCET_URL point it elsewhere than the network's own services. In server mode stdout
  * carries MCP messages only; logs go to stderr.
  */

package/dist/limits.d.ts

@@ -15,8 +15,8 @@ export declare const MAINNET_LIMITS: Limits;
 /** What the limits leave free (`NOT_LIMITED`), in words, for the guide, `init` and `gage_limits`. */
 export declare const NOT_LIMITED_WORDS = "Repaying, cashing out, rolling a loan over at the same size, leaving a loan to roll by itself or ending that, withdrawing, cancelling, collecting and rating gage are not limited, nor are actions in an asset other than USDG.";
 /**
- * The limits a server signs under on `chainId`: each setting given, else mainnet's default for it. On the testnet a
- * setting not given is no limit, and with none given there are no limits at all (null).
+ * The limits a server signs under on `chainId`: each setting given (`off` for none), else mainnet's default for it. On
+ * the testnet a setting not given is no limit, and with none given there are no limits at all (null).
  */
 export declare function limitsFrom(env: NodeJS.ProcessEnv, chainId: number): Limits | null;
 /** Raw USDG as it is written: 100, 20.5, 0.000001. */

package/dist/limits.js

@@ -6,7 +6,8 @@
  * action in an asset other than USDG (the founder's choice). A roll counts only what it borrows beyond the loan it
  * repays (the founder, 18 October 2026): gage-sdk rolls a loan into one of the same size, so a roll counts nothing, as
  * repaying does; leaving a loan to roll by itself, or ending that, moves nothing, nor does a rating of gage (D302). On
- * mainnet each limit has a default, 100 USDG an action and 250 in 24 hours; on the testnet there is none unless one is set.
+ * mainnet each limit has a default, 100 USDG an action and 250 in 24 hours, which the owner may lift with `off` (D311:
+ * whether an agent signs without limits is its owner's choice); on the testnet there is none unless one is set.
  *
  * The 24 hours count across restarts and across every gage-mcp on this computer acting for the wallet: each action that
  * counts holds its amount as a file in the wallet's folder, named after its time, kind and amount. The file is made
@@ -36,17 +37,22 @@ const SETTINGS = {
 const NOT_LIMITED = ["reclaim", "cash_out", "roll (a loan of the same size)", "auto_roll", "cancel_auto_roll", "earn_redeem", "cancel", "collect", "feedback", "actions in an asset other than USDG"];
 /** What the limits leave free (`NOT_LIMITED`), in words, for the guide, `init` and `gage_limits`. */
 export const NOT_LIMITED_WORDS = "Repaying, cashing out, rolling a loan over at the same size, leaving a loan to roll by itself or ending that, withdrawing, cancelling, collecting and rating gage are not limited, nor are actions in an asset other than USDG.";
-/** A setting's amount of USDG, whole or with up to six decimals, as raw USDG; refused in fixed words naming it. */
+/**
+ * A setting's amount of USDG, whole or with up to six decimals, as raw USDG, or null for `off` (no limit, D311); anything
+ * else is refused in fixed words naming it.
+ */
 function amountOf(name, value) {
     const written = value.trim();
+    if (written.toLowerCase() === "off")
+        return null;
     if (!/^\d{1,12}(\.\d{1,6})?$/.test(written))
-        throw new ApiError("INVALID_LIMIT", `${name} must be an amount of USDG, such as 100 or 0.5`, 400);
+        throw new ApiError("INVALID_LIMIT", `${name} must be an amount of USDG, such as 100 or 0.5, or off`, 400);
     const [whole = "0", decimals = ""] = written.split(".");
     return BigInt(whole) * USDG_UNIT + BigInt(decimals.padEnd(6, "0"));
 }
 /**
- * The limits a server signs under on `chainId`: each setting given, else mainnet's default for it. On the testnet a
- * setting not given is no limit, and with none given there are no limits at all (null).
+ * The limits a server signs under on `chainId`: each setting given (`off` for none), else mainnet's default for it. On
+ * the testnet a setting not given is no limit, and with none given there are no limits at all (null).
  */
 export function limitsFrom(env, chainId) {
     const given = (name) => (env[name] ?? "").trim() !== "";

package/dist/server.d.ts

@@ -3,13 +3,14 @@
  * and prepares unsigned transactions. With a key it also carries actions out, signing in this process. The key never
  * leaves the process, and gage never sees it. It signs only the transactions gage's own planner builds, to gage's
  * contracts and, for a rating of gage on mainnet (D302), to ERC-8004's Reputation Registry: there is no tool that sends
- * arbitrary calldata. On the testnet (46630, D222) with or without a key; on mainnet (4663, D260) with a key only under
- * spend limits (D225, D297), which every action is checked against before anything is sent.
+ * arbitrary calldata. On mainnet (4663, D260, the default since D311) and the testnet (46630, D222), with or without a
+ * key; on mainnet a key signs under spend limits (D297) unless its owner lifts them (D311), and every action is checked
+ * against the limits kept before anything is sent.
  */
 import { type ActionName, type Gage, type Signer } from "gage-sdk";
 import { McpServer } from "@modelcontextprotocol/server";
 import { type Ledger, type Limits } from "./limits.js";
-export declare const VERSION = "0.5.1";
+export declare const VERSION = "0.6.0";
 /** A key's spend limits (D297), and the ledger of what they have held. */
 export interface Limited {
     limits: Limits;

package/dist/server.js

@@ -3,14 +3,15 @@
  * and prepares unsigned transactions. With a key it also carries actions out, signing in this process. The key never
  * leaves the process, and gage never sees it. It signs only the transactions gage's own planner builds, to gage's
  * contracts and, for a rating of gage on mainnet (D302), to ERC-8004's Reputation Registry: there is no tool that sends
- * arbitrary calldata. On the testnet (46630, D222) with or without a key; on mainnet (4663, D260) with a key only under
- * spend limits (D225, D297), which every action is checked against before anything is sent.
+ * arbitrary calldata. On mainnet (4663, D260, the default since D311) and the testnet (46630, D222), with or without a
+ * key; on mainnet a key signs under spend limits (D297) unless its owner lifts them (D311), and every action is checked
+ * against the limits kept before anything is sent.
  */
 import { ACTIONS, MAINNET, MAINNET_DEFAULTS, TESTNET, gageTools, refusalOf } from "gage-sdk";
 import { McpServer } from "@modelcontextprotocol/server";
 import { z } from "zod";
 import { limitsOf, limitsSentence, NOT_LIMITED_WORDS, spendLimit } from "./limits.js";
-export const VERSION = "0.5.1";
+export const VERSION = "0.6.0";
 const WHERE = {
     [TESTNET]: "on Robinhood Chain testnet (46630). Test assets only.",
     [MAINNET]: "on Robinhood Chain (4663), with real assets.",

package/dist/wallet.d.ts

@@ -21,9 +21,12 @@ export declare function ensureKey(file: string): {
  * link), so it is read as named, and `warn` says when other users can read it.
  */
 export declare function readKey(env: NodeJS.ProcessEnv, made: string, warn?: (message: string) => void): string | undefined;
-/** How each agent adds the server that signs with this wallet: the prompt on gage.cash says "do what it prints". */
-export declare const NEXT: readonly ["Next: add gage's MCP server, which runs `npx -y gage-mcp` and signs with this wallet, then restart so its tools load.", "  Claude Code: `claude mcp add gage -- npx -y gage-mcp`", "  Codex: `codex mcp add gage -- npx -y gage-mcp`", "  Hermes: under mcp_servers in ~/.hermes/config.yaml, `gage: { command: \"npx\", args: [\"-y\", \"gage-mcp\"] }`, then /reload-mcp", "  Any other agent: a stdio MCP server named gage that runs `npx -y gage-mcp`."];
-/** The same on mainnet, where the server is told its network (D260). */
+/**
+ * How each agent adds the server that signs with this wallet on the testnet: the prompt on testnet.gage.cash says "do
+ * what it prints". The server serves mainnet unless told otherwise (D311), so it is told the testnet.
+ */
+export declare const NEXT: readonly ["Next: add gage's MCP server, which runs `npx -y gage-mcp` on the testnet and signs with this wallet, then restart so its tools load.", "  Claude Code: `claude mcp add gage -e GAGE_NETWORK=testnet -- npx -y gage-mcp`", "  Codex: `codex mcp add gage --env GAGE_NETWORK=testnet -- npx -y gage-mcp`", "  Hermes: under mcp_servers in ~/.hermes/config.yaml, `gage: { command: \"npx\", args: [\"-y\", \"gage-mcp\"], env: { GAGE_NETWORK: \"testnet\" } }`, then /reload-mcp", "  Any other agent: a stdio MCP server named gage that runs `npx -y gage-mcp` with GAGE_NETWORK=testnet."];
+/** The same on mainnet, where the server is told its network (D260), as earlier releases needed. */
 export declare const NEXT_MAINNET: readonly ["Next: add gage's MCP server, which runs `npx -y gage-mcp` on mainnet and signs with this wallet, then restart so its tools load.", "  Claude Code: `claude mcp add gage -e GAGE_NETWORK=mainnet -- npx -y gage-mcp`", "  Codex: `codex mcp add gage --env GAGE_NETWORK=mainnet -- npx -y gage-mcp`", "  Hermes: under mcp_servers in ~/.hermes/config.yaml, `gage: { command: \"npx\", args: [\"-y\", \"gage-mcp\"], env: { GAGE_NETWORK: \"mainnet\" } }`, then /reload-mcp", "  Any other agent: a stdio MCP server named gage that runs `npx -y gage-mcp` with GAGE_NETWORK=mainnet."];
 export interface InitOptions {
     gage: Gage;

package/dist/wallet.js

@@ -95,15 +95,18 @@ async function fund(faucetUrl, to, fetcher) {
         refused: results.filter((r) => !r.hash).map((r) => `${r.label}${r.code ? ` (${r.code})` : ""}`),
     };
 }
-/** How each agent adds the server that signs with this wallet: the prompt on gage.cash says "do what it prints". */
+/**
+ * How each agent adds the server that signs with this wallet on the testnet: the prompt on testnet.gage.cash says "do
+ * what it prints". The server serves mainnet unless told otherwise (D311), so it is told the testnet.
+ */
 export const NEXT = [
-    "Next: add gage's MCP server, which runs `npx -y gage-mcp` and signs with this wallet, then restart so its tools load.",
-    "  Claude Code: `claude mcp add gage -- npx -y gage-mcp`",
-    "  Codex: `codex mcp add gage -- npx -y gage-mcp`",
-    '  Hermes: under mcp_servers in ~/.hermes/config.yaml, `gage: { command: "npx", args: ["-y", "gage-mcp"] }`, then /reload-mcp',
-    "  Any other agent: a stdio MCP server named gage that runs `npx -y gage-mcp`.",
+    "Next: add gage's MCP server, which runs `npx -y gage-mcp` on the testnet and signs with this wallet, then restart so its tools load.",
+    "  Claude Code: `claude mcp add gage -e GAGE_NETWORK=testnet -- npx -y gage-mcp`",
+    "  Codex: `codex mcp add gage --env GAGE_NETWORK=testnet -- npx -y gage-mcp`",
+    '  Hermes: under mcp_servers in ~/.hermes/config.yaml, `gage: { command: "npx", args: ["-y", "gage-mcp"], env: { GAGE_NETWORK: "testnet" } }`, then /reload-mcp',
+    "  Any other agent: a stdio MCP server named gage that runs `npx -y gage-mcp` with GAGE_NETWORK=testnet.",
 ];
-/** The same on mainnet, where the server is told its network (D260). */
+/** The same on mainnet, where the server is told its network (D260), as earlier releases needed. */
 export const NEXT_MAINNET = [
     "Next: add gage's MCP server, which runs `npx -y gage-mcp` on mainnet and signs with this wallet, then restart so its tools load.",
     "  Claude Code: `claude mcp add gage -e GAGE_NETWORK=mainnet -- npx -y gage-mcp`",
@@ -120,7 +123,7 @@ export async function init(o) {
     const chainId = o.gage.deployment.chainId, mainnet = chainId === MAINNET;
     const file = keyFile(o.home, chainId);
     const { key, created } = ensureKey(file);
-    const signer = privateKeySigner(key, { ...(o.rpcUrl ? { rpcUrl: o.rpcUrl } : {}), ...(mainnet ? { network: "mainnet" } : {}) });
+    const signer = privateKeySigner(key, { ...(o.rpcUrl ? { rpcUrl: o.rpcUrl } : {}), network: mainnet ? "mainnet" : "testnet" });
     o.out(`Your gage wallet on Robinhood Chain${mainnet ? "" : " testnet"} (${chainId}): ${signer.address}`);
     o.out(created ? `Made just now. Its key is in ${file}, readable only by you: never print, share or move it.` : `It already existed; its key is in ${file}.`);
     if (o.faucetUrl) {
@@ -144,7 +147,7 @@ export async function init(o) {
     }
     if (o.limits) {
         o.out(`Spend limits: ${limitsSentence(o.limits)}`);
-        o.out("Change them in the server's environment: GAGE_MAX_BORROW_USDG, GAGE_MAX_BORROW_DAY_USDG, GAGE_MAX_DEPOSIT_USDG, GAGE_MAX_DEPOSIT_DAY_USDG (amounts of USDG).");
+        o.out("Change them in the server's environment: GAGE_MAX_BORROW_USDG, GAGE_MAX_BORROW_DAY_USDG, GAGE_MAX_DEPOSIT_USDG, GAGE_MAX_DEPOSIT_DAY_USDG (amounts of USDG, or off for no limit).");
     }
     for (const line of mainnet ? NEXT_MAINNET : NEXT)
         o.out(line);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gage-mcp",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "mcpName": "cash.gage/gage",
   "type": "module",
   "description": "gage's MCP server for agents with their own wallet: `npx -y gage-mcp init`, then borrow and earn on gage. Robinhood Chain under spend limits, and its testnet.",
@@ -47,7 +47,7 @@
     "@modelcontextprotocol/server": "2.0.0",
     "viem": "2.56.3",
     "zod": "^4.5.4",
-    "gage-sdk": "0.5.1"
+    "gage-sdk": "0.6.0"
   },
   "devDependencies": {
     "@modelcontextprotocol/client": "2.0.0",