mcp-gauge-x402 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CHANGCHINFU
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,116 @@
+# mcp-gauge — MCP server for GAUGE (verifiable signals, pay-per-call in USDC via x402)
+
+[![MCP server score](https://glama.ai/mcp/servers/CHANGCHINFU/mcp-gauge/badges/score.svg)](https://glama.ai/mcp/servers/CHANGCHINFU/mcp-gauge)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
+[![Model Context Protocol](https://img.shields.io/badge/Model_Context_Protocol-server-blue)](https://modelcontextprotocol.io)
+
+Give any **MCP host** (Claude Desktop, Cursor, MCP-compatible agents) access to **GAUGE**'s verifiable, screening-level signals across many domains (weather, drought, agriculture, power grid, shipping, regulatory filings, and more) — and let the agent **pay per call in USDC on Base via [x402](https://x402.org)** (EIP-3009 gasless, **no API key, no signup**).
+
+**Pure description** — official-source facts (USGS / NOAA / EPA / CAMS / ERA5 / FRED / Open-Meteo Marine / SEC EDGAR) + back-testable statistics + `record_hash`, with daily Merkle roots stamped via OpenTimestamps to Bitcoin — the stamp proves the record set existed **no later than** its `stamped_at`; it is **not** evidence about the data day itself. The agent decides. Payment settles **directly to the provider wallet**.
+
+Backed by the GAUGE service at **https://api.truthbear.co**.
+(The service also still answers on its previous host `https://aeml-x402.zeabur.app`; `api.truthbear.co` is the canonical URL and is what every 402 challenge advertises as the resource.)
+
+> **Part of Truth Bear 🐻** — GAUGE is the data engine behind [Truth Bear](https://gauge-frontdesk.zeabur.app), the natural-language front desk for AI agents and SMBs. Ask in plain language, get the official fact + its source + a verifiable `record_hash` — no prediction, no advice, the rest is your call. *An analyst, not a commander.* Front desk: **https://gauge-frontdesk.zeabur.app** · discovery: `/.well-known/x402`, `/llms.txt`.
+
+## Why MCP + x402
+
+- **Discovery** is free and open (MCP): any MCP host lists these tools with zero setup.
+- **Payment** is crypto (x402): the agent pays USDC only when it calls a *paid* tool.
+- Free tools (`gauge_catalog`, `gauge_preview`, `gauge_sample`, `gauge_river_free`) need **no wallet** — try before you buy.
+
+## Tools
+
+| Tool | Price | What |
+|---|---|---|
+| `gauge_catalog` | free | All signals + queryable entities |
+| `gauge_preview` | free | Coverage, pricing menu, bundle lists |
+| `gauge_sample` | free | A full sample record (what paid looks like) |
+| `gauge_river_free` | free | Raw US river reading (USGS site id) |
+| `verify_signal` | **$0.01** | **Start here.** Verify one official fact before your agent acts - reading vs the official threshold ladder + 5yr percentile + source URL + offline-recomputable record_hash. 180+ signals. |
+| `gauge_flood_risk` | **$0.01** | Hydrology/air/precip alias of `verify_signal` - same endpoint, same price |
+| `gauge_region` | **$0.25** | City bundle: air + precipitation + river + cross-check |
+| `gauge_crop_drought` | **$0.25** | Agriculture triangle: drought (USDM) + heat/GDD + crop VHI |
+| `gauge_grid_stress` | **$0.25** | Power grid triangle: demand + renewables + energy inflation |
+| `gauge_route_disruption` | **$0.25** | Shipping triangle: route disruption + sea state + AIS throughput |
+| `gauge_filing_check` | **$0.25** | Regulatory-filing triangle: 8-K + late filing + Form 4 insider |
+| `gauge_stablecoin_lifecycle` | **$0.25** | see the tool description (regenerated from the live 402 quote) |
+| `gauge_rwa_lifecycle` | **$0.25** | see the tool description (regenerated from the live 402 quote) |
+| `gauge_lrt_lifecycle` | **$0.25** | see the tool description (regenerated from the live 402 quote) |
+| `gauge_defi_lending` | **$0.25** | see the tool description (regenerated from the live 402 quote) |
+| `gauge_depin_network` | **$0.25** | see the tool description (regenerated from the live 402 quote) |
+| `gauge_resolution_as_of` | **$0.01** | see the tool description (regenerated from the live 402 quote) |
+
+Every figure above is regenerated from the live 402 quote. **The 402 challenge the endpoint returns is always authoritative.** If you drive the API with your own x402 client rather than this server, set its `maxValue` to at least **$0.25** — the common default of $0.10 makes your client reject the bundle tools locally, before the request is ever sent. `gauge_preview` returns the current menu for free.
+
+**130+ signals (and growing)** across hydrology, air quality, precipitation, agriculture, power grid, shipping and regulatory filing — with **global coverage** (US plus Argentina, Brazil, China, India, Ukraine, EU and more). Check the live set anytime via the free `gauge_catalog` tool.
+
+## Install & configure
+
+Requires Node 18+. The MCP host runs the server over **stdio**. Install straight from GitHub — **no npm account, no signup** (the built `dist/` is committed):
+
+```bash
+npx -y github:CHANGCHINFU/mcp-gauge
+```
+
+### Claude Desktop
+
+Add to `claude_desktop_config.json` (macOS: `~/Library/Application Support/Claude/`, Windows: `%APPDATA%\Claude\`):
+
+```json
+{
+  "mcpServers": {
+    "gauge": {
+      "command": "npx",
+      "args": ["-y", "github:CHANGCHINFU/mcp-gauge"],
+      "env": {
+        "EVM_PRIVATE_KEY": "0xYOUR_BASE_WALLET_KEY_WITH_A_LITTLE_USDC"
+      }
+    }
+  }
+}
+```
+
+Omit `EVM_PRIVATE_KEY` to use **free tools only** (catalog / preview / sample / river).
+
+### Cursor / other MCP hosts / Claude Code
+
+- **Claude Code**: `claude mcp add gauge -- npx -y github:CHANGCHINFU/mcp-gauge` (add `--env EVM_PRIVATE_KEY=0x…` for paid tools).
+- **Cursor / others**: command `npx -y github:CHANGCHINFU/mcp-gauge`, transport stdio, optional `EVM_PRIVATE_KEY` env.
+
+### From source
+
+```bash
+git clone https://github.com/CHANGCHINFU/mcp-gauge && cd mcp-gauge
+npm install && npm run build
+node dist/index.js        # stdio
+```
+
+> Once published to npm the package name is `mcp-gauge-x402` (`npx -y mcp-gauge-x402`); until then use the GitHub form above.
+
+## Config (env)
+
+| Key | Required | Description |
+|---|---|---|
+| `EVM_PRIVATE_KEY` | for **paid** tools | 0x Base-mainnet wallet key; needs a little USDC (EIP-3009 gasless, no ETH). |
+| `GAUGE_BASE_URL` | no | Default `https://api.truthbear.co`. |
+| `GAUGE_MAX_USDC` | no | Atomic per-call cap. Default `120000` ($0.12). |
+
+> Handle the private key like any hot-wallet secret; fund it with a small USDC balance only.
+
+## Verify (zero-trust)
+
+Every paid record carries `record_hash` (canonical sha256). Daily Merkle roots are stamped via OpenTimestamps to Bitcoin: **the stamp proves the record set existed no later than its `stamped_at` — it is NOT evidence about the data day itself.** Re-check via `POST /verify` or `/proof/:record_hash` at the GAUGE service; see `/gauge/anchor` for the day roots and attestation bytes (verify them with the official `ots` tool).
+
+## Distribution (maintainers)
+
+- **GitHub install** (primary, no npm account): users run `npx -y github:CHANGCHINFU/mcp-gauge`.
+- **awesome-mcp-servers**: submit a PR to a curated MCP server list for discoverability (no npm needed).
+- **MCP Registry** (optional, needs npm): publish `mcp-gauge-x402` to npm, then `server.json` is ready for the [MCP publisher](https://github.com/modelcontextprotocol/registry):
+  ```bash
+  npm publish
+  mcp-publisher login github
+  mcp-publisher publish
+  ```
+
+MIT · AEML-DS Vanished-Data Exchange

package/dist/index.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { createWalletClient, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { base } from "viem/chains";
+import { wrapFetchWithPayment } from "x402-fetch";
+var BASE = (process.env.GAUGE_BASE_URL || "https://api.truthbear.co").replace(/\/$/, "");
+var MAX = BigInt(process.env.GAUGE_MAX_USDC || "350000");
+var DAILY_MAX = BigInt(process.env.GAUGE_DAILY_MAX_USDC || "5000000");
+var _spendDay = "";
+var _spentToday = 0n;
+function assertDailyCap() {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  if (today !== _spendDay) {
+    _spendDay = today;
+    _spentToday = 0n;
+  }
+  if (_spentToday + MAX > DAILY_MAX) {
+    throw new Error(`GAUGE daily spend cap reached (${DAILY_MAX} atomic USDC/day). Blocks runaway/prompt-injection wallet drain. Raise GAUGE_DAILY_MAX_USDC or restart to reset.`);
+  }
+  _spentToday += MAX;
+}
+function wallet() {
+  let pk = process.env.EVM_PRIVATE_KEY || process.env.GAUGE_PRIVATE_KEY;
+  if (!pk) return null;
+  if (!pk.startsWith("0x")) pk = "0x" + pk;
+  return createWalletClient({ account: privateKeyToAccount(pk), chain: base, transport: http() });
+}
+async function freeGet(path) {
+  const r = await fetch(BASE + path);
+  if (!r.ok) throw new Error(`GAUGE ${r.status}: ${(await r.text()).slice(0, 200)}`);
+  return r.json();
+}
+async function paidGet(path) {
+  const w = wallet();
+  if (!w) throw new Error("EVM_PRIVATE_KEY not set \u2014 paid GAUGE tools need a Base-mainnet wallet with a little USDC (x402, gasless, no API key). Set EVM_PRIVATE_KEY in this MCP server's env. Free tools (gauge_catalog/sample/preview/river_free) work without a wallet.");
+  assertDailyCap();
+  const payFetch = wrapFetchWithPayment(fetch, w, MAX);
+  const r = await payFetch(BASE + path, { method: "GET" });
+  if (!r.ok) throw new Error(`GAUGE ${r.status}: ${(await r.text()).slice(0, 200)}`);
+  return r.json();
+}
+var q = (s) => encodeURIComponent(s);
+var ok = (o) => ({ content: [{ type: "text", text: typeof o === "string" ? o : JSON.stringify(o, null, 2) }] });
+var fail = (e) => ({ content: [{ type: "text", text: "Error: " + (e?.message || String(e)) }], isError: true });
+var server = new McpServer({ name: "gauge", version: "0.1.0" });
+server.registerTool("gauge_catalog", {
+  title: "GAUGE catalog (free)",
+  description: "List all GAUGE signals \u2014 hydrology (river level/streamflow), air quality (AQI/PM2.5), precipitation/drought, agriculture (drought/heat/crop VHI), power grid (demand/renewables/energy inflation), shipping (route disruption/sea state/AIS throughput), regulatory filing (8-K/late filing/insider) \u2014 with the entities you can query. Free, no payment.",
+  inputSchema: {}
+}, async () => {
+  try {
+    return ok(await freeGet("/gauge/catalog"));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("gauge_preview", {
+  title: "GAUGE preview & pricing menu (free)",
+  description: "GAUGE coverage counts, \xE0-la-carte pricing menu, and the lists of region/company bundles (regions, agri_regions, grid_regions, shipping_regions, filing_watchlist). Use this to discover what to buy. Free.",
+  inputSchema: {}
+}, async () => {
+  try {
+    return ok(await freeGet("/gauge/preview"));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("gauge_sample", {
+  title: "GAUGE free sample record",
+  description: "A free full sample GAUGE record \u2014 shows exactly what a paid response contains: current reading vs official thresholds (band, distance-to-action), seasonal statistical anomaly (percentile/strata), sources + record_hash provenance. Try before you buy.",
+  inputSchema: {}
+}, async () => {
+  try {
+    return ok(await freeGet("/gauge/sample"));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("gauge_river_free", {
+  title: "Free US river reading",
+  description: "Free raw US river reading (gage height / streamflow) for a USGS site id \u2014 current/previous/change/trend/sources/record_hash. No payment. Example site 07010000 = Mississippi at St. Louis.",
+  inputSchema: {
+    entity: z.string().describe("USGS site id, e.g. 07010000"),
+    signal_id: z.enum(["hydrology.river-level", "hydrology.streamflow"]).optional().describe("default hydrology.river-level")
+  }
+}, async ({ entity, signal_id }) => {
+  try {
+    return ok(await freeGet(`/gauge/raw?signal_id=${q(signal_id || "hydrology.river-level")}&entity=${q(entity)}`));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("verify_signal", {
+  title: "Verify one official fact before you act ($0.01)",
+  description: "PRE-EXECUTION CHECK. Verify one official-source fact before your agent commits to an action - a payout, an order, a route, a filing, an alert. Returns the current official reading against the OFFICIAL threshold ladder (band, distance-to-action), a 5-year same-season percentile so you can tell routine from unusual, the source URL, and a record_hash you can recompute offline to prove the answer was not altered. 180+ signals across macro, weather, hazard, shipping, filings, crypto and lifecycle lines - this is the cheapest and most general entry point; the $0.25 *_region tools are the multi-leg audit version of the same thing. Costs $0.01 USDC on Base via x402. Free coverage check first at gauge_catalog. Descriptive only, never a forecast or advice. No data -> not billed.",
+  inputSchema: {
+    signal_id: z.string().describe("what to check, in genus.species form, e.g. hydrology.river-level, macro.unemployment, crypto.spot, earthquake.current_activity - full list free via gauge_catalog"),
+    entity: z.string().describe("which object, PAIRED WITH signal_id, e.g. 07010000 for hydrology.river-level, japan for earthquake.current_activity - valid pairs free via gauge_catalog")
+  }
+}, async ({ signal_id, entity }) => {
+  try {
+    return ok(await paidGet(`/gauge?signal_id=${q(signal_id)}&entity=${q(entity)}`));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("gauge_flood_risk", {
+  title: "Flood-risk / anomaly record ($0.01)",
+  description: "Hydrology/air/precipitation alias of verify_signal - same endpoint, same $0.01 price; prefer verify_signal for anything else. Verifiable flood-risk / anomaly record for one signal+entity: current vs official USGS/NOAA/EPA/CAMS thresholds (band, distance-to-action) + 5yr seasonal anomaly (percentile/strata) + record_hash. Costs $0.01 USDC on Base via x402. Works for hydrology/air/precip signals.",
+  inputSchema: {
+    signal_id: z.string().describe("e.g. hydrology.river-level, hydrology.streamflow, airquality.aqi, airquality.pm25, precipitation.daily, precipitation.wetness30d"),
+    entity: z.string().describe("USGS site id for rivers, or city id (e.g. us-chicago) for air/precip \u2014 see gauge_catalog")
+  }
+}, async ({ signal_id, entity }) => {
+  try {
+    return ok(await paidGet(`/gauge?signal_id=${q(signal_id)}&entity=${q(entity)}`));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("gauge_region", {
+  title: "Region bundle: air + rain + river ($0.25)",
+  description: "Three-leg region bundle for a US city: air quality + precipitation + nearby river, with cross-line corroboration narrative. Costs $0.25 USDC on Base. loc e.g. us-stlouis, us-chicago (see gauge_preview regions). Set your x402 client maxValue to at least $0.25 - the common default of $0.10 rejects this locally, before the request is sent.",
+  inputSchema: { loc: z.string().describe("city id, e.g. us-stlouis") }
+}, async ({ loc }) => {
+  try {
+    return ok(await paidGet(`/gauge/region?loc=${q(loc)}`));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("gauge_crop_drought", {
+  title: "Agriculture triangle: crop drought ($0.25)",
+  description: "Agriculture triangle for a grain region: agricultural drought (soil moisture vs official USDM D0\u2013D4) + heat/GDD + crop vegetation health (NOAA satellite VHI) + cross-validation (has drought hit the crop canopy). For ag traders & crop insurers. Costs $0.25 USDC on Base. loc e.g. us-iowa, ar-pampas, ua-ukraine. Set your x402 client maxValue to at least $0.25 - the common default of $0.10 rejects this locally, before the request is sent.",
+  inputSchema: { loc: z.string().describe("grain region id, e.g. us-iowa, ar-pampas, ua-ukraine") }
+}, async ({ loc }) => {
+  try {
+    return ok(await paidGet(`/gauge/agri-region?loc=${q(loc)}`));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("gauge_grid_stress", {
+  title: "Power grid triangle: grid stress & energy inflation ($0.25)",
+  description: "Power grid triangle for a grid region: electricity demand pressure (temperature HDD/CDD load proxy) + renewable resource (solar/wind) + energy inflation (US CPI Energy YoY) / natural gas price + cross-validation (high demand \xD7 low renewables = grid squeeze \u2192 energy inflation). For power/energy & macro/inflation traders, utilities. Costs $0.25 USDC on Base. loc e.g. us-ercot, us-caiso, eu-germany. Set your x402 client maxValue to at least $0.25 - the common default of $0.10 rejects this locally, before the request is sent.",
+  inputSchema: { loc: z.string().describe("grid region id, e.g. us-ercot, us-caiso, eu-germany") }
+}, async ({ loc }) => {
+  try {
+    return ok(await paidGet(`/gauge/grid-region?loc=${q(loc)}`));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("gauge_route_disruption", {
+  title: "Shipping triangle: route disruption & throughput ($0.25)",
+  description: "Shipping/port triangle for a chokepoint: logistics-flow disruption (WMO sea state + wind vs operational thresholds) + sea-state cause (wave decomposition: local-storm vs distant-swell) + live AIS vessel throughput (waiting vs transiting + congestion) + cross-validation. For shipping lines, commodity/freight traders, ports, marine insurers. Costs $0.25 USDC on Base. loc e.g. malacca, suez-redsea, hormuz, channel. Set your x402 client maxValue to at least $0.25 - the common default of $0.10 rejects this locally, before the request is sent.",
+  inputSchema: { loc: z.string().describe("chokepoint id, e.g. malacca, suez-redsea, hormuz, channel") }
+}, async ({ loc }) => {
+  try {
+    return ok(await paidGet(`/gauge/shipping-region?loc=${q(loc)}`));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("gauge_filing_check", {
+  title: "Regulatory-filing triangle: corporate distress & insider ($0.25)",
+  description: "Regulatory-filing triangle for a company: 8-K material events (item severity \u2014 bankruptcy/default/restatement/delisting = critical) + NT late-filing delinquency (distress leading indicator) + Form 4 insider net open-market buy/sell + cross-validation (do insiders confirm the distress by selling or contradict it by buying). All official SEC EDGAR. For event-driven/activist/short funds, quant funds, credit & distressed analysts. Costs $0.25 USDC on Base. entity = ticker e.g. AMC, CVNA, GME. Set your x402 client maxValue to at least $0.25 - the common default of $0.10 rejects this locally, before the request is sent.",
+  inputSchema: { entity: z.string().describe("ticker from watchlist, e.g. AMC, CVNA, GME, BA (see gauge_preview filing_watchlist)") }
+}, async ({ entity }) => {
+  try {
+    return ok(await paidGet(`/gauge/filing-company?entity=${q(entity.toUpperCase())}`));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("gauge_stablecoin_lifecycle", {
+  title: "Stablecoin lifecycle triangle: peg-distress & redemption flight ($0.25)",
+  description: "Verifiable stablecoin lifecycle record for one issuer: peg-distress band (current price vs the $1 anchor \u2014 distance-to-action) + redemption-flight pressure (supply/reserve/outflow dynamics) + downstream exposure cascade + cross-validation, from official/on-chain sources with record_hash. Screening-grade forensics of where a stablecoin sits in its lifecycle \u2014 not investment advice, no buy/sell framing. Costs $0.25 USDC on Base via x402. entity e.g. terrausd-ust, usdc-circle, usdt. Set your x402 client maxValue to at least $0.25 - the common default of $0.10 rejects this locally, before the request is sent.",
+  inputSchema: { entity: z.string().describe("stablecoin id, e.g. terrausd-ust, usdc-circle, usdt (see gauge_catalog)") }
+}, async ({ entity }) => {
+  try {
+    return ok(await paidGet(`/gauge/stablecoin-region?entity=${q(entity)}`));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("gauge_rwa_lifecycle", {
+  title: "Tokenized RWA lifecycle triangle: redemption pressure & exposure cascade ($0.25)",
+  description: "Verifiable tokenized real-world-asset (RWA) issuer lifecycle record: issuer lifecycle band + redemption pressure (NAV vs on-chain supply, outflow) + exposure cascade to downstream holders/protocols + cross-validation, from official/on-chain sources with record_hash. Screening-grade forensics of a tokenized-asset issuer's lifecycle position \u2014 not investment advice, no buy/sell framing. Costs $0.25 USDC on Base via x402. entity e.g. blackrock-buidl, ondo-ousg. Set your x402 client maxValue to at least $0.25 - the common default of $0.10 rejects this locally, before the request is sent.",
+  inputSchema: { entity: z.string().describe("RWA issuer id, e.g. blackrock-buidl, ondo-ousg (see gauge_catalog)") }
+}, async ({ entity }) => {
+  try {
+    return ok(await paidGet(`/gauge/rwa-region?entity=${q(entity)}`));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("gauge_lrt_lifecycle", {
+  title: "Liquid-restaking (LRT) lifecycle triangle: redemption queue & collateral cascade ($0.25)",
+  description: "Verifiable liquid-restaking-token (LRT) lifecycle record: lifecycle band anchored to ETH-NAV (NOT $1) + redemption-queue pressure (withdrawal backlog, discount-to-NAV) + collateral cascade to protocols using the LRT as collateral + cross-validation, from official/on-chain sources with record_hash. Screening-grade forensics of where an LRT sits in its lifecycle \u2014 not investment advice, no buy/sell framing. Costs $0.25 USDC on Base via x402. entity e.g. etherfi-weeth, renzo-ezeth. Set your x402 client maxValue to at least $0.25 - the common default of $0.10 rejects this locally, before the request is sent.",
+  inputSchema: { entity: z.string().describe("LRT id, e.g. etherfi-weeth, renzo-ezeth (see gauge_catalog)") }
+}, async ({ entity }) => {
+  try {
+    return ok(await paidGet(`/gauge/lrt-region?entity=${q(entity)}`));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("gauge_defi_lending", {
+  title: "DeFi lending protocol lifecycle triangle: bad-debt stress & contagion ($0.25)",
+  description: "Verifiable DeFi lending-protocol lifecycle record: protocol lifecycle band + bad-debt stress (utilization, insolvency/underwater-position pressure) + contagion cascade to correlated protocols and collateral + cross-validation, from official/on-chain sources with record_hash. Screening-grade forensics of a lending protocol's lifecycle position \u2014 not investment advice, no buy/sell framing. Costs $0.25 USDC on Base via x402. entity = protocol id (see gauge_catalog). Set your x402 client maxValue to at least $0.25 - the common default of $0.10 rejects this locally, before the request is sent.",
+  inputSchema: { entity: z.string().describe("DeFi lending protocol id (see gauge_catalog)") }
+}, async ({ entity }) => {
+  try {
+    return ok(await paidGet(`/gauge/defilending-region?entity=${q(entity)}`));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("gauge_depin_network", {
+  title: "DePIN network lifecycle triangle: reward churn & downstream exposure ($0.25)",
+  description: "Verifiable DePIN (decentralized physical infrastructure) network lifecycle record: network-liveness lifecycle band (active nodes/coverage/throughput) + reward-churn pressure (emissions vs participation, node attrition) + downstream exposure cascade + cross-validation, from official/on-chain sources with record_hash. Screening-grade forensics of a DePIN network's lifecycle position \u2014 not investment advice, no buy/sell framing. Costs $0.25 USDC on Base via x402. entity e.g. helium, render, filecoin. Set your x402 client maxValue to at least $0.25 - the common default of $0.10 rejects this locally, before the request is sent.",
+  inputSchema: { entity: z.string().describe("DePIN network id, e.g. helium, render, filecoin (see gauge_catalog)") }
+}, async ({ entity }) => {
+  try {
+    return ok(await paidGet(`/gauge/depin-region?entity=${q(entity)}`));
+  } catch (e) {
+    return fail(e);
+  }
+});
+server.registerTool("gauge_resolution_as_of", {
+  title: "Proposer-feed resolution: official fact + evidence + source-agreement confidence ($0.01)",
+  description: "Resolves a prediction-market question to the OFFICIAL FACT for an issuer/form. Returns the official answer (boolean) + a verifiable evidence_url + source_tier + a source-AGREEMENT confidence in [0,1] + _citation. This is the recorded official fact and how strongly official sources agree on it \u2014 it is NOT a prediction of the market outcome, and the confidence is NOT a probability that the market resolves yes. Honest-fails with no charge ({ answer:null, confidence:0, no_charge:true, note }) when the fact is not officially determinable as of the cutoff. Screening-grade, official sources only. Costs $0.01 USDC on Base via x402 (no charge on honest-fail).",
+  inputSchema: {
+    issuer: z.string().describe("the entity/issuer the question is about (e.g. a ticker or issuer id)"),
+    form: z.string().optional().describe("the official form/event type to resolve against (e.g. a filing form), if applicable"),
+    as_of: z.string().optional().describe("optional cutoff timestamp \u2014 resolve the fact as known at this instant (ISO 8601)")
+  }
+}, async ({ issuer, form, as_of }) => {
+  try {
+    const params = [`issuer=${q(issuer)}`];
+    if (form) params.push(`form=${q(form)}`);
+    if (as_of) params.push(`as_of=${q(as_of)}`);
+    return ok(await paidGet(`/resolve/proposer?${params.join("&")}`));
+  } catch (e) {
+    return fail(e);
+  }
+});
+var transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("mcp-gauge running (stdio). Base=" + BASE + " wallet=" + (wallet() ? "set" : "unset \u2014 free tools only"));

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "mcp-gauge-x402",
+  "version": "1.0.1",
+  "mcpName": "io.github.CHANGCHINFU/mcp-gauge",
+  "description": "MCP server for GAUGE — verifiable environmental, agriculture, power-grid, shipping & regulatory-filing signals for AI agents. Free discovery tools; paid screening-level records pay-per-call in USDC on Base via x402 (no API key). Official sources (USGS/NOAA/EPA/ERA5/FRED/Marine/SEC-EDGAR) + record_hash provenance.",
+  "type": "module",
+  "bin": {
+    "mcp-gauge-x402": "dist/index.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "server.json"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "start": "node dist/index.js",
+    "dev": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "viem": "^2.21.0",
+    "x402-fetch": "^0.4.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "mcp-server",
+    "x402",
+    "usdc",
+    "base",
+    "ai-agent",
+    "pay-per-call",
+    "verifiable-data",
+    "flood-risk",
+    "drought",
+    "air-quality",
+    "power-grid",
+    "energy-inflation",
+    "shipping",
+    "port-congestion",
+    "sec-edgar",
+    "insider-trading",
+    "corporate-distress",
+    "record-hash",
+    "opentimestamps"
+  ],
+  "license": "MIT",
+  "author": "AEML-DS Vanished-Data Exchange"
+}

package/server.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.CHANGCHINFU/mcp-gauge",
+  "description": "US government data (USGS/NOAA/SEC/FDA) with cryptographic proof; x402 pay-per-call, no API key",
+  "version": "1.0.1",
+  "websiteUrl": "https://truthbear.co",
+  "repository": {
+    "url": "https://github.com/CHANGCHINFU/mcp-gauge",
+    "source": "github"
+  },
+  "remotes": [
+    {
+      "type": "streamable-http",
+      "url": "https://api.truthbear.co/mcp"
+    }
+  ]
+}