@seekdaseek/plugin-agentfeed 0.1.0

package/README.md

@@ -0,0 +1,81 @@
+# @seekdaseek/plugin-agentfeed
+
+Live crypto market data for [elizaOS](https://github.com/elizaOS/eliza) trading agents, paid per-call in USDC over the [x402 protocol](https://x402.org) on Solana.
+
+No API keys. No subscriptions. No signup. Your agent holds a wallet, and pays $0.001–$0.01 per call only when it actually needs data.
+
+Backed by [AgentFeed](https://x402.ochinimus.app) — multi-exchange liquidation collection (Bybit + OKX WebSocket), Bybit v5 positioning, Pyth prices, and Helius DAS on-chain data.
+
+## What your agent can ask for
+
+| Action | Data | Price |
+|---|---|---|
+| `AGENTFEED_GET_TRADE_CONTEXT` | Full market state: prices, funding, fear/greed, positioning, liquidations | $0.01 |
+| `AGENTFEED_GET_LIQUIDATIONS` | Recent SOL/BTC liquidation prints, filterable | $0.003 |
+| `AGENTFEED_GET_LIQUIDATION_STATS` | 1h/24h totals, long/short split, biggest print | $0.004 |
+| `AGENTFEED_GET_POSITIONING` | Long/short ratio + open interest with 1h/24h deltas | $0.004 |
+| `AGENTFEED_GET_FUNDING_RATE` | SOL + BTC perp funding rates | $0.002 |
+| `AGENTFEED_GET_MARKET_SNAPSHOT` | Compact market snapshot | $0.003 |
+| `AGENTFEED_GET_SOL_PRICE` | SOL spot via Pyth | $0.001 |
+| `AGENTFEED_GET_BTC_PRICE` | BTC spot via Pyth | $0.001 |
+| `AGENTFEED_GET_TOKEN_RISK` | Rug-risk scan: mint/freeze authority, holder concentration | $0.01 |
+| `AGENTFEED_GET_TOKEN_METADATA` | SPL token metadata via Helius DAS | $0.005 |
+| `AGENTFEED_GET_WALLET_HOLDINGS` | Wallet portfolio via Helius DAS | $0.008 |
+
+## Quickstart
+
+```bash
+npm install @seekdaseek/plugin-agentfeed
+```
+
+Character config:
+
+```json
+{
+  "name": "TraderAgent",
+  "plugins": ["@seekdaseek/plugin-agentfeed"],
+  "settings": {
+    "secrets": {
+      "AGENTFEED_PRIVATE_KEY": "<base58 private key OR solana-keygen JSON array>"
+    }
+  }
+}
+```
+
+Fund the wallet with USDC on Solana mainnet. **$1 of USDC ≈ 100–1000 calls.** A tiny amount of SOL is not required — x402 exact-SVM settlement is handled by the facilitator.
+
+Then just talk to your agent:
+
+> "How much got liquidated in the last 24 hours?"
+> "What's the long/short ratio on SOL?"
+> "Is this token a rug: EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+> "Give me the full trade context before we size this position."
+
+## Built-in spend guard
+
+Agents with funded wallets and buggy loops are a drained-wallet incident waiting to happen. This plugin refuses to pay blind:
+
+- Before paying any endpoint, the plugin reads the live 402 quote and **refuses any price above `AGENTFEED_MAX_SPEND_PER_CALL`** (default `$0.02`).
+- Approved quotes are cached for 10 minutes, so steady-state calls cost a single request.
+- No `Provider` is registered — the plugin never silently injects paid data into every prompt. Data is fetched only when an action explicitly fires.
+
+## Settings
+
+| Setting | Required | Default | Description |
+|---|---|---|---|
+| `AGENTFEED_PRIVATE_KEY` | yes | — | Payer wallet key (base58 string or JSON byte array). Must hold USDC on Solana mainnet. |
+| `AGENTFEED_BASE_URL` | no | `https://x402.ochinimus.app` | API base URL. |
+| `AGENTFEED_MAX_SPEND_PER_CALL` | no | `0.02` | USD cap per call; higher quotes are refused. |
+
+## Security notes
+
+- Use a **dedicated hot wallet** for the agent with only the USDC you're willing to spend. Never your main wallet.
+- The private key never leaves the process; payments are signed locally and settled through the x402 facilitator.
+
+## Also available over MCP
+
+The same data is exposed as MCP tools (x402-gated) — see the [AgentFeed manifest](https://x402.ochinimus.app/.well-known/x402.json).
+
+## License
+
+MIT — [seekdaseek](https://github.com/seekdaseek)

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+import { Service, IAgentRuntime, Plugin } from '@elizaos/core';
+
+interface PaidResult {
+    ok: boolean;
+    status: number;
+    data: unknown;
+    paidUsd?: number;
+    settlement?: unknown;
+    error?: string;
+}
+declare class AgentFeedService extends Service {
+    protected runtime: IAgentRuntime;
+    static serviceType: string;
+    capabilityDescription: string;
+    private payFetch;
+    private baseUrl;
+    private maxSpendUsd;
+    private payerAddress;
+    /** path -> { usd, checkedAt } of last approved quote */
+    private approvedQuotes;
+    /** lifetime spend counter for this process (informational) */
+    private totalSpentUsd;
+    constructor(runtime: IAgentRuntime);
+    static start(runtime: IAgentRuntime): Promise<AgentFeedService>;
+    stop(): Promise<void>;
+    private getSettingStr;
+    private init;
+    /** Extract the max USD price from a 402 response body (x402 "accepts" array). */
+    private quoteFromBody;
+    /**
+     * Spend guard. Returns the approved quote in USD, or throws if over cap /
+     * unquotable. Cached per path for QUOTE_TTL_MS.
+     */
+    private preflight;
+    /** Paid GET against AgentFeed. Guard first, then x402 pay-and-retry fetch. */
+    paidGet(path: string): Promise<PaidResult>;
+    get spentUsd(): number;
+    get payer(): string;
+}
+
+interface EndpointDef {
+    /** Path template. `:mint` / `:wallet` are filled from the message. */
+    path: string;
+    /** Expected price in USD (informational; guard uses live quote). */
+    usd: number;
+    /** elizaOS action name (SCREAMING_SNAKE). */
+    action: string;
+    /** Alternative trigger phrases. */
+    similes: string[];
+    /** Action description shown to the LLM. */
+    description: string;
+    /** Natural-language examples that should trigger this action. */
+    triggers: string[];
+    /** Which param the path needs, if any. */
+    param?: 'mint' | 'wallet';
+}
+declare const ENDPOINTS: EndpointDef[];
+
+declare const agentfeedPlugin: Plugin;
+
+export { AgentFeedService, ENDPOINTS, agentfeedPlugin, agentfeedPlugin as default };

package/dist/index.js

@@ -0,0 +1,355 @@
+// src/service.ts
+import { Service, logger } from "@elizaos/core";
+import { createKeyPairSignerFromBytes } from "@solana/kit";
+import { toClientSvmSigner } from "@x402/svm";
+import { ExactSvmScheme } from "@x402/svm/exact/client";
+import { wrapFetchWithPaymentFromConfig, decodePaymentResponseHeader } from "@x402/fetch";
+import bs58 from "bs58";
+var DEFAULT_BASE_URL = "https://x402.ochinimus.app";
+var DEFAULT_MAX_SPEND_USD = 0.02;
+var QUOTE_TTL_MS = 10 * 60 * 1e3;
+var USDC_DECIMALS = 6;
+var AgentFeedService = class _AgentFeedService extends Service {
+  constructor(runtime) {
+    super(runtime);
+    this.runtime = runtime;
+  }
+  runtime;
+  static serviceType = "agentfeed";
+  capabilityDescription = "Pays for and fetches live crypto market data (liquidations, positioning, funding, prices, token risk) from the AgentFeed x402 API on Solana.";
+  payFetch;
+  baseUrl = DEFAULT_BASE_URL;
+  maxSpendUsd = DEFAULT_MAX_SPEND_USD;
+  payerAddress = "";
+  /** path -> { usd, checkedAt } of last approved quote */
+  approvedQuotes = /* @__PURE__ */ new Map();
+  /** lifetime spend counter for this process (informational) */
+  totalSpentUsd = 0;
+  static async start(runtime) {
+    const svc = new _AgentFeedService(runtime);
+    await svc.init();
+    return svc;
+  }
+  async stop() {
+  }
+  getSettingStr(key) {
+    const v = this.runtime.getSetting(key);
+    return typeof v === "string" && v.length > 0 ? v : void 0;
+  }
+  async init() {
+    this.baseUrl = (this.getSettingStr("AGENTFEED_BASE_URL") || DEFAULT_BASE_URL).replace(/\/+$/, "");
+    const cap = Number(this.getSettingStr("AGENTFEED_MAX_SPEND_PER_CALL"));
+    this.maxSpendUsd = Number.isFinite(cap) && cap > 0 ? cap : DEFAULT_MAX_SPEND_USD;
+    const rawKey = this.getSettingStr("AGENTFEED_PRIVATE_KEY");
+    if (!rawKey) {
+      throw new Error(
+        "plugin-agentfeed: AGENTFEED_PRIVATE_KEY is not set. Provide a base58 private key or a solana-keygen JSON byte array for a wallet holding USDC on Solana mainnet."
+      );
+    }
+    const bytes = parseKey(rawKey);
+    const keypair = await createKeyPairSignerFromBytes(bytes);
+    this.payerAddress = keypair.address;
+    const signer = toClientSvmSigner(keypair);
+    this.payFetch = wrapFetchWithPaymentFromConfig(fetch, {
+      schemes: [{ network: "solana:*", client: new ExactSvmScheme(signer) }]
+    });
+    logger.info(
+      `[agentfeed] ready \u2014 payer ${this.payerAddress.slice(0, 4)}\u2026${this.payerAddress.slice(-4)}, base ${this.baseUrl}, cap $${this.maxSpendUsd}/call`
+    );
+  }
+  /** Extract the max USD price from a 402 response body (x402 "accepts" array). */
+  quoteFromBody(body) {
+    const accepts = body?.accepts;
+    if (!Array.isArray(accepts) || accepts.length === 0) return null;
+    let maxUsd = 0;
+    for (const a of accepts) {
+      const raw = a?.maxAmountRequired ?? a?.amount ?? a?.maxAmount;
+      const n = Number(raw);
+      if (Number.isFinite(n) && n > 0) {
+        maxUsd = Math.max(maxUsd, n / 10 ** USDC_DECIMALS);
+      }
+    }
+    return maxUsd > 0 ? maxUsd : null;
+  }
+  /**
+   * Spend guard. Returns the approved quote in USD, or throws if over cap /
+   * unquotable. Cached per path for QUOTE_TTL_MS.
+   */
+  async preflight(path) {
+    const cached = this.approvedQuotes.get(path);
+    if (cached && Date.now() - cached.checkedAt < QUOTE_TTL_MS) return cached.usd;
+    const res = await fetch(this.baseUrl + path, { method: "GET" });
+    if (res.status !== 402) {
+      this.approvedQuotes.set(path, { usd: 0, checkedAt: Date.now() });
+      return 0;
+    }
+    let quoted = null;
+    const prHeader = res.headers.get("payment-required") || res.headers.get("x-payment-required");
+    if (prHeader) {
+      try {
+        quoted = this.quoteFromBody(JSON.parse(atob(prHeader)));
+      } catch {
+      }
+    }
+    if (quoted === null) {
+      try {
+        quoted = this.quoteFromBody(await res.json());
+      } catch {
+      }
+    }
+    if (quoted === null) {
+      throw new Error(`AgentFeed returned 402 for ${path} but the quote could not be parsed; refusing to pay blind.`);
+    }
+    if (quoted > this.maxSpendUsd) {
+      throw new Error(
+        `AgentFeed quoted $${quoted} for ${path}, above the configured cap of $${this.maxSpendUsd} (AGENTFEED_MAX_SPEND_PER_CALL). Call refused.`
+      );
+    }
+    this.approvedQuotes.set(path, { usd: quoted, checkedAt: Date.now() });
+    return quoted;
+  }
+  /** Paid GET against AgentFeed. Guard first, then x402 pay-and-retry fetch. */
+  async paidGet(path) {
+    try {
+      const quotedUsd = await this.preflight(path);
+      const res = await this.payFetch(this.baseUrl + path, { method: "GET" });
+      let settlement;
+      const settleHeader = res.headers.get("payment-response") || res.headers.get("x-payment-response");
+      if (settleHeader) {
+        try {
+          settlement = decodePaymentResponseHeader(settleHeader);
+        } catch {
+          settlement = settleHeader.slice(0, 120);
+        }
+      }
+      const data = await res.json().catch(() => null);
+      if (!res.ok) {
+        return { ok: false, status: res.status, data, error: `AgentFeed HTTP ${res.status}` };
+      }
+      if (settlement) this.totalSpentUsd += quotedUsd;
+      return { ok: true, status: res.status, data, paidUsd: settlement ? quotedUsd : 0, settlement };
+    } catch (e) {
+      return { ok: false, status: 0, data: null, error: e?.message || String(e) };
+    }
+  }
+  get spentUsd() {
+    return this.totalSpentUsd;
+  }
+  get payer() {
+    return this.payerAddress;
+  }
+};
+function parseKey(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("[")) {
+    const arr = JSON.parse(trimmed);
+    if (!Array.isArray(arr)) throw new Error("AGENTFEED_PRIVATE_KEY JSON must be a byte array");
+    return Uint8Array.from(arr);
+  }
+  return bs58.decode(trimmed);
+}
+
+// src/endpoints.ts
+var ENDPOINTS = [
+  {
+    path: "/api/trade-context",
+    usd: 0.01,
+    action: "AGENTFEED_GET_TRADE_CONTEXT",
+    similes: ["GET_TRADE_CONTEXT", "MARKET_CONTEXT", "FULL_MARKET_STATE"],
+    description: "Fetch the full crypto market state in one paid call ($0.01): SOL+BTC prices, funding rates, fear/greed index, long/short positioning, open interest, and recent liquidation summary. Use when the agent needs a complete trading picture before making or explaining a decision.",
+    triggers: [
+      "what's the current trade context",
+      "give me the full market state",
+      "should I be long or short SOL right now, check the data",
+      "pull the trading context before we decide"
+    ]
+  },
+  {
+    path: "/api/liquidations",
+    usd: 3e-3,
+    action: "AGENTFEED_GET_LIQUIDATIONS",
+    similes: ["GET_RECENT_LIQUIDATIONS", "RECENT_LIQUIDATIONS", "LIQUIDATION_FEED"],
+    description: "Fetch recent SOL/BTC perp liquidation prints ($0.003): side, size, price, exchange, timestamp. Use for questions about recent liquidations, cascades, or big liquidation prints.",
+    triggers: [
+      "any big liquidations in the last hour",
+      "show me recent SOL liquidations",
+      "was there a liquidation cascade"
+    ]
+  },
+  {
+    path: "/api/liquidation-stats",
+    usd: 4e-3,
+    action: "AGENTFEED_GET_LIQUIDATION_STATS",
+    similes: ["GET_LIQUIDATION_STATS", "LIQUIDATION_TOTALS"],
+    description: 'Fetch aggregated liquidation stats ($0.004): 1h/24h totals, long vs short split, biggest single print. Use for "how much got liquidated" style questions.',
+    triggers: [
+      "how much got liquidated today",
+      "longs or shorts getting rekt more",
+      "liquidation totals last 24h"
+    ]
+  },
+  {
+    path: "/api/positioning",
+    usd: 4e-3,
+    action: "AGENTFEED_GET_POSITIONING",
+    similes: ["GET_POSITIONING", "LONG_SHORT_RATIO", "OPEN_INTEREST"],
+    description: "Fetch SOL+BTC long/short account ratio and open interest with 1h/24h OI deltas ($0.004). Use for positioning, crowding, or OI questions.",
+    triggers: [
+      "what's the long/short ratio on SOL",
+      "is open interest rising or falling",
+      "how crowded is the long side"
+    ]
+  },
+  {
+    path: "/api/funding-rate",
+    usd: 2e-3,
+    action: "AGENTFEED_GET_FUNDING_RATE",
+    similes: ["GET_FUNDING_RATE", "FUNDING_RATES", "PERP_FUNDING"],
+    description: "Fetch current SOL and BTC perp funding rates ($0.002). Use for funding questions or carry-cost checks.",
+    triggers: [
+      "what's SOL funding right now",
+      "are funding rates positive or negative"
+    ]
+  },
+  {
+    path: "/api/market-snapshot",
+    usd: 3e-3,
+    action: "AGENTFEED_GET_MARKET_SNAPSHOT",
+    similes: ["GET_MARKET_SNAPSHOT", "MARKET_SNAPSHOT"],
+    description: "Fetch a compact market snapshot ($0.003): SOL+BTC prices plus key market gauges in one call. Cheaper than trade-context; use for quick price/market checks that need more than a single price.",
+    triggers: [
+      "quick market snapshot",
+      "how's the market looking"
+    ]
+  },
+  {
+    path: "/api/sol-price",
+    usd: 1e-3,
+    action: "AGENTFEED_GET_SOL_PRICE",
+    similes: ["GET_SOL_PRICE", "SOL_PRICE"],
+    description: "Fetch live SOL spot price via Pyth ($0.001). Use for a plain SOL price check.",
+    triggers: ["what's SOL trading at", "SOL price"]
+  },
+  {
+    path: "/api/btc-price",
+    usd: 1e-3,
+    action: "AGENTFEED_GET_BTC_PRICE",
+    similes: ["GET_BTC_PRICE", "BTC_PRICE"],
+    description: "Fetch live BTC spot price via Pyth ($0.001). Use for a plain BTC price check.",
+    triggers: ["what's bitcoin at", "BTC price"]
+  },
+  {
+    path: "/api/token-risk/:mint",
+    usd: 0.01,
+    action: "AGENTFEED_GET_TOKEN_RISK",
+    similes: ["GET_TOKEN_RISK", "RUG_CHECK", "TOKEN_SAFETY"],
+    description: "Rug-risk scan for an SPL token mint ($0.01): mint/freeze authority status, top-holder concentration, risk flags. The message must contain a Solana mint address. Use before an agent buys or recommends any token.",
+    triggers: [
+      "is this token a rug: <mint>",
+      "run a risk check on <mint>",
+      "check mint and freeze authority for <mint>"
+    ],
+    param: "mint"
+  },
+  {
+    path: "/api/token-metadata/:mint",
+    usd: 5e-3,
+    action: "AGENTFEED_GET_TOKEN_METADATA",
+    similes: ["GET_TOKEN_METADATA", "TOKEN_INFO"],
+    description: "Fetch SPL token metadata via Helius DAS ($0.005): name, symbol, supply, decimals. The message must contain a Solana mint address.",
+    triggers: ["what token is <mint>", "token info for <mint>"],
+    param: "mint"
+  },
+  {
+    path: "/api/wallet-holdings/:wallet",
+    usd: 8e-3,
+    action: "AGENTFEED_GET_WALLET_HOLDINGS",
+    similes: ["GET_WALLET_HOLDINGS", "WALLET_PORTFOLIO"],
+    description: "Fetch a Solana wallet's token holdings via Helius DAS ($0.008). The message must contain a Solana wallet address.",
+    triggers: ["what does this wallet hold: <address>", "portfolio of <address>"],
+    param: "wallet"
+  }
+];
+var BASE58_RE = /\b[1-9A-HJ-NP-Za-km-z]{32,44}\b/;
+
+// src/actions.ts
+function buildExamples(def) {
+  return def.triggers.slice(0, 2).map((t) => [
+    {
+      name: "{{user1}}",
+      content: { text: t.replace("<mint>", "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v").replace("<address>", "4a8o45skRPcyjAdyR8yES215Swvh8uTpZD6KLarhxCJ7") }
+    },
+    {
+      name: "{{agent}}",
+      content: {
+        text: "Pulling live data from AgentFeed\u2026",
+        actions: [def.action]
+      }
+    }
+  ]);
+}
+function makeAction(def) {
+  return {
+    name: def.action,
+    similes: def.similes,
+    description: def.description,
+    validate: async (_runtime, message) => {
+      const text = message?.content?.text ?? "";
+      if (def.param) return BASE58_RE.test(text);
+      return true;
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+      const svc = runtime.getService(AgentFeedService.serviceType);
+      if (!svc) {
+        await callback?.({
+          text: "AgentFeed service is not available \u2014 check that AGENTFEED_PRIVATE_KEY is configured."
+        });
+        return false;
+      }
+      let path = def.path;
+      if (def.param) {
+        const m = (message?.content?.text ?? "").match(BASE58_RE);
+        if (!m) {
+          await callback?.({
+            text: `I need a Solana ${def.param} address in the message to run this lookup.`
+          });
+          return false;
+        }
+        path = path.replace(`:${def.param}`, m[0]);
+      }
+      const result = await svc.paidGet(path);
+      if (!result.ok) {
+        await callback?.({
+          text: `AgentFeed call failed: ${result.error ?? `HTTP ${result.status}`}`
+        });
+        return false;
+      }
+      const paidNote = result.paidUsd ? ` (paid $${result.paidUsd} via x402)` : "";
+      await callback?.({
+        text: `AgentFeed ${def.path} result${paidNote}:
+\`\`\`json
+${JSON.stringify(result.data, null, 2).slice(0, 3500)}
+\`\`\``,
+        data: { agentfeed: { path: def.path, result: result.data, paidUsd: result.paidUsd ?? 0 } }
+      });
+      return true;
+    },
+    examples: buildExamples(def)
+  };
+}
+var agentfeedActions = ENDPOINTS.map(makeAction);
+
+// src/index.ts
+var agentfeedPlugin = {
+  name: "agentfeed",
+  description: "Live crypto market data for trading agents \u2014 liquidations, long/short positioning, open interest, funding rates, SOL/BTC prices, and SPL token rug-risk checks. Each call is paid on the fly in USDC via the x402 protocol on Solana ($0.001\u2013$0.01 per call). Requires a funded Solana wallet.",
+  services: [AgentFeedService],
+  actions: agentfeedActions
+};
+var index_default = agentfeedPlugin;
+export {
+  AgentFeedService,
+  ENDPOINTS,
+  agentfeedPlugin,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@seekdaseek/plugin-agentfeed",
+  "version": "0.1.0",
+  "description": "elizaOS plugin for AgentFeed — paid crypto market data (liquidations, positioning, funding, token risk) over x402 micropayments on Solana. $0.001–$0.01 per call in USDC, no API keys, no subscriptions.",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "test": "node --test"
+  },
+  "keywords": [
+    "elizaos",
+    "elizaos-plugins",
+    "x402",
+    "solana",
+    "crypto",
+    "market-data",
+    "liquidations",
+    "trading",
+    "ai-agents",
+    "micropayments"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/seekdaseek/plugin-agentfeed.git"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@solana/kit": "^7.0.0",
+    "@x402/fetch": "^2.17.0",
+    "@x402/svm": "^2.17.0",
+    "bs58": "^6.0.0"
+  },
+  "peerDependencies": {
+    "@elizaos/core": ">=1.0.0"
+  },
+  "devDependencies": {
+    "@elizaos/core": "^1.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  },
+  "agentConfig": {
+    "pluginType": "elizaos:plugin:1.0.0",
+    "pluginParameters": {
+      "AGENTFEED_PRIVATE_KEY": {
+        "type": "string",
+        "description": "Solana private key of the paying wallet (base58 string OR JSON byte array). Wallet must hold USDC on Solana mainnet. Fund with $1 of USDC = ~100-1000 calls."
+      },
+      "AGENTFEED_BASE_URL": {
+        "type": "string",
+        "description": "AgentFeed API base URL. Default: https://x402.ochinimus.app"
+      },
+      "AGENTFEED_MAX_SPEND_PER_CALL": {
+        "type": "string",
+        "description": "Safety cap in USD per single API call. Any 402 quote above this is refused. Default: 0.02"
+      }
+    }
+  }
+}