pmxt-core 2.16.1 → 2.17.0

package/dist/BaseExchange.d.ts

@@ -272,7 +272,7 @@ export declare abstract class PredictionMarketExchange {
      * Events group related markets together (e.g., "Who will be Fed Chair?" contains multiple candidate markets).
      *
      * @param params - Optional parameters for search and filtering
-     * @param params.query - Search keyword to filter events (required)
+     * @param params.query - Search keyword to filter events. If omitted, returns top events by volume.
      * @param params.limit - Maximum number of results
      * @param params.offset - Pagination offset
      * @param params.searchIn - Where to search ('title' | 'description' | 'both')

package/dist/BaseExchange.js

@@ -242,7 +242,7 @@ class PredictionMarketExchange {
      * Events group related markets together (e.g., "Who will be Fed Chair?" contains multiple candidate markets).
      *
      * @param params - Optional parameters for search and filtering
-     * @param params.query - Search keyword to filter events (required)
+     * @param params.query - Search keyword to filter events. If omitted, returns top events by volume.
      * @param params.limit - Maximum number of results
      * @param params.offset - Pagination offset
      * @param params.searchIn - Where to search ('title' | 'description' | 'both')
@@ -261,10 +261,7 @@ class PredictionMarketExchange {
      * print(fed_event.title, len(fed_event.markets), 'markets')
      */
     async fetchEvents(params) {
-        if (!params?.query && !params?.eventId && !params?.slug) {
-            throw new Error("fetchEvents() requires a query, eventId, or slug parameter");
-        }
-        return this.fetchEventsImpl(params);
+        return this.fetchEventsImpl(params ?? {});
     }
     /**
      * Fetch a single market by lookup parameters.

package/dist/exchanges/kalshi/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-02-24T09:41:14.329Z
+ * Generated at: 2026-02-24T10:20:38.358Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const kalshiApiSpec: {

package/dist/exchanges/kalshi/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.kalshiApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-02-24T09:41:14.329Z
+ * Generated at: 2026-02-24T10:20:38.358Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.kalshiApiSpec = {

package/dist/exchanges/kalshi/fetchEvents.js

@@ -34,6 +34,52 @@ async function fetchEventByTicker(eventTicker, callApi) {
     };
     return [unifiedEvent];
 }
+function rawEventToUnified(event) {
+    const markets = [];
+    if (event.markets) {
+        for (const market of event.markets) {
+            const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market);
+            if (unifiedMarket) {
+                markets.push(unifiedMarket);
+            }
+        }
+    }
+    return {
+        id: event.event_ticker,
+        title: event.title,
+        description: event.mututals_description || "",
+        slug: event.event_ticker,
+        markets: markets,
+        url: `https://kalshi.com/events/${event.event_ticker}`,
+        image: event.image_url,
+        category: event.category,
+        tags: event.tags || [],
+    };
+}
+async function fetchAllWithStatus(callApi, apiStatus) {
+    let allEvents = [];
+    let cursor = null;
+    let page = 0;
+    const MAX_PAGES = 1000;
+    const BATCH_SIZE = 200;
+    do {
+        const queryParams = {
+            limit: BATCH_SIZE,
+            with_nested_markets: true,
+            status: apiStatus,
+        };
+        if (cursor)
+            queryParams.cursor = cursor;
+        const data = await callApi("GetEvents", queryParams);
+        const events = data.events || [];
+        if (events.length === 0)
+            break;
+        allEvents = allEvents.concat(events);
+        cursor = data.cursor;
+        page++;
+    } while (cursor && page < MAX_PAGES);
+    return allEvents;
+}
 async function fetchEvents(params, callApi) {
     try {
         // Handle eventId lookup (direct API call)
@@ -47,82 +93,64 @@ async function fetchEvents(params, callApi) {
         const status = params?.status || "active";
         const limit = params?.limit || 10000;
         const query = (params?.query || "").toLowerCase();
-        const fetchAllWithStatus = async (apiStatus) => {
-            let allEvents = [];
-            let cursor = null;
-            let page = 0;
-            const MAX_PAGES = 1000; // Safety cap against infinite loops
-            const BATCH_SIZE = 200; // Max limit per Kalshi API docs
-            do {
-                const queryParams = {
-                    limit: BATCH_SIZE,
-                    with_nested_markets: true,
-                    status: apiStatus,
-                };
-                if (cursor)
-                    queryParams.cursor = cursor;
-                const data = await callApi("GetEvents", queryParams);
-                const events = data.events || [];
-                if (events.length === 0)
-                    break;
-                allEvents = allEvents.concat(events);
-                cursor = data.cursor;
-                page++;
-                // If we have no search query and have fetched enough events, we can stop early
-                if (!query && allEvents.length >= limit * 1.5) {
-                    break;
-                }
-            } while (cursor && page < MAX_PAGES);
-            return allEvents;
-        };
         let events = [];
         if (status === "all") {
             const [openEvents, closedEvents, settledEvents] = await Promise.all([
-                fetchAllWithStatus("open"),
-                fetchAllWithStatus("closed"),
-                fetchAllWithStatus("settled"),
+                fetchAllWithStatus(callApi, "open"),
+                fetchAllWithStatus(callApi, "closed"),
+                fetchAllWithStatus(callApi, "settled"),
             ]);
             events = [...openEvents, ...closedEvents, ...settledEvents];
         }
         else if (status === "closed" || status === "inactive") {
             const [closedEvents, settledEvents] = await Promise.all([
-                fetchAllWithStatus("closed"),
-                fetchAllWithStatus("settled"),
+                fetchAllWithStatus(callApi, "closed"),
+                fetchAllWithStatus(callApi, "settled"),
             ]);
             events = [...closedEvents, ...settledEvents];
         }
         else {
-            events = await fetchAllWithStatus("open");
+            events = await fetchAllWithStatus(callApi, "open");
         }
-        const filtered = events.filter((event) => {
-            return (event.title || "").toLowerCase().includes(query);
-        });
-        const unifiedEvents = filtered.map((event) => {
-            const markets = [];
-            if (event.markets) {
-                for (const market of event.markets) {
-                    const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market);
-                    if (unifiedMarket) {
-                        markets.push(unifiedMarket);
-                    }
-                }
-            }
-            const unifiedEvent = {
-                id: event.event_ticker,
-                title: event.title,
-                description: event.mututals_description || "",
-                slug: event.event_ticker,
-                markets: markets,
-                url: `https://kalshi.com/events/${event.event_ticker}`,
-                image: event.image_url,
-                category: event.category,
-                tags: event.tags || [],
-            };
-            return unifiedEvent;
-        });
+        // Apply keyword filter if a query was provided
+        const filtered = query
+            ? events.filter((event) => (event.title || "").toLowerCase().includes(query))
+            : events;
+        // Client-side sort — Kalshi's /events endpoint has no sort param.
+        // We aggregate stats from nested markets and sort the full set before slicing.
+        const sort = params?.sort || "volume";
+        const sorted = sortRawEvents(filtered, sort);
+        const unifiedEvents = sorted.map(rawEventToUnified);
         return unifiedEvents.slice(0, limit);
     }
     catch (error) {
         throw errors_1.kalshiErrorMapper.mapError(error);
     }
 }
+function eventVolume(event) {
+    return (event.markets || []).reduce((sum, m) => sum + Number(m.volume || 0), 0);
+}
+function eventLiquidity(event) {
+    return (event.markets || []).reduce((sum, m) => sum + Number(m.open_interest || m.liquidity || 0), 0);
+}
+function eventNewest(event) {
+    // Use the earliest close_time across markets as a proxy for "newness"
+    const times = (event.markets || [])
+        .map((m) => (m.close_time ? new Date(m.close_time).getTime() : 0))
+        .filter((t) => t > 0);
+    return times.length > 0 ? Math.min(...times) : 0;
+}
+function sortRawEvents(events, sort) {
+    const copy = [...events];
+    if (sort === "newest") {
+        copy.sort((a, b) => eventNewest(b) - eventNewest(a));
+    }
+    else if (sort === "liquidity") {
+        copy.sort((a, b) => eventLiquidity(b) - eventLiquidity(a));
+    }
+    else {
+        // Default: volume
+        copy.sort((a, b) => eventVolume(b) - eventVolume(a));
+    }
+    return copy;
+}

package/dist/exchanges/limitless/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/limitless/Limitless.yaml
- * Generated at: 2026-02-24T09:41:14.367Z
+ * Generated at: 2026-02-24T10:20:38.402Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const limitlessApiSpec: {

package/dist/exchanges/limitless/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.limitlessApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/limitless/Limitless.yaml
- * Generated at: 2026-02-24T09:41:14.367Z
+ * Generated at: 2026-02-24T10:20:38.402Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.limitlessApiSpec = {

package/dist/exchanges/limitless/fetchEvents.js

@@ -32,15 +32,17 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchEvents = fetchEvents;
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
+const axios_1 = __importDefault(require("axios"));
 async function fetchEventBySlug(slug) {
     const { HttpClient, MarketFetcher } = await Promise.resolve().then(() => __importStar(require('@limitless-exchange/sdk')));
     const httpClient = new HttpClient({ baseURL: utils_1.LIMITLESS_API_URL });
-    // TODO: Ideally inject http into HttpClient if supported, but SDK abstracts it.
-    // For now, single market fetch uses SDK's internal client.
     const marketFetcher = new MarketFetcher(httpClient);
     const market = await marketFetcher.getMarket(slug);
     if (!market)
@@ -68,6 +70,30 @@ async function fetchEventBySlug(slug) {
         tags: market.tags || []
     };
 }
+function rawMarketToEvent(market) {
+    let marketsList = [];
+    if (market.markets && Array.isArray(market.markets)) {
+        marketsList = market.markets
+            .map((child) => (0, utils_1.mapMarketToUnified)(child))
+            .filter((m) => m !== null);
+    }
+    else {
+        const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
+        if (unifiedMarket)
+            marketsList = [unifiedMarket];
+    }
+    return {
+        id: market.slug,
+        title: market.title || market.question,
+        description: market.description || '',
+        slug: market.slug,
+        markets: marketsList,
+        url: `https://limitless.exchange/markets/${market.slug}`,
+        image: market.logo || `https://limitless.exchange/api/og?slug=${market.slug}`,
+        category: market.categories?.[0],
+        tags: market.tags || []
+    };
+}
 async function fetchEvents(params, callApi) {
     try {
         // Handle eventId/slug lookup (same thing for Limitless)
@@ -76,52 +102,66 @@ async function fetchEvents(params, callApi) {
             const event = await fetchEventBySlug(slug);
             return event ? [event] : [];
         }
-        // NOTE: The Limitless /markets/search endpoint currently only returns active/funded markets.
-        // It does not include expired or resolved markets in search results.
-        // Consequently, status 'inactive' will likely return 0 results and 'all' will only show active markets.
-        const data = await callApi('MarketSearchController_search', {
-            query: params.query,
-            limit: params?.limit || 10000,
-            similarityThreshold: 0.5,
-        });
-        let markets = data?.markets || [];
-        // Filter by status based on expired/resolved state
-        // Active: not expired and not resolved
-        // Inactive: expired OR resolved (has winningOutcomeIndex)
-        const status = params?.status || 'active';
-        if (status === 'active') {
-            markets = markets.filter((m) => !m.expired && m.winningOutcomeIndex === null);
-        }
-        else if (status === 'inactive' || status === 'closed') {
-            markets = markets.filter((m) => m.expired === true || m.winningOutcomeIndex !== null);
+        // Query-based search: use the /markets/search endpoint
+        if (params.query) {
+            return await searchEvents(params, callApi);
         }
-        // If status === 'all', don't filter
-        return markets.map((market) => {
-            let marketsList = [];
-            if (market.markets && Array.isArray(market.markets)) {
-                marketsList = market.markets
-                    .map((child) => (0, utils_1.mapMarketToUnified)(child))
-                    .filter((m) => m !== null);
-            }
-            else {
-                const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
-                if (unifiedMarket)
-                    marketsList = [unifiedMarket];
-            }
-            return {
-                id: market.slug,
-                title: market.title || market.question,
-                description: market.description || '',
-                slug: market.slug,
-                markets: marketsList,
-                url: `https://limitless.exchange/markets/${market.slug}`,
-                image: market.logo || `https://limitless.exchange/api/og?slug=${market.slug}`,
-                category: market.categories?.[0],
-                tags: market.tags || []
-            };
-        });
+        // Default: fetch active group markets from /markets/active
+        // On Limitless, "events" = group markets (tradeType === 'group')
+        return await fetchEventsDefault(params);
     }
     catch (error) {
         throw errors_1.limitlessErrorMapper.mapError(error);
     }
 }
+async function searchEvents(params, callApi) {
+    // NOTE: The Limitless /markets/search endpoint currently only returns active/funded markets.
+    const data = await callApi('MarketSearchController_search', {
+        query: params.query,
+        limit: params?.limit || 10000,
+        similarityThreshold: 0.5,
+    });
+    let markets = data?.markets || [];
+    const status = params?.status || 'active';
+    if (status === 'active') {
+        markets = markets.filter((m) => !m.expired && m.winningOutcomeIndex === null);
+    }
+    else if (status === 'inactive' || status === 'closed') {
+        markets = markets.filter((m) => m.expired === true || m.winningOutcomeIndex !== null);
+    }
+    return markets.map(rawMarketToEvent);
+}
+async function fetchEventsDefault(params) {
+    // Limitless has no dedicated /events endpoint.
+    // Group markets (tradeType === 'group') are the semantic equivalent of events.
+    // We use GET /markets/active and filter for groups only.
+    const limit = params?.limit || 10000;
+    let page = 1;
+    const pageSize = 25; // Limitless API hard limit
+    const MAX_PAGES = 40; // Safety cap
+    const allGroups = [];
+    while (allGroups.length < limit && page <= MAX_PAGES) {
+        const response = await axios_1.default.get(`${utils_1.LIMITLESS_API_URL}/markets/active`, {
+            params: {
+                page,
+                limit: pageSize,
+                tradeType: 'group',
+                sortBy: params?.sort === 'newest' ? 'newest' : params?.sort === 'liquidity' ? 'lp_rewards' : 'high_value',
+            }
+        });
+        const items = response.data?.data || response.data || [];
+        if (items.length === 0)
+            break;
+        for (const item of items) {
+            if (allGroups.length >= limit)
+                break;
+            const event = rawMarketToEvent(item);
+            allGroups.push(event);
+        }
+        // If the page returned fewer items than the page size, we've reached the end
+        if (items.length < pageSize)
+            break;
+        page++;
+    }
+    return allGroups;
+}

package/dist/exchanges/myriad/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/myriad/myriad.yaml
- * Generated at: 2026-02-24T09:41:14.379Z
+ * Generated at: 2026-02-24T10:20:38.413Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const myriadApiSpec: {

package/dist/exchanges/myriad/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.myriadApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/myriad/myriad.yaml
- * Generated at: 2026-02-24T09:41:14.379Z
+ * Generated at: 2026-02-24T10:20:38.413Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.myriadApiSpec = {

package/dist/exchanges/polymarket/api-clob.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-02-24T09:41:14.335Z
+ * Generated at: 2026-02-24T10:20:38.367Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketClobSpec: {

package/dist/exchanges/polymarket/api-clob.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketClobSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-02-24T09:41:14.335Z
+ * Generated at: 2026-02-24T10:20:38.367Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketClobSpec = {

package/dist/exchanges/polymarket/api-data.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-02-24T09:41:14.348Z
+ * Generated at: 2026-02-24T10:20:38.384Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketDataSpec: {

package/dist/exchanges/polymarket/api-data.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketDataSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-02-24T09:41:14.348Z
+ * Generated at: 2026-02-24T10:20:38.384Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketDataSpec = {

package/dist/exchanges/polymarket/api-gamma.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-02-24T09:41:14.345Z
+ * Generated at: 2026-02-24T10:20:38.380Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketGammaSpec: {

package/dist/exchanges/polymarket/api-gamma.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketGammaSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-02-24T09:41:14.345Z
+ * Generated at: 2026-02-24T10:20:38.380Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketGammaSpec = {

package/dist/exchanges/polymarket/fetchEvents.js

@@ -7,36 +7,32 @@ exports.fetchEvents = fetchEvents;
 const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
+function mapRawEventToUnified(event) {
+    const markets = [];
+    if (event.markets && Array.isArray(event.markets)) {
+        for (const market of event.markets) {
+            const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market, { useQuestionAsCandidateFallback: true });
+            if (unifiedMarket) {
+                markets.push(unifiedMarket);
+            }
+        }
+    }
+    return {
+        id: event.id || event.slug,
+        title: event.title,
+        description: event.description || '',
+        slug: event.slug,
+        markets: markets,
+        url: `https://polymarket.com/event/${event.slug}`,
+        image: event.image || `https://polymarket.com/api/og?slug=${event.slug}`,
+        category: event.category || event.tags?.[0]?.label,
+        tags: event.tags?.map((t) => t.label) || []
+    };
+}
 async function fetchEvents(params, http = axios_1.default) {
     try {
-        if (!params.query && !params.eventId && !params.slug) {
-            throw new Error("Query, eventId, or slug is required for Polymarket event search");
-        }
         const limit = params.limit || 10000;
-        const status = params.status || 'active';
-        // Helper to map a raw event to a UnifiedEvent
-        const mapRawEventToUnified = (event) => {
-            const markets = [];
-            if (event.markets && Array.isArray(event.markets)) {
-                for (const market of event.markets) {
-                    const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market, { useQuestionAsCandidateFallback: true });
-                    if (unifiedMarket) {
-                        markets.push(unifiedMarket);
-                    }
-                }
-            }
-            return {
-                id: event.id || event.slug,
-                title: event.title,
-                description: event.description || '',
-                slug: event.slug,
-                markets: markets,
-                url: `https://polymarket.com/event/${event.slug}`,
-                image: event.image || `https://polymarket.com/api/og?slug=${event.slug}`,
-                category: event.category || event.tags?.[0]?.label,
-                tags: event.tags?.map((t) => t.label) || []
-            };
-        };
+        // Handle eventId or slug lookup (direct API call)
         if (params.eventId || params.slug) {
             const queryParams = params.eventId ? { id: params.eventId } : { slug: params.slug };
             const response = await http.get(utils_1.GAMMA_API_URL, { params: queryParams });
@@ -45,68 +41,92 @@ async function fetchEvents(params, http = axios_1.default) {
                 return [];
             return events.map(mapRawEventToUnified).slice(0, limit);
         }
-        let sortParam = 'volume';
-        if (params.sort === 'newest')
-            sortParam = 'startDate';
-        if (params.sort === 'liquidity')
-            sortParam = 'liquidity';
-        const queryParams = {
-            q: params.query,
-            limit_per_type: 50,
-            sort: sortParam,
-            ascending: false
-        };
-        const fetchWithStatus = async (eventStatus) => {
-            const currentParams = { ...queryParams, events_status: eventStatus };
-            return (0, utils_1.paginateSearchParallel)(utils_1.GAMMA_SEARCH_URL, currentParams, limit * 10, http);
-        };
-        // Client-side filtering logic
-        // The API returns active events when querying for 'closed' status sometimes.
-        // We must strictly filter based on the event's `active` and `closed` properties.
-        const filterActive = (e) => e.active === true;
-        const filterClosed = (e) => e.closed === true;
-        let events = [];
-        if (status === 'all') {
-            const [activeEvents, closedEvents] = await Promise.all([
-                fetchWithStatus('active'),
-                fetchWithStatus('closed')
-            ]);
-            // Merge and de-duplicate by ID
-            const seenIds = new Set();
-            events = [...activeEvents, ...closedEvents].filter(event => {
-                const id = event.id || event.slug;
-                if (seenIds.has(id))
-                    return false;
-                seenIds.add(id);
-                return true;
-            });
-        }
-        else if (status === 'active') {
-            const rawEvents = await fetchWithStatus('active');
-            events = rawEvents.filter(filterActive);
+        // Handle query-based search (uses the /public-search endpoint)
+        if (params.query) {
+            return await searchEvents(params, limit, http);
         }
-        else if (status === 'inactive' || status === 'closed') {
-            // Polymarket sometimes returns active events when querying for closed
-            // So we fetch 'closed' but strictly filter
-            const rawEvents = await fetchWithStatus('closed');
-            events = rawEvents.filter(filterClosed);
-        }
-        // Client-side filtering to ensure title matches (API does fuzzy search)
-        const lowerQuery = params.query.toLowerCase();
-        const searchIn = params.searchIn || 'title';
-        const filteredEvents = events.filter((event) => {
-            const titleMatch = (event.title || '').toLowerCase().includes(lowerQuery);
-            const descMatch = (event.description || '').toLowerCase().includes(lowerQuery);
-            if (searchIn === 'title')
-                return titleMatch;
-            if (searchIn === 'description')
-                return descMatch;
-            return titleMatch || descMatch; // 'both'
-        });
-        const unifiedEvents = filteredEvents.map(mapRawEventToUnified);
-        return unifiedEvents.slice(0, limit);
+        // Default: fetch top events list from the Gamma /events endpoint (no query required)
+        return await fetchEventsDefault(params, limit, http);
     }
     catch (error) {
         throw errors_1.polymarketErrorMapper.mapError(error);
     }
 }
+async function searchEvents(params, limit, http) {
+    let sortParam = 'volume';
+    if (params.sort === 'newest')
+        sortParam = 'startDate';
+    if (params.sort === 'liquidity')
+        sortParam = 'liquidity';
+    const queryParams = {
+        q: params.query,
+        limit_per_type: 50,
+        sort: sortParam,
+        ascending: false
+    };
+    const status = params.status || 'active';
+    const fetchWithStatus = async (eventStatus) => {
+        const currentParams = { ...queryParams, events_status: eventStatus };
+        return (0, utils_1.paginateSearchParallel)(utils_1.GAMMA_SEARCH_URL, currentParams, limit * 10, http);
+    };
+    const filterActive = (e) => e.active === true;
+    const filterClosed = (e) => e.closed === true;
+    let events = [];
+    if (status === 'all') {
+        const [activeEvents, closedEvents] = await Promise.all([
+            fetchWithStatus('active'),
+            fetchWithStatus('closed')
+        ]);
+        const seenIds = new Set();
+        events = [...activeEvents, ...closedEvents].filter(event => {
+            const id = event.id || event.slug;
+            if (seenIds.has(id))
+                return false;
+            seenIds.add(id);
+            return true;
+        });
+    }
+    else if (status === 'active') {
+        const rawEvents = await fetchWithStatus('active');
+        events = rawEvents.filter(filterActive);
+    }
+    else if (status === 'inactive' || status === 'closed') {
+        const rawEvents = await fetchWithStatus('closed');
+        events = rawEvents.filter(filterClosed);
+    }
+    const lowerQuery = params.query.toLowerCase();
+    const searchIn = params.searchIn || 'title';
+    const filteredEvents = events.filter((event) => {
+        const titleMatch = (event.title || '').toLowerCase().includes(lowerQuery);
+        const descMatch = (event.description || '').toLowerCase().includes(lowerQuery);
+        if (searchIn === 'title')
+            return titleMatch;
+        if (searchIn === 'description')
+            return descMatch;
+        return titleMatch || descMatch;
+    });
+    return filteredEvents.map(mapRawEventToUnified).slice(0, limit);
+}
+async function fetchEventsDefault(params, limit, http) {
+    const status = params.status || 'active';
+    let sortParam = 'volume';
+    if (params.sort === 'newest')
+        sortParam = 'startDate';
+    else if (params.sort === 'liquidity')
+        sortParam = 'liquidity';
+    const queryParams = {
+        order: sortParam,
+        ascending: false,
+    };
+    if (status === 'active') {
+        queryParams.active = 'true';
+        queryParams.closed = 'false';
+    }
+    else if (status === 'closed' || status === 'inactive') {
+        queryParams.active = 'false';
+        queryParams.closed = 'true';
+    }
+    // 'all' — no status filter applied
+    const events = await (0, utils_1.paginateParallel)(utils_1.GAMMA_API_URL, queryParams, http, limit);
+    return events.map(mapRawEventToUnified).slice(0, limit);
+}

package/dist/exchanges/probable/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-02-24T09:41:14.372Z
+ * Generated at: 2026-02-24T10:20:38.408Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const probableApiSpec: {

package/dist/exchanges/probable/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.probableApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-02-24T09:41:14.372Z
+ * Generated at: 2026-02-24T10:20:38.408Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.probableApiSpec = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmxt-core",
-  "version": "2.16.1",
+  "version": "2.17.0",
   "description": "pmxt is a unified prediction market data API. The ccxt for prediction markets.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,8 +29,8 @@
     "test": "jest -c jest.config.js",
     "server": "tsx watch src/server/index.ts",
     "server:prod": "node dist/server/index.js",
-    "generate:sdk:python": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g python -o ../sdks/python/generated --package-name pmxt_internal --additional-properties=projectName=pmxt-internal,packageVersion=2.16.1,library=urllib3",
-    "generate:sdk:typescript": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g typescript-fetch -o ../sdks/typescript/generated --additional-properties=npmName=pmxtjs,npmVersion=2.16.1,supportsES6=true,typescriptThreePlus=true && node ../sdks/typescript/scripts/fix-generated.js",
+    "generate:sdk:python": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g python -o ../sdks/python/generated --package-name pmxt_internal --additional-properties=projectName=pmxt-internal,packageVersion=2.17.0,library=urllib3",
+    "generate:sdk:typescript": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g typescript-fetch -o ../sdks/typescript/generated --additional-properties=npmName=pmxtjs,npmVersion=2.17.0,supportsES6=true,typescriptThreePlus=true && node ../sdks/typescript/scripts/fix-generated.js",
     "fetch:openapi": "node scripts/fetch-openapi-specs.js",
     "extract:jsdoc": "node ../scripts/extract-jsdoc.js",
     "generate:docs": "npm run extract:jsdoc && node ../scripts/generate-api-docs.js",