@c0pilot/mcp-polymarket 1.0.3 → 1.0.4

package/build/tools/index.js

@@ -2,6 +2,7 @@ import { registerMarketTools } from "./markets.js";
 import { registerOrderbookTools } from "./orderbook.js";
 import { registerAccountTools } from "./account.js";
 import { registerTradingTools } from "./trading.js";
+import { registerNewsTools } from "./news.js";
 export function registerAllTools(server, clientWrapper) {
     const isReadonly = clientWrapper.isReadonly();
     console.error(`Registering tools (readonly: ${isReadonly})`);
@@ -9,6 +10,7 @@ export function registerAllTools(server, clientWrapper) {
     registerMarketTools(server, clientWrapper);
     registerOrderbookTools(server, clientWrapper);
     registerAccountTools(server, clientWrapper);
+    registerNewsTools(server);
     // Register trading tools (write tools are conditionally included)
     registerTradingTools(server, clientWrapper, !isReadonly);
     console.error("All tools registered successfully");

package/build/tools/markets.js

@@ -7,13 +7,33 @@ const GetMarketsSchema = z.object({
 const GetMarketSchema = z.object({
     condition_id: z.string().optional(),
     slug: z.string().optional(),
+    url: z.string().optional(),
 });
+/**
+ * Gamma API sometimes returns array fields as JSON strings instead of arrays.
+ * e.g. clobTokenIds: '["abc","def"]' instead of ["abc","def"]
+ */
+function ensureArray(val) {
+    if (Array.isArray(val))
+        return val;
+    if (typeof val === "string") {
+        try {
+            const parsed = JSON.parse(val);
+            if (Array.isArray(parsed))
+                return parsed;
+        }
+        catch { /* not valid JSON */ }
+    }
+    return [];
+}
 async function fetchGammaMarkets(clientWrapper, limit, offset, search) {
     const baseUrl = clientWrapper.getGammaApiUrl();
     const params = new URLSearchParams({
         limit: limit.toString(),
         offset: offset.toString(),
         active: "true",
+        order: "volume24hr",
+        ascending: "false",
     });
     if (search) {
         params.set("slug_contains", search.toLowerCase());
@@ -54,30 +74,45 @@ async function fetchGammaMarketBySlug(clientWrapper, slug) {
         return null;
     return data[0];
 }
+/**
+ * Extract a Polymarket event slug from a URL.
+ * Handles: https://polymarket.com/event/slug, polymarket.com/event/slug?params, raw slug
+ */
+function extractSlugFromUrl(url) {
+    const match = url.match(/(?:polymarket\.com\/event\/)([^/?#]+)/);
+    return match ? match[1] : url.replace(/^\/+/, "");
+}
 function formatMarket(market) {
     const tokens = [];
-    const outcomes = market.outcomes || ["Yes", "No"];
-    const prices = market.outcomePrices || [];
-    const tokenIds = market.clobTokenIds || [];
-    for (let i = 0; i < outcomes.length; i++) {
+    const outcomes = ensureArray(market.outcomes);
+    const prices = ensureArray(market.outcomePrices);
+    const tokenIds = ensureArray(market.clobTokenIds);
+    // Fall back to ["Yes", "No"] if no outcomes
+    const outcomeNames = outcomes.length > 0 ? outcomes : ["Yes", "No"];
+    for (let i = 0; i < outcomeNames.length; i++) {
         tokens.push({
             token_id: tokenIds[i] || "",
-            outcome: outcomes[i],
+            outcome: outcomeNames[i],
             price: prices[i] ? parseFloat(prices[i]) : 0,
         });
     }
     return {
         condition_id: market.conditionId,
         question: market.question,
+        slug: market.slug,
+        url: market.slug ? `https://polymarket.com/event/${market.slug}` : undefined,
+        description: market.description ? market.description.slice(0, 500) : undefined,
         tokens,
         volume: market.volume || "0",
-        end_date: market.endDate || "",
+        liquidity: market.liquidityNum,
+        end_date: market.endDateIso || market.endDate || "",
         active: market.active,
         closed: market.closed,
+        accepting_orders: market.acceptingOrders,
     };
 }
 export function registerMarketTools(server, clientWrapper) {
-    server.tool("polymarket_get_markets", "List available prediction markets on Polymarket. Returns market question, current prices for Yes/No outcomes, and trading volume.", GetMarketsSchema.shape, async (args) => {
+    server.tool("polymarket_get_markets", "List available prediction markets on Polymarket, sorted by volume. Returns market question, current prices for Yes/No outcomes, token IDs, volume, liquidity, and Polymarket URL.", GetMarketsSchema.shape, async (args) => {
         try {
             const { limit, offset, search } = GetMarketsSchema.parse(args);
             const markets = await fetchGammaMarkets(clientWrapper, limit, offset, search);
@@ -104,17 +139,21 @@ export function registerMarketTools(server, clientWrapper) {
             };
         }
     });
-    server.tool("polymarket_get_market", `Get detailed information about a specific prediction market including token IDs, current prices, and market status.
+    server.tool("polymarket_get_market", `Get detailed information about a specific prediction market including token IDs, current prices, description, liquidity, and market status.
 
-Provide either condition_id or slug to look up a market.`, GetMarketSchema.shape, async (args) => {
+Provide one of: condition_id, slug, or a full Polymarket URL (e.g. https://polymarket.com/event/btc-updown-15m-1770647400).`, GetMarketSchema.shape, async (args) => {
         try {
-            const { condition_id, slug } = GetMarketSchema.parse(args);
+            let { condition_id, slug, url } = GetMarketSchema.parse(args);
+            // Extract slug from URL if provided
+            if (url) {
+                slug = extractSlugFromUrl(url);
+            }
             if (!condition_id && !slug) {
                 return {
                     content: [
                         {
                             type: "text",
-                            text: "Either condition_id or slug is required",
+                            text: "Provide one of: condition_id, slug, or url",
                         },
                     ],
                     isError: true,

package/build/tools/news.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerNewsTools(server: McpServer): void;

package/build/tools/news.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+const GetNewsSchema = z.object({
+    query: z.string().min(1).describe("News search query (e.g., 'Bitcoin price', 'Trump tariffs', 'NBA playoffs')"),
+    limit: z.number().min(1).max(10).optional().default(5),
+});
+/**
+ * Fetch news headlines from Google News RSS (free, no API key needed).
+ */
+async function fetchNewsHeadlines(query, maxResults) {
+    const encoded = encodeURIComponent(query);
+    const url = `https://news.google.com/rss/search?q=${encoded}&hl=en&gl=US&ceid=US:en`;
+    const response = await fetch(url, {
+        signal: AbortSignal.timeout(10_000),
+        headers: { "User-Agent": "Mozilla/5.0 (compatible; mcp-polymarket/1.0)" },
+    });
+    if (!response.ok) {
+        throw new Error(`Google News returned ${response.status}`);
+    }
+    const xml = await response.text();
+    return parseRssItems(xml, maxResults);
+}
+function parseRssItems(xml, maxResults) {
+    const headlines = [];
+    const itemRegex = /<item>([\s\S]*?)<\/item>/g;
+    let match;
+    while ((match = itemRegex.exec(xml)) !== null && headlines.length < maxResults) {
+        const item = match[1];
+        const title = extractTag(item, "title");
+        const source = extractTag(item, "source");
+        const pubDate = extractTag(item, "pubDate");
+        const link = extractTag(item, "link");
+        if (title) {
+            headlines.push({
+                title: decodeXmlEntities(title),
+                source: source || "Unknown",
+                pubDate: pubDate || "",
+                link: link || "",
+            });
+        }
+    }
+    return headlines;
+}
+function extractTag(xml, tag) {
+    const regex = new RegExp(`<${tag}[^>]*>(.*?)</${tag}>`, "s");
+    const match = xml.match(regex);
+    return match ? match[1] : null;
+}
+function decodeXmlEntities(text) {
+    return text
+        .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'");
+}
+export function registerNewsTools(server) {
+    server.tool("polymarket_get_news", "Fetch recent news headlines for a topic via Google News RSS. Useful for understanding current events and market context when analyzing prediction markets. No API key required.", GetNewsSchema.shape, async (args) => {
+        try {
+            const { query, limit } = GetNewsSchema.parse(args);
+            const headlines = await fetchNewsHeadlines(query, limit);
+            if (headlines.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No recent news found for "${query}"`,
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ count: headlines.length, headlines }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error fetching news: ${message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/build/types.d.ts

@@ -6,11 +6,16 @@ export interface TokenInfo {
 export interface MarketInfo {
     condition_id: string;
     question: string;
+    slug?: string;
+    url?: string;
+    description?: string;
     tokens: TokenInfo[];
     volume: string;
+    liquidity?: number;
     end_date: string;
     active: boolean;
     closed: boolean;
+    accepting_orders?: boolean;
 }
 export interface OrderbookEntry {
     price: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c0pilot/mcp-polymarket",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "MCP server and client library for Polymarket prediction markets - trade, browse markets, manage positions",
   "type": "module",
   "main": "./build/index.js",