wickedapi-mcp 0.1.0 → 0.2.0

package/README.md

@@ -1,16 +1,25 @@
 # WickedAPI MCP Server
 
-MCP server for [WickedAPI](https://api.wickedapi.com) — an agent-ready trading & market-data API covering crypto/stock prices, OHLCV, technical indicators (ATR, Fair Value Gaps, ICT liquidity levels), perp funding/OI, order books, Kalshi prediction markets, DeFi TVL, volatility, a verified macro calendar, an earnings calendar, and an AI momentum score.
+MCP server for the whole [WickedAPI](https://wickedapi.com) platform — trading data, DeFi protocol health, token safety, and brokerage sync, in one server.
 
-Tools are generated automatically from the live [`openapi.json`](https://api.wickedapi.com/openapi.json), so the tool list always matches what's actually deployed.
+**35 tools** across 4 live services, generated automatically from each service's own live `openapi.json` — the tool list always matches what's actually deployed:
+
+| Service | Tools | Auth |
+| --- | --- | --- |
+| [Trading Data API](https://api.wickedapi.com) | 22 (unprefixed: `price`, `ohlcv`, `fvg`, `momentum_score`, `sentiment`, `macro_calendar`, …) | API key or x402, 5 free |
+| [Protocol Health Oracle](https://protocol-health-oracle.wickedapi.com) | 6 (`protocol_health_*`) | API key or x402, scoreboard free |
+| [Token Risk Oracle](https://token-risk-oracle.wickedapi.com) | 1 (`token_risk`) | 100% free, no key |
+| [Broker Sync API](https://broker-sync-api.wickedapi.com) | 6 (`broker_sync_*`) | API key or x402 |
+
+Plus **6 resources** (the platform directory, `llms.txt`, and each service's live endpoint catalog) and **3 prompts** (`rug_check`, `vet_dependency`, `morning_briefing`) that chain tools together the way the [cookbook](../cookbooks/wickedapi-cookbook.md) does.
 
 ## No signup required
 
-Every tool call hits a real `/v1/*` endpoint that's gated by [x402](https://x402.org) (HTTP-native pay-per-call, USDC on Base) with an API-key fallback:
+Every tool hits a real endpoint gated by [x402](https://x402.org) (HTTP-native pay-per-call, USDC on Base) with an API-key fallback — and the Token Risk Oracle tool is free no matter what:
 
-- **Zero config** — calls without credentials still work; you'll get back the real `402` payment challenge (price, network, `payTo`) as the tool result.
+- **Zero config** — calls without credentials still work; paid endpoints return the real `402` payment challenge (price, network, `payTo`) as the tool result.
 - **Autonomous pay-per-call** — set `WICKEDAPI_PAYER_PRIVATE_KEY` to a funded Base-mainnet wallet's private key, and every call auto-pays ~$0.001 in USDC and returns real data. No account, no subscription.
-- **Partner API key** — set `WICKEDAPI_API_KEY` for free, rate-limited access if you have one.
+- **Partner API key** — set `WICKEDAPI_API_KEY` for free, rate-limited access across all four services (same key works everywhere).
 
 ## Install
 
@@ -44,15 +53,37 @@ Or for autonomous pay-per-call instead of a key:
 }
 ```
 
+Nothing configured? The Token Risk Oracle tool and the 5 free Trading Data API endpoints (`sentiment`, `macro_calendar`, `market_overview`, `gas`, `kalshi_probability`) still work with zero setup.
+
+## Resources
+
+Read without calling a tool — useful for a client that surfaces resources in its UI:
+
+- `wickedapi://platform/services` — the full service directory (JSON)
+- `wickedapi://platform/llms` — the platform's `llms.txt`
+- `wickedapi://trading/status`, `wickedapi://protocol_health/status`, `wickedapi://token_risk/status`, `wickedapi://broker_sync/status` — each service's live endpoint catalog
+
+## Prompts
+
+One-click workflows that chain real tool calls (Claude Desktop and other prompt-aware clients surface these directly):
+
+- **`rug_check`** (`address`, `chain`, optional `symbol`) — token risk check + market sentiment + optional momentum read, before buying.
+- **`vet_dependency`** (`slug`, optional `token_address`, `chain`) — protocol health + optional contract-level risk check, before building on a DeFi protocol.
+- **`morning_briefing`** (optional `symbol`) — macro calendar + earnings calendar + sentiment + momentum verdict, as one digest.
+
 ## Environment variables
 
 | Var | Required | Notes |
 | --- | --- | --- |
-| `WICKEDAPI_API_KEY` | no | Free, rate-limited access if you have a partner key. |
+| `WICKEDAPI_API_KEY` | no | Free, rate-limited access across all four services (same key works everywhere). |
 | `WICKEDAPI_PAYER_PRIVATE_KEY` | no | Base-mainnet wallet private key. If set, every call auto-pays the x402 challenge in USDC — no key needed. |
-| `WICKEDAPI_BASE_URL` | no | Override the API base (default `https://api.wickedapi.com`). |
+| `WICKEDAPI_BASE_URL` | no | Override the Trading Data API base (default `https://api.wickedapi.com`). |
+| `WICKEDAPI_PROTOCOL_HEALTH_URL` | no | Override the Protocol Health Oracle base (default `https://protocol-health-oracle.wickedapi.com`). |
+| `WICKEDAPI_TOKEN_RISK_URL` | no | Override the Token Risk Oracle base (default `https://token-risk-oracle.wickedapi.com`). |
+| `WICKEDAPI_BROKER_SYNC_URL` | no | Override the Broker Sync API base (default `https://broker-sync-api.wickedapi.com`). |
+| `WICKEDAPI_SHOWCASE_URL` | no | Override the platform directory base used by resources (default `https://wickedapi.com`). |
 
-If neither `WICKEDAPI_API_KEY` nor `WICKEDAPI_PAYER_PRIVATE_KEY` is set, calls still succeed at the protocol level — you'll get the real `402` challenge back as the tool result instead of data.
+If neither `WICKEDAPI_API_KEY` nor `WICKEDAPI_PAYER_PRIVATE_KEY` is set, paid calls still succeed at the protocol level — you'll get the real `402` challenge back as the tool result instead of data. If one service's spec fails to load (network hiccup, that service is down), its tools are simply skipped for the session — the rest still register normally.
 
 ## Local development
 
@@ -64,4 +95,4 @@ node dist/index.js
 
 ## What this is not
 
-This server doesn't reimplement any data logic — it's a thin, auto-generated bridge from MCP tool calls to the live WickedAPI HTTP endpoints. All the actual market data, indicators, and scoring live in the API itself.
+This server doesn't reimplement any data logic — it's a thin, auto-generated bridge from MCP tool calls to the live WickedAPI HTTP endpoints across all four services. All the actual market data, indicators, scoring, and risk signals live in the APIs themselves.

package/dist/index.js

@@ -2,21 +2,51 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-const BASE_URL = (process.env.WICKEDAPI_BASE_URL || "https://api.wickedapi.com").replace(/\/$/, "");
+function envUrl(name, fallback) {
+    return (process.env[name] || fallback).replace(/\/$/, "");
+}
+const SERVICES = [
+    { id: "trading", name: "Trading Data API", baseUrl: envUrl("WICKEDAPI_BASE_URL", "https://api.wickedapi.com") },
+    { id: "protocol_health", name: "Protocol Health Oracle", baseUrl: envUrl("WICKEDAPI_PROTOCOL_HEALTH_URL", "https://protocol-health-oracle.wickedapi.com") },
+    { id: "token_risk", name: "Token Risk Oracle", baseUrl: envUrl("WICKEDAPI_TOKEN_RISK_URL", "https://token-risk-oracle.wickedapi.com") },
+    { id: "broker_sync", name: "Broker Sync API", baseUrl: envUrl("WICKEDAPI_BROKER_SYNC_URL", "https://broker-sync-api.wickedapi.com") },
+];
+const SHOWCASE_URL = envUrl("WICKEDAPI_SHOWCASE_URL", "https://wickedapi.com");
 const API_KEY = process.env.WICKEDAPI_API_KEY;
 const PAYER_KEY = process.env.WICKEDAPI_PAYER_PRIVATE_KEY;
+// A few auto-generated tool names collide or read badly (e.g. GET and POST
+// both hitting /v1/protocols) — override just those, keyed by
+// "METHOD /openapi/path/{param}".
+const TOOL_NAME_OVERRIDES = {
+    protocol_health: {
+        "GET /v1/protocols": "protocol_health_list_protocols",
+        "POST /v1/protocols": "protocol_health_track_protocol",
+        "GET /v1/health/{slug}": "protocol_health_score",
+        "POST /v1/refresh": "protocol_health_refresh_all",
+        "POST /v1/ingest": "protocol_health_sync_universe",
+    },
+    broker_sync: {
+        "POST /v1/users": "broker_sync_register_user",
+    },
+};
 // If a funded Base-mainnet wallet key is provided, every call auto-pays the
 // x402 402 challenge in USDC — no API key or signup needed at all. Loaded
 // lazily so a plain API-key setup never has to pull in viem/x402-fetch.
 async function buildFetcher() {
     if (!PAYER_KEY)
         return fetch;
-    const [{ createWalletClient, http }, { privateKeyToAccount }, { base }, { wrapFetchWithPayment }] = await Promise.all([
-        import("viem"),
-        import("viem/accounts"),
-        import("viem/chains"),
-        import("x402-fetch"),
-    ]);
+    let deps;
+    try {
+        deps = await Promise.all([import("viem"), import("viem/accounts"), import("viem/chains"), import("x402-fetch")]);
+    }
+    catch {
+        console.error("[wickedapi-mcp] WICKEDAPI_PAYER_PRIVATE_KEY is set, but the wallet-payment dependencies " +
+            "(viem, x402-fetch) aren't installed in this distribution. Falling back to plain fetch — " +
+            "calls without an API key will surface the 402 challenge instead of auto-paying. " +
+            "Use `npx wickedapi-mcp` for full auto-pay support.");
+        return fetch;
+    }
+    const [{ createWalletClient, http }, { privateKeyToAccount }, { base }, { wrapFetchWithPayment }] = deps;
     const account = privateKeyToAccount(PAYER_KEY);
     const wallet = createWalletClient({ account, chain: base, transport: http() });
     console.error(`[wickedapi-mcp] x402 auto-pay enabled — wallet ${account.address}`);
@@ -25,65 +55,270 @@ async function buildFetcher() {
     // wallet client the same way — cast rather than pull in publicActions.
     return wrapFetchWithPayment(fetch, wallet);
 }
-function toolNameFromPath(path) {
-    return path.replace(/^\/v1\//, "").replace(/-/g, "_");
+function pathSlug(openapiPath) {
+    return openapiPath
+        .replace(/^\/v1\//, "")
+        .replace(/[{}]/g, "")
+        .replace(/[\/\-]+/g, "_");
+}
+function toolNameFor(service, method, openapiPath) {
+    const override = TOOL_NAME_OVERRIDES[service.id]?.[`${method.toUpperCase()} ${openapiPath}`];
+    if (override)
+        return override;
+    const slug = pathSlug(openapiPath);
+    if (service.id === "trading")
+        return slug; // legacy naming, already published
+    return slug === service.id ? service.id : `${service.id}_${slug}`;
 }
-function zodForParam(p) {
-    const type = p.schema?.type;
-    const base = type === "number" ? z.coerce.number() : type === "boolean" ? z.coerce.boolean() : z.string();
+function zodFor(p) {
+    const base = p.type === "number" || p.type === "integer"
+        ? z.coerce.number()
+        : p.type === "boolean"
+            ? z.coerce.boolean()
+            : z.string();
     const described = p.description ? base.describe(p.description) : base;
     return p.required ? described : described.optional();
 }
-async function main() {
-    const specRes = await fetch(`${BASE_URL}/openapi.json`);
-    if (!specRes.ok) {
-        throw new Error(`Failed to load ${BASE_URL}/openapi.json: HTTP ${specRes.status}`);
+async function loadServiceSpec(service) {
+    try {
+        const res = await fetch(`${service.baseUrl}/openapi.json`);
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        return (await res.json());
     }
-    const doc = (await specRes.json());
-    const doFetch = await buildFetcher();
-    const server = new McpServer({ name: "wickedapi", version: "0.1.0" });
+    catch (err) {
+        console.error(`[wickedapi-mcp] WARNING: couldn't load ${service.name} spec (${service.baseUrl}/openapi.json): ` +
+            `${err.message} — its tools are unavailable this session, the rest load normally.`);
+        return null;
+    }
+}
+function registerServiceTools(server, service, doc, doFetch) {
     let registered = 0;
-    for (const [path, methods] of Object.entries(doc.paths)) {
-        const op = methods.get;
-        if (!op || !path.startsWith("/v1/") || path === "/v1/status")
-            continue;
-        const shape = {};
-        for (const p of op.parameters ?? []) {
-            if (p.in !== "query")
-                continue;
-            shape[p.name] = zodForParam(p);
-        }
-        server.registerTool(toolNameFromPath(path), {
-            description: [op.summary, op.description].filter(Boolean).join(" — ").slice(0, 1000),
-            inputSchema: shape,
-        }, async (args) => {
-            const url = new URL(BASE_URL + path);
-            for (const [k, v] of Object.entries(args ?? {})) {
-                if (v !== undefined && v !== null)
-                    url.searchParams.set(k, String(v));
+    for (const [openapiPath, methods] of Object.entries(doc.paths)) {
+        if (!openapiPath.startsWith("/v1/") || openapiPath === "/v1/status")
+            continue; // /v1/status is a resource instead
+        if (openapiPath.includes("webhook"))
+            continue; // called by a third party, never by an agent
+        for (const [method, op] of Object.entries(methods)) {
+            const pathParamNames = [];
+            const queryParamNames = [];
+            const bodyPropNames = [];
+            const shape = {};
+            for (const p of op.parameters ?? []) {
+                if (p.in === "path") {
+                    pathParamNames.push(p.name);
+                    shape[p.name] = zodFor({ type: p.schema?.type, required: true, description: p.description });
+                }
+                else if (p.in === "query") {
+                    queryParamNames.push(p.name);
+                    shape[p.name] = zodFor({ type: p.schema?.type, required: p.required, description: p.description });
+                }
             }
-            const headers = {};
-            if (API_KEY)
-                headers["x-api-key"] = API_KEY;
-            const r = await doFetch(url.toString(), { headers });
-            const text = await r.text();
-            let body;
-            try {
-                body = JSON.parse(text);
+            const bodySchema = op.requestBody?.content?.["application/json"]?.schema;
+            if (bodySchema) {
+                const required = new Set(bodySchema.required ?? []);
+                for (const [name, prop] of Object.entries(bodySchema.properties ?? {})) {
+                    bodyPropNames.push(name);
+                    shape[name] = zodFor({ type: prop.type, required: required.has(name), description: prop.description });
+                }
             }
-            catch {
-                body = text;
-            }
-            return {
-                isError: !r.ok,
-                content: [{ type: "text", text: JSON.stringify(body, null, 2) }],
-            };
+            const name = toolNameFor(service, method, openapiPath);
+            server.registerTool(name, {
+                description: `[${service.name}] ${[op.summary, op.description].filter(Boolean).join(" — ")}`.slice(0, 1000),
+                inputSchema: shape,
+            }, async (args) => {
+                let urlPath = openapiPath;
+                for (const p of pathParamNames)
+                    urlPath = urlPath.replace(`{${p}}`, encodeURIComponent(String(args[p])));
+                const url = new URL(service.baseUrl + urlPath);
+                for (const p of queryParamNames) {
+                    const v = args[p];
+                    if (v !== undefined && v !== null)
+                        url.searchParams.set(p, String(v));
+                }
+                const headers = {};
+                if (API_KEY)
+                    headers["x-api-key"] = API_KEY;
+                const init = { method: method.toUpperCase(), headers };
+                if (bodyPropNames.length) {
+                    const bodyObj = {};
+                    for (const p of bodyPropNames)
+                        if (args[p] !== undefined)
+                            bodyObj[p] = args[p];
+                    headers["content-type"] = "application/json";
+                    init.body = JSON.stringify(bodyObj);
+                }
+                const r = await doFetch(url.toString(), init);
+                const text = await r.text();
+                let body;
+                try {
+                    body = JSON.parse(text);
+                }
+                catch {
+                    body = text;
+                }
+                return {
+                    isError: !r.ok,
+                    content: [{ type: "text", text: JSON.stringify(body, null, 2) }],
+                };
+            });
+            registered++;
+        }
+    }
+    return registered;
+}
+// --- Resources -----------------------------------------------------------
+// Reference material an agent can read without invoking a tool: the
+// platform-wide directory/llms.txt, and each service's live endpoint
+// catalog (the /v1/status we deliberately excluded from becoming a tool).
+function registerResources(server) {
+    server.registerResource("platform-services", "wickedapi://platform/services", {
+        title: "WickedAPI service directory",
+        description: "Every live WickedAPI service — URL, category, one-line description, auth modes, and links to each one's own OpenAPI spec/docs/llms.txt.",
+        mimeType: "application/json",
+    }, async (uri) => {
+        const r = await fetch(`${SHOWCASE_URL}/services.json`);
+        if (!r.ok)
+            throw new Error(`Failed to load service directory: HTTP ${r.status}`);
+        return { contents: [{ uri: uri.toString(), mimeType: "application/json", text: await r.text() }] };
+    });
+    server.registerResource("platform-llms-txt", "wickedapi://platform/llms", {
+        title: "WickedAPI llms.txt",
+        description: "Terse, platform-wide summary for agents deciding what to call — auth modes, free vs. paid endpoints.",
+        mimeType: "text/plain",
+    }, async (uri) => {
+        const r = await fetch(`${SHOWCASE_URL}/llms.txt`);
+        if (!r.ok)
+            throw new Error(`Failed to load llms.txt: HTTP ${r.status}`);
+        return { contents: [{ uri: uri.toString(), mimeType: "text/plain", text: await r.text() }] };
+    });
+    for (const service of SERVICES) {
+        server.registerResource(`${service.id}-status`, `wickedapi://${service.id}/status`, {
+            title: `${service.name} — live catalog`,
+            description: `Live endpoint catalog for ${service.name} (${service.baseUrl}), fetched fresh on every read.`,
+            mimeType: "application/json",
+        }, async (uri) => {
+            const r = await fetch(`${service.baseUrl}/v1/status`);
+            if (!r.ok)
+                throw new Error(`Failed to load ${service.name} status: HTTP ${r.status}`);
+            return { contents: [{ uri: uri.toString(), mimeType: "application/json", text: await r.text() }] };
         });
-        registered++;
     }
+}
+// --- Prompts ---------------------------------------------------------------
+// The "compound recipes" from the WickedAPI cookbook, turned into one-click
+// prompts: each just tells the assistant which real tools to call and how
+// to read the results — no fabricated synthesis, every number cited comes
+// from an actual tool call made during the conversation.
+function registerPrompts(server) {
+    server.registerPrompt("rug_check", {
+        title: "Rug-check before buying",
+        description: "Real on-chain risk signals for a token contract, plus market sentiment (and momentum, if it's a covered asset) before you decide whether to buy.",
+        argsSchema: {
+            address: z.string().describe("The token contract address (EVM) or mint address (Solana)."),
+            chain: z.string().describe("ethereum, bsc, base, polygon, arbitrum, optimism, avalanche, fantom, zksync, linea, scroll, or solana."),
+            symbol: z.string().optional().describe("If this token maps to a covered momentum-score asset (BTC, ETH, SOL, SUI, NVDA, IBIT, COIN, QQQ, TQQQ, DIA), pass it to also pull a real momentum verdict."),
+        },
+    }, ({ address, chain, symbol }) => ({
+        description: "Rug-check workflow",
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Before I consider buying this token, run a real risk check — don't guess or assume anything:\n\n` +
+                        `1. Call the \`token_risk\` tool with address="${address}" and chain="${chain}". Report the exact ` +
+                        `risk_score, risk_tier, and every real flag it returns (honeypot, mint/ownership authority, holder ` +
+                        `and LP concentration, buy/sell tax, trust-list status) — cite the actual values, don't summarize ` +
+                        `away the specifics or invent ones that weren't returned.\n` +
+                        `2. Call the \`sentiment\` tool for the current overall crypto market mood.\n` +
+                        (symbol
+                            ? `3. Call the \`momentum_score\` tool with symbol="${symbol}" and timeframe="1h" for a real technical read.\n`
+                            : "") +
+                        `\nThen give a plain verdict: the real risk signals found (listed, not paraphrased), current market ` +
+                        `mood, and — only if applicable — the momentum read. State clearly this is aggregated real signals, ` +
+                        `never a safety guarantee.`,
+                },
+            },
+        ],
+    }));
+    server.registerPrompt("vet_dependency", {
+        title: "Vet a DeFi dependency",
+        description: "Protocol activity/treasury health plus an optional contract-level risk check, before you build on a DeFi protocol.",
+        argsSchema: {
+            slug: z.string().describe('The protocol\'s DefiLlama slug, e.g. "lido".'),
+            token_address: z.string().optional().describe("The protocol's token contract address, if you also want a contract-level risk check."),
+            chain: z.string().optional().describe("Chain for token_address (default ethereum)."),
+        },
+    }, ({ slug, token_address, chain }) => ({
+        description: "Dependency-vetting workflow",
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Before I integrate this protocol as a dependency, check its real health — don't guess:\n\n` +
+                        `1. Call the \`protocol_health_score\` tool with slug="${slug}". Report the components (GitHub ` +
+                        `activity, TVL trend, treasury) exactly as returned, including any that came back null (never ` +
+                        `filled in).\n` +
+                        (token_address
+                            ? `2. Call the \`token_risk\` tool with address="${token_address}" and chain="${chain || "ethereum"}" ` +
+                                `for a contract-level check on its token.\n`
+                            : "") +
+                        `\nSummarize: is this protocol actively maintained, is its TVL trend healthy, and (if checked) does ` +
+                        `its token carry any real contract-level risk flags. Cite the real numbers.`,
+                },
+            },
+        ],
+    }));
+    server.registerPrompt("morning_briefing", {
+        title: "Morning briefing",
+        description: "One daily digest from macro calendar, earnings calendar, sentiment, and a momentum verdict — all free or a fraction of a cent.",
+        argsSchema: {
+            symbol: z.string().optional().describe("Asset for the momentum verdict (default BTC). One of BTC, ETH, SOL, SUI, NVDA, IBIT, COIN, QQQ, TQQQ, DIA."),
+        },
+    }, ({ symbol }) => {
+        const sym = symbol || "BTC";
+        return {
+            description: "Morning briefing workflow",
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: `Compile my morning briefing from real, current data — call each tool, don't estimate:\n\n` +
+                            `1. \`macro_calendar\` with days=7 — upcoming FOMC/CPI/jobs events.\n` +
+                            `2. \`earnings_calendar\` with days=3 — upcoming earnings reports.\n` +
+                            `3. \`sentiment\` — current crypto Fear & Greed reading.\n` +
+                            `4. \`momentum_score\` with symbol="${sym}" and timeframe="1D" — today's technical verdict.\n\n` +
+                            `Then write one concise digest combining all four, citing the real values from each call.`,
+                    },
+                },
+            ],
+        };
+    });
+}
+async function main() {
+    const server = new McpServer({ name: "wickedapi", version: "0.2.0" });
+    const doFetch = await buildFetcher();
+    let totalTools = 0;
+    const loaded = [];
+    for (const service of SERVICES) {
+        const doc = await loadServiceSpec(service);
+        if (!doc)
+            continue;
+        totalTools += registerServiceTools(server, service, doc, doFetch);
+        loaded.push(service.name);
+    }
+    if (totalTools === 0) {
+        throw new Error("No service specs loaded — check network access and WICKEDAPI_*_URL overrides.");
+    }
+    registerResources(server);
+    registerPrompts(server);
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error(`[wickedapi-mcp] ready — ${registered} tools loaded from ${BASE_URL}/openapi.json`);
+    console.error(`[wickedapi-mcp] ready — ${totalTools} tools across ${loaded.length} service(s) (${loaded.join(", ")}), ` +
+        `${2 + SERVICES.length} resources, 3 prompts.`);
 }
 main().catch((err) => {
     console.error("[wickedapi-mcp] fatal:", err);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "wickedapi-mcp",
-  "version": "0.1.0",
-  "description": "MCP server for WickedAPI — agent-ready trading & market-data API (crypto/stock prices, indicators, prediction markets, DeFi, macro, AI momentum score). No signup required: pay per call in USDC via x402, or use a partner API key.",
+  "version": "0.2.0",
+  "description": "MCP server for the whole WickedAPI platform — trading data, DeFi protocol health, token safety, and brokerage sync. 35 tools, 6 resources, 3 prompts. No signup required: pay per call in USDC via x402, or use a partner API key.",
   "type": "module",
   "bin": {
     "wickedapi-mcp": "dist/index.js"
@@ -31,6 +31,8 @@
     "crypto",
     "stocks",
     "market-data",
+    "defi",
+    "brokerage",
     "x402",
     "agent"
   ],