pmxt 1.4.1__py3-none-any.whl → 1.5.1__py3-none-any.whl

pmxt/__init__.py

@@ -16,7 +16,7 @@ Example:
     >>> print(markets[0].title)
 """
 
-from .client import Polymarket, Kalshi, Exchange
+from .client import Polymarket, Kalshi, Limitless, Exchange
 from .server_manager import ServerManager
 from .models import (
     UnifiedMarket,
@@ -33,11 +33,12 @@ from .models import (
     CreateOrderParams,
 )
 
-__version__ = "1.4.1"
+__version__ = "1.5.1"
 __all__ = [
     # Exchanges
     "Polymarket",
     "Kalshi",
+    "Limitless",
     "Exchange",
     # Server Management
     "ServerManager",

pmxt/_server/server/bundled.js

@@ -104839,6 +104839,798 @@ var require_polymarket = __commonJS({
           throw new Error("Price is required for limit orders");
         }
         const price = params.price || (side === clob_client_1.Side.BUY ? 0.99 : 0.01);
+        let tickSize;
+        if (params.tickSize) {
+          tickSize = params.tickSize.toString();
+        } else {
+          try {
+            const orderBook = await this.fetchOrderBook(params.outcomeId);
+            tickSize = this.inferTickSize(orderBook);
+          } catch (error) {
+            tickSize = "0.01";
+          }
+        }
+        try {
+          const response = await client.createAndPostOrder({
+            tokenID: params.outcomeId,
+            price,
+            side,
+            size: params.amount,
+            feeRateBps: 0
+          }, {
+            tickSize
+          });
+          if (!response || !response.success) {
+            throw new Error(response?.errorMsg || "Order placement failed");
+          }
+          return {
+            id: response.orderID,
+            marketId: params.marketId,
+            outcomeId: params.outcomeId,
+            side: params.side,
+            type: params.type,
+            price,
+            amount: params.amount,
+            status: "open",
+            filled: 0,
+            remaining: params.amount,
+            timestamp: Date.now()
+          };
+        } catch (error) {
+          throw error;
+        }
+      }
+      /**
+       * Infer the tick size from order book price levels.
+       * Analyzes the decimal precision of existing orders to determine the market's tick size.
+       */
+      inferTickSize(orderBook) {
+        const allPrices = [
+          ...orderBook.bids.map((b) => b.price),
+          ...orderBook.asks.map((a) => a.price)
+        ];
+        if (allPrices.length === 0) {
+          return "0.01";
+        }
+        let minIncrement = 1;
+        for (const price of allPrices) {
+          const priceStr = price.toString();
+          const decimalPart = priceStr.split(".")[1];
+          if (decimalPart) {
+            const decimals = decimalPart.length;
+            const increment = Math.pow(10, -decimals);
+            if (increment < minIncrement) {
+              minIncrement = increment;
+            }
+          }
+        }
+        if (minIncrement >= 0.1)
+          return "0.1";
+        if (minIncrement >= 0.01)
+          return "0.01";
+        if (minIncrement >= 1e-3)
+          return "0.001";
+        return "0.0001";
+      }
+      async cancelOrder(orderId) {
+        const auth = this.ensureAuth();
+        const client = await auth.getClobClient();
+        try {
+          await client.cancelOrder({ orderID: orderId });
+          return {
+            id: orderId,
+            marketId: "unknown",
+            outcomeId: "unknown",
+            side: "buy",
+            type: "limit",
+            amount: 0,
+            status: "cancelled",
+            filled: 0,
+            remaining: 0,
+            timestamp: Date.now()
+          };
+        } catch (error) {
+          throw error;
+        }
+      }
+      async fetchOrder(orderId) {
+        const auth = this.ensureAuth();
+        const client = await auth.getClobClient();
+        try {
+          const order = await client.getOrder(orderId);
+          return {
+            id: order.id,
+            marketId: order.market || "unknown",
+            outcomeId: order.asset_id,
+            side: order.side.toLowerCase(),
+            type: order.order_type === "GTC" ? "limit" : "market",
+            price: parseFloat(order.price),
+            amount: parseFloat(order.original_size),
+            status: order.status,
+            // Needs precise mapping
+            filled: parseFloat(order.size_matched),
+            remaining: parseFloat(order.original_size) - parseFloat(order.size_matched),
+            timestamp: order.created_at * 1e3
+          };
+        } catch (error) {
+          throw error;
+        }
+      }
+      async fetchOpenOrders(marketId) {
+        const auth = this.ensureAuth();
+        const client = await auth.getClobClient();
+        try {
+          const orders = await client.getOpenOrders({
+            market: marketId
+          });
+          return orders.map((o) => ({
+            id: o.id,
+            marketId: o.market || "unknown",
+            outcomeId: o.asset_id,
+            side: o.side.toLowerCase(),
+            type: "limit",
+            price: parseFloat(o.price),
+            amount: parseFloat(o.original_size),
+            status: "open",
+            filled: parseFloat(o.size_matched),
+            remaining: parseFloat(o.size_left || parseFloat(o.original_size) - parseFloat(o.size_matched)),
+            timestamp: o.created_at * 1e3
+          }));
+        } catch (error) {
+          console.error("Error fetching Polymarket open orders:", error);
+          return [];
+        }
+      }
+      async fetchPositions() {
+        const auth = this.ensureAuth();
+        const address = auth.getAddress();
+        return (0, fetchPositions_1.fetchPositions)(address);
+      }
+      async fetchBalance() {
+        const auth = this.ensureAuth();
+        const client = await auth.getClobClient();
+        try {
+          const USDC_DECIMALS = 6;
+          const balRes = await client.getBalanceAllowance({
+            asset_type: clob_client_1.AssetType.COLLATERAL
+          });
+          const rawBalance = parseFloat(balRes.balance);
+          const total = rawBalance / Math.pow(10, USDC_DECIMALS);
+          const openOrders = await client.getOpenOrders({});
+          let locked = 0;
+          if (openOrders && Array.isArray(openOrders)) {
+            for (const order of openOrders) {
+              if (order.side === clob_client_1.Side.BUY) {
+                const remainingSize = parseFloat(order.original_size) - parseFloat(order.size_matched);
+                const price = parseFloat(order.price);
+                locked += remainingSize * price;
+              }
+            }
+          }
+          return [{
+            currency: "USDC",
+            total,
+            available: total - locked,
+            // Available for new trades
+            locked
+          }];
+        } catch (error) {
+          throw error;
+        }
+      }
+      async watchOrderBook(id, limit) {
+        if (!this.ws) {
+          this.ws = new websocket_1.PolymarketWebSocket(this.wsConfig);
+        }
+        return this.ws.watchOrderBook(id);
+      }
+      async watchTrades(id, since, limit) {
+        if (!this.ws) {
+          this.ws = new websocket_1.PolymarketWebSocket(this.wsConfig);
+        }
+        return this.ws.watchTrades(id);
+      }
+      async close() {
+        if (this.ws) {
+          this.ws.close();
+          this.ws = void 0;
+        }
+      }
+    };
+    exports2.PolymarketExchange = PolymarketExchange;
+  }
+});
+
+// dist/exchanges/limitless/utils.js
+var require_utils10 = __commonJS({
+  "dist/exchanges/limitless/utils.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LIMITLESS_API_URL = void 0;
+    exports2.mapMarketToUnified = mapMarketToUnified;
+    exports2.mapIntervalToFidelity = mapIntervalToFidelity;
+    var market_utils_1 = require_market_utils();
+    exports2.LIMITLESS_API_URL = "https://api.limitless.exchange";
+    function mapMarketToUnified(market) {
+      if (!market)
+        return null;
+      const outcomes = [];
+      if (market.tokens && market.prices) {
+        const tokenEntries = Object.entries(market.tokens);
+        tokenEntries.forEach(([label, tokenId], index) => {
+          const outcomePrice = market.prices[index] || 0;
+          outcomes.push({
+            id: tokenId,
+            label: label.charAt(0).toUpperCase() + label.slice(1),
+            // Capitalize 'yes'/'no'
+            price: outcomePrice,
+            priceChange24h: 0,
+            // Not directly available in this flat list, can be computed if needed
+            metadata: {
+              clobTokenId: tokenId
+            }
+          });
+        });
+      }
+      const um = {
+        id: market.slug,
+        title: market.title || market.question,
+        description: market.description,
+        outcomes,
+        resolutionDate: market.expirationTimestamp ? new Date(market.expirationTimestamp) : /* @__PURE__ */ new Date(),
+        volume24h: Number(market.volumeFormatted || 0),
+        volume: Number(market.volume || 0),
+        liquidity: 0,
+        // Not directly in the flat market list
+        openInterest: 0,
+        // Not directly in the flat market list
+        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 || []
+      };
+      (0, market_utils_1.addBinaryOutcomes)(um);
+      return um;
+    }
+    function mapIntervalToFidelity(interval) {
+      const mapping = {
+        "1m": 1,
+        "5m": 5,
+        "15m": 15,
+        "1h": 60,
+        "6h": 360,
+        "1d": 1440
+      };
+      return mapping[interval];
+    }
+  }
+});
+
+// dist/exchanges/limitless/fetchMarkets.js
+var require_fetchMarkets2 = __commonJS({
+  "dist/exchanges/limitless/fetchMarkets.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.fetchMarkets = fetchMarkets;
+    var axios_1 = __importDefault(require_axios());
+    var utils_1 = require_utils10();
+    async function fetchMarkets(params) {
+      const limit = params?.limit || 200;
+      const offset = params?.offset || 0;
+      const url2 = `${utils_1.LIMITLESS_API_URL}/markets/active`;
+      try {
+        const response = await axios_1.default.get(url2);
+        const markets = response.data?.data || response.data;
+        if (!markets || !Array.isArray(markets)) {
+          return [];
+        }
+        const unifiedMarkets = [];
+        for (const market of markets) {
+          const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
+          if (unifiedMarket) {
+            unifiedMarkets.push(unifiedMarket);
+          }
+        }
+        if (params?.sort === "volume") {
+          unifiedMarkets.sort((a, b) => (b.volume ?? 0) - (a.volume ?? 0));
+        } else {
+          unifiedMarkets.sort((a, b) => (b.volume ?? 0) - (a.volume ?? 0));
+        }
+        return unifiedMarkets.slice(offset, offset + limit);
+      } catch (error) {
+        console.error("Error fetching Limitless markets:", error.message);
+        return [];
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/searchMarkets.js
+var require_searchMarkets2 = __commonJS({
+  "dist/exchanges/limitless/searchMarkets.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.searchMarkets = searchMarkets;
+    var axios_1 = __importDefault(require_axios());
+    var utils_1 = require_utils10();
+    async function searchMarkets(query, params) {
+      try {
+        const response = await axios_1.default.get(`${utils_1.LIMITLESS_API_URL}/markets/search`, {
+          params: {
+            query,
+            limit: params?.limit || 20
+          }
+        });
+        const markets = response.data?.markets || [];
+        return markets.map((m) => (0, utils_1.mapMarketToUnified)(m)).filter((m) => m !== null).slice(0, params?.limit || 20);
+      } catch (error) {
+        console.error("Error searching Limitless data:", error.message);
+        return [];
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/searchEvents.js
+var require_searchEvents2 = __commonJS({
+  "dist/exchanges/limitless/searchEvents.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.searchEvents = searchEvents;
+    var axios_1 = __importDefault(require_axios());
+    var utils_1 = require_utils10();
+    async function searchEvents(query, params) {
+      try {
+        const response = await axios_1.default.get(`${utils_1.LIMITLESS_API_URL}/markets/search`, {
+          params: {
+            query,
+            limit: params?.limit || 20
+          }
+        });
+        const markets = response.data?.markets || [];
+        return markets.map((market) => {
+          const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
+          const marketsList = unifiedMarket ? [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 || [],
+            searchMarkets: function(marketQuery) {
+              const lowerMarketQuery = marketQuery.toLowerCase();
+              return this.markets.filter((m) => m.title.toLowerCase().includes(lowerMarketQuery) || m.description.toLowerCase().includes(lowerMarketQuery));
+            }
+          };
+        });
+      } catch (error) {
+        console.error("Error searching Limitless events:", error.message);
+        return [];
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/getMarketsBySlug.js
+var require_getMarketsBySlug2 = __commonJS({
+  "dist/exchanges/limitless/getMarketsBySlug.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getMarketsBySlug = getMarketsBySlug;
+    var axios_1 = __importDefault(require_axios());
+    var utils_1 = require_utils10();
+    async function getMarketsBySlug(slug) {
+      try {
+        const response = await axios_1.default.get(`${utils_1.LIMITLESS_API_URL}/markets/${slug}`);
+        const market = response.data;
+        if (!market)
+          return [];
+        const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
+        return unifiedMarket ? [unifiedMarket] : [];
+      } catch (error) {
+        console.error(`Error fetching Limitless slug ${slug}:`, error.message);
+        return [];
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/fetchOHLCV.js
+var require_fetchOHLCV2 = __commonJS({
+  "dist/exchanges/limitless/fetchOHLCV.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.fetchOHLCV = fetchOHLCV;
+    var axios_1 = __importDefault(require_axios());
+    var utils_1 = require_utils10();
+    async function fetchOHLCV(id, params) {
+      try {
+        const fidelity = (0, utils_1.mapIntervalToFidelity)(params.resolution);
+        const url2 = `${utils_1.LIMITLESS_API_URL}/markets/${id}/historical-price`;
+        const response = await axios_1.default.get(url2, {
+          params: { fidelity }
+        });
+        const data = response.data;
+        const prices = data.prices || [];
+        let candles = prices.map((p) => {
+          const price = Number(p.price);
+          const ts = Number(p.timestamp);
+          return {
+            timestamp: ts,
+            open: price,
+            high: price,
+            low: price,
+            close: price,
+            volume: 0
+            // Volume not provided in this specific endpoint
+          };
+        }).sort((a, b) => a.timestamp - b.timestamp);
+        if (params.start) {
+          candles = candles.filter((c) => c.timestamp >= params.start.getTime());
+        }
+        if (params.end) {
+          candles = candles.filter((c) => c.timestamp <= params.end.getTime());
+        }
+        if (params.limit) {
+          candles = candles.slice(0, params.limit);
+        }
+        return candles;
+      } catch (error) {
+        console.error(`Error fetching Limitless history for ${id}:`, error.message);
+        return [];
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/fetchOrderBook.js
+var require_fetchOrderBook2 = __commonJS({
+  "dist/exchanges/limitless/fetchOrderBook.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.fetchOrderBook = fetchOrderBook;
+    var axios_1 = __importDefault(require_axios());
+    var utils_1 = require_utils10();
+    async function fetchOrderBook(id) {
+      try {
+        const url2 = `${utils_1.LIMITLESS_API_URL}/markets/${id}/orderbook`;
+        const response = await axios_1.default.get(url2);
+        const data = response.data;
+        const bids = (data.bids || []).map((level) => ({
+          price: parseFloat(level.price),
+          size: parseFloat(level.size)
+        })).sort((a, b) => b.price - a.price);
+        const asks = (data.asks || []).map((level) => ({
+          price: parseFloat(level.price),
+          size: parseFloat(level.size)
+        })).sort((a, b) => a.price - b.price);
+        return {
+          bids,
+          asks,
+          timestamp: Date.now()
+          // API doesn't seem to return a specific timestamp in the root anymore
+        };
+      } catch (error) {
+        console.error(`Error fetching Limitless orderbook for ${id}:`, error.message);
+        return { bids: [], asks: [] };
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/fetchTrades.js
+var require_fetchTrades2 = __commonJS({
+  "dist/exchanges/limitless/fetchTrades.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.fetchTrades = fetchTrades;
+    var axios_1 = __importDefault(require_axios());
+    var utils_1 = require_utils10();
+    async function fetchTrades(id, params) {
+      try {
+        const url2 = `${utils_1.LIMITLESS_API_URL}/portfolio/trades`;
+        const requestParams = {
+          limit: params.limit || 100
+        };
+        if (params.start) {
+          requestParams.after = Math.floor(params.start.getTime() / 1e3);
+        }
+        if (params.end) {
+          requestParams.before = Math.floor(params.end.getTime() / 1e3);
+        }
+        const response = await axios_1.default.get(url2, {
+          params: requestParams
+        });
+        const tradesData = response.data?.data || response.data || [];
+        let trades = tradesData.map((trade) => {
+          const price = parseFloat(trade.price);
+          const timestamp = Number(trade.timestamp);
+          let side = "unknown";
+          const rawSide = trade.side?.toLowerCase();
+          if (rawSide === "buy")
+            side = "buy";
+          else if (rawSide === "sell")
+            side = "sell";
+          return {
+            id: trade.id || `${timestamp}-${price}`,
+            timestamp: timestamp * 1e3,
+            price,
+            amount: parseFloat(trade.size || trade.amount || 0),
+            side
+          };
+        });
+        trades.sort((a, b) => b.timestamp - a.timestamp);
+        if (params.limit) {
+          trades = trades.slice(0, params.limit);
+        }
+        return trades;
+      } catch (error) {
+        console.error(`Error fetching Limitless trades for ${id}:`, error.message);
+        return [];
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/fetchPositions.js
+var require_fetchPositions2 = __commonJS({
+  "dist/exchanges/limitless/fetchPositions.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.fetchPositions = fetchPositions;
+    var axios_1 = __importDefault(require_axios());
+    var utils_1 = require_utils10();
+    async function fetchPositions(userAddress) {
+      try {
+        const url2 = `${utils_1.LIMITLESS_API_URL}/portfolio/${userAddress}/positions`;
+        const response = await axios_1.default.get(url2);
+        const data = response.data?.data || response.data || [];
+        return data.map((p) => ({
+          marketId: p.market?.slug || p.conditionId,
+          outcomeId: p.asset,
+          outcomeLabel: p.outcome || "Unknown",
+          size: parseFloat(p.size || "0"),
+          entryPrice: parseFloat(p.avgPrice || "0"),
+          currentPrice: parseFloat(p.curPrice || "0"),
+          unrealizedPnL: parseFloat(p.cashPnl || "0"),
+          realizedPnL: parseFloat(p.realizedPnl || "0")
+        }));
+      } catch (error) {
+        if (error.response?.status === 404) {
+          return [];
+        }
+        console.error(`Error fetching Limitless positions: ${error.message}`);
+        return [];
+      }
+    }
+  }
+});
+
+// dist/exchanges/limitless/auth.js
+var require_auth2 = __commonJS({
+  "dist/exchanges/limitless/auth.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LimitlessAuth = void 0;
+    var clob_client_1 = (init_dist2(), __toCommonJS(dist_exports));
+    var ethers_1 = require_lib36();
+    var LIMITLESS_HOST = "https://api.limitless.exchange";
+    var BASE_CHAIN_ID = 8453;
+    var LimitlessAuth = class {
+      constructor(credentials) {
+        this.credentials = credentials;
+        if (!credentials.privateKey) {
+          throw new Error("Limitless requires a privateKey for authentication");
+        }
+        this.signer = new ethers_1.Wallet(credentials.privateKey);
+      }
+      /**
+       * Get or create API credentials using L1 authentication.
+       * This uses the private key to derive/create API credentials.
+       */
+      async getApiCredentials() {
+        if (this.apiCreds) {
+          return this.apiCreds;
+        }
+        if (this.credentials.apiKey && this.credentials.apiSecret && this.credentials.passphrase) {
+          this.apiCreds = {
+            key: this.credentials.apiKey,
+            secret: this.credentials.apiSecret,
+            passphrase: this.credentials.passphrase
+          };
+          return this.apiCreds;
+        }
+        const l1Client = new clob_client_1.ClobClient(LIMITLESS_HOST, BASE_CHAIN_ID, this.signer);
+        let creds;
+        try {
+          creds = await l1Client.deriveApiKey();
+        } catch (deriveError) {
+          try {
+            creds = await l1Client.createApiKey();
+          } catch (createError) {
+            console.error("Failed to both derive and create API key:", createError?.message || createError);
+            throw new Error("Authentication failed: Could not create or derive API key.");
+          }
+        }
+        if (!creds) {
+          throw new Error("Authentication failed: Credentials are empty.");
+        }
+        this.apiCreds = creds;
+        return creds;
+      }
+      /**
+       * Get an authenticated CLOB client for L2 operations (trading).
+       * This client can place orders, cancel orders, query positions, etc.
+       */
+      async getClobClient() {
+        if (this.clobClient) {
+          return this.clobClient;
+        }
+        const apiCreds = await this.getApiCredentials();
+        const signatureType = this.credentials.signatureType ?? 0;
+        const funderAddress = this.credentials.funderAddress ?? this.signer.address;
+        this.clobClient = new clob_client_1.ClobClient(LIMITLESS_HOST, BASE_CHAIN_ID, this.signer, apiCreds, signatureType, funderAddress);
+        return this.clobClient;
+      }
+      /**
+       * Get the signer's address.
+       */
+      getAddress() {
+        return this.signer.address;
+      }
+      /**
+       * Reset cached credentials and client (useful for testing or credential rotation).
+       */
+      reset() {
+        this.apiCreds = void 0;
+        this.clobClient = void 0;
+      }
+    };
+    exports2.LimitlessAuth = LimitlessAuth;
+  }
+});
+
+// dist/exchanges/limitless/websocket.js
+var require_websocket4 = __commonJS({
+  "dist/exchanges/limitless/websocket.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LimitlessWebSocket = void 0;
+    var LimitlessWebSocket = class {
+      constructor(_config = {}) {
+      }
+      async watchOrderBook(_id) {
+        throw new Error("Limitless WebSocket (watchOrderBook) is currently unavailable. The Limitless API v1 does not provide a public WebSocket endpoint for real-time updates. Please use fetchOrderBook() for polling instead.");
+      }
+      async watchTrades(_id) {
+        throw new Error("Limitless WebSocket (watchTrades) is currently unavailable. The Limitless API v1 does not provide a public WebSocket endpoint for real-time updates. Please use fetchOHLCV() or fetchOrderBook() for recent activity instead.");
+      }
+      async close() {
+      }
+    };
+    exports2.LimitlessWebSocket = LimitlessWebSocket;
+  }
+});
+
+// dist/exchanges/limitless/index.js
+var require_limitless = __commonJS({
+  "dist/exchanges/limitless/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LimitlessExchange = void 0;
+    var BaseExchange_1 = require_BaseExchange();
+    var fetchMarkets_1 = require_fetchMarkets2();
+    var searchMarkets_1 = require_searchMarkets2();
+    var searchEvents_1 = require_searchEvents2();
+    var getMarketsBySlug_1 = require_getMarketsBySlug2();
+    var fetchOHLCV_1 = require_fetchOHLCV2();
+    var fetchOrderBook_1 = require_fetchOrderBook2();
+    var fetchTrades_1 = require_fetchTrades2();
+    var fetchPositions_1 = require_fetchPositions2();
+    var auth_1 = require_auth2();
+    var clob_client_1 = (init_dist2(), __toCommonJS(dist_exports));
+    var websocket_1 = require_websocket4();
+    var LimitlessExchange = class extends BaseExchange_1.PredictionMarketExchange {
+      constructor(options) {
+        let credentials;
+        let wsConfig;
+        if (options && "credentials" in options) {
+          credentials = options.credentials;
+          wsConfig = options.websocket;
+        } else if (options && "privateKey" in options) {
+          credentials = options;
+        } else {
+          credentials = options;
+        }
+        super(credentials);
+        this.wsConfig = wsConfig;
+        if (credentials?.privateKey) {
+          this.auth = new auth_1.LimitlessAuth(credentials);
+        }
+      }
+      get name() {
+        return "Limitless";
+      }
+      async fetchMarkets(params) {
+        return (0, fetchMarkets_1.fetchMarkets)(params);
+      }
+      async searchMarkets(query, params) {
+        return (0, searchMarkets_1.searchMarkets)(query, params);
+      }
+      async searchEvents(query, params) {
+        return (0, searchEvents_1.searchEvents)(query, params);
+      }
+      async getMarketsBySlug(slug) {
+        return (0, getMarketsBySlug_1.getMarketsBySlug)(slug);
+      }
+      async fetchOHLCV(id, params) {
+        return (0, fetchOHLCV_1.fetchOHLCV)(id, params);
+      }
+      async fetchOrderBook(id) {
+        return (0, fetchOrderBook_1.fetchOrderBook)(id);
+      }
+      async fetchTrades(id, params) {
+        return (0, fetchTrades_1.fetchTrades)(id, params);
+      }
+      // ----------------------------------------------------------------------------
+      // Trading Methods
+      // ----------------------------------------------------------------------------
+      /**
+       * Ensure authentication is initialized before trading operations.
+       */
+      ensureAuth() {
+        if (!this.auth) {
+          throw new Error('Trading operations require authentication. Initialize LimitlessExchange with credentials: new LimitlessExchange({ privateKey: "0x..." })');
+        }
+        return this.auth;
+      }
+      async createOrder(params) {
+        const auth = this.ensureAuth();
+        const client = await auth.getClobClient();
+        const side = params.side.toUpperCase() === "BUY" ? clob_client_1.Side.BUY : clob_client_1.Side.SELL;
+        if (params.type === "limit" && !params.price) {
+          throw new Error("Price is required for limit orders");
+        }
+        const price = params.price || (side === clob_client_1.Side.BUY ? 0.99 : 0.01);
+        let tickSize;
+        if (params.tickSize) {
+          tickSize = params.tickSize.toString();
+        } else {
+          try {
+            const orderBook = await this.fetchOrderBook(params.outcomeId);
+            tickSize = this.inferTickSize(orderBook);
+          } catch (error) {
+            tickSize = "0.001";
+          }
+        }
         try {
           const response = await client.createAndPostOrder({
             tokenID: params.outcomeId,
@@ -104847,7 +105639,7 @@ var require_polymarket = __commonJS({
             size: params.amount,
             feeRateBps: 0
           }, {
-            tickSize: "0.01"
+            tickSize
           });
           if (!response || !response.success) {
             throw new Error(response?.errorMsg || "Order placement failed");
@@ -104869,6 +105661,38 @@ var require_polymarket = __commonJS({
           throw error;
         }
       }
+      /**
+       * Infer the tick size from order book price levels.
+       * Analyzes the decimal precision of existing orders to determine the market's tick size.
+       */
+      inferTickSize(orderBook) {
+        const allPrices = [
+          ...orderBook.bids.map((b) => b.price),
+          ...orderBook.asks.map((a) => a.price)
+        ];
+        if (allPrices.length === 0) {
+          return "0.001";
+        }
+        let minIncrement = 1;
+        for (const price of allPrices) {
+          const priceStr = price.toString();
+          const decimalPart = priceStr.split(".")[1];
+          if (decimalPart) {
+            const decimals = decimalPart.length;
+            const increment = Math.pow(10, -decimals);
+            if (increment < minIncrement) {
+              minIncrement = increment;
+            }
+          }
+        }
+        if (minIncrement >= 0.1)
+          return "0.1";
+        if (minIncrement >= 0.01)
+          return "0.01";
+        if (minIncrement >= 1e-3)
+          return "0.001";
+        return "0.0001";
+      }
       async cancelOrder(orderId) {
         const auth = this.ensureAuth();
         const client = await auth.getClobClient();
@@ -104934,7 +105758,7 @@ var require_polymarket = __commonJS({
             timestamp: o.created_at * 1e3
           }));
         } catch (error) {
-          console.error("Error fetching Polymarket open orders:", error);
+          console.error("Error fetching Limitless open orders:", error.message);
           return [];
         }
       }
@@ -104977,13 +105801,13 @@ var require_polymarket = __commonJS({
       }
       async watchOrderBook(id, limit) {
         if (!this.ws) {
-          this.ws = new websocket_1.PolymarketWebSocket(this.wsConfig);
+          this.ws = new websocket_1.LimitlessWebSocket(this.wsConfig);
         }
         return this.ws.watchOrderBook(id);
       }
       async watchTrades(id, since, limit) {
         if (!this.ws) {
-          this.ws = new websocket_1.PolymarketWebSocket(this.wsConfig);
+          this.ws = new websocket_1.LimitlessWebSocket(this.wsConfig);
         }
         return this.ws.watchTrades(id);
       }
@@ -104994,12 +105818,12 @@ var require_polymarket = __commonJS({
         }
       }
     };
-    exports2.PolymarketExchange = PolymarketExchange;
+    exports2.LimitlessExchange = LimitlessExchange;
   }
 });
 
 // dist/exchanges/kalshi/utils.js
-var require_utils10 = __commonJS({
+var require_utils11 = __commonJS({
   "dist/exchanges/kalshi/utils.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -105089,7 +105913,7 @@ var require_utils10 = __commonJS({
 });
 
 // dist/exchanges/kalshi/fetchMarkets.js
-var require_fetchMarkets2 = __commonJS({
+var require_fetchMarkets3 = __commonJS({
   "dist/exchanges/kalshi/fetchMarkets.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
@@ -105099,7 +105923,7 @@ var require_fetchMarkets2 = __commonJS({
     exports2.resetCache = resetCache;
     exports2.fetchMarkets = fetchMarkets;
     var axios_1 = __importDefault(require_axios());
-    var utils_1 = require_utils10();
+    var utils_1 = require_utils11();
     async function fetchActiveEvents(targetMarketCount) {
       let allEvents = [];
       let totalMarketCount = 0;
@@ -105178,16 +106002,21 @@ var require_fetchMarkets2 = __commonJS({
           events = cachedEvents;
           seriesMap = cachedSeriesMap;
         } else {
-          const fetchLimit = 1e3;
+          const isSorted = params?.sort && (params.sort === "volume" || params.sort === "liquidity");
+          const fetchLimit = isSorted ? 1e3 : limit;
           const [allEvents, fetchedSeriesMap] = await Promise.all([
             fetchActiveEvents(fetchLimit),
             fetchSeriesMap()
           ]);
           events = allEvents;
           seriesMap = fetchedSeriesMap;
-          cachedEvents = allEvents;
-          cachedSeriesMap = fetchedSeriesMap;
-          lastCacheTime = now;
+          events = allEvents;
+          seriesMap = fetchedSeriesMap;
+          if (fetchLimit >= 1e3) {
+            cachedEvents = allEvents;
+            cachedSeriesMap = fetchedSeriesMap;
+            lastCacheTime = now;
+          }
         }
         const allMarkets = [];
         for (const event of events) {
@@ -105219,12 +106048,12 @@ var require_fetchMarkets2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/searchMarkets.js
-var require_searchMarkets2 = __commonJS({
+var require_searchMarkets3 = __commonJS({
   "dist/exchanges/kalshi/searchMarkets.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.searchMarkets = searchMarkets;
-    var fetchMarkets_1 = require_fetchMarkets2();
+    var fetchMarkets_1 = require_fetchMarkets3();
     async function searchMarkets(query, params) {
       const fetchLimit = 1e5;
       try {
@@ -105251,7 +106080,7 @@ var require_searchMarkets2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/searchEvents.js
-var require_searchEvents2 = __commonJS({
+var require_searchEvents3 = __commonJS({
   "dist/exchanges/kalshi/searchEvents.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
@@ -105260,7 +106089,7 @@ var require_searchEvents2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.searchEvents = searchEvents;
     var axios_1 = __importDefault(require_axios());
-    var utils_1 = require_utils10();
+    var utils_1 = require_utils11();
     async function searchEvents(query, params) {
       try {
         const queryParams = {
@@ -105313,7 +106142,7 @@ var require_searchEvents2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/getMarketsBySlug.js
-var require_getMarketsBySlug2 = __commonJS({
+var require_getMarketsBySlug3 = __commonJS({
   "dist/exchanges/kalshi/getMarketsBySlug.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
@@ -105322,7 +106151,7 @@ var require_getMarketsBySlug2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getMarketsBySlug = getMarketsBySlug;
     var axios_1 = __importDefault(require_axios());
-    var utils_1 = require_utils10();
+    var utils_1 = require_utils11();
     async function getMarketsBySlug(eventTicker) {
       try {
         const normalizedTicker = eventTicker.toUpperCase();
@@ -105371,7 +106200,7 @@ var require_getMarketsBySlug2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/fetchOHLCV.js
-var require_fetchOHLCV2 = __commonJS({
+var require_fetchOHLCV3 = __commonJS({
   "dist/exchanges/kalshi/fetchOHLCV.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
@@ -105380,7 +106209,7 @@ var require_fetchOHLCV2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.fetchOHLCV = fetchOHLCV;
     var axios_1 = __importDefault(require_axios());
-    var utils_1 = require_utils10();
+    var utils_1 = require_utils11();
     async function fetchOHLCV(id, params) {
       try {
         const cleanedId = id.replace(/-NO$/, "");
@@ -105458,7 +106287,7 @@ var require_fetchOHLCV2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/fetchOrderBook.js
-var require_fetchOrderBook2 = __commonJS({
+var require_fetchOrderBook3 = __commonJS({
   "dist/exchanges/kalshi/fetchOrderBook.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
@@ -105509,7 +106338,7 @@ var require_fetchOrderBook2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/fetchTrades.js
-var require_fetchTrades2 = __commonJS({
+var require_fetchTrades3 = __commonJS({
   "dist/exchanges/kalshi/fetchTrades.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
@@ -105545,7 +106374,7 @@ var require_fetchTrades2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/auth.js
-var require_auth2 = __commonJS({
+var require_auth3 = __commonJS({
   "dist/exchanges/kalshi/auth.js"(exports2) {
     "use strict";
     var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
@@ -105645,7 +106474,7 @@ var require_auth2 = __commonJS({
 });
 
 // dist/exchanges/kalshi/websocket.js
-var require_websocket4 = __commonJS({
+var require_websocket5 = __commonJS({
   "dist/exchanges/kalshi/websocket.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
@@ -105939,15 +106768,15 @@ var require_kalshi = __commonJS({
     exports2.KalshiExchange = void 0;
     var axios_1 = __importDefault(require_axios());
     var BaseExchange_1 = require_BaseExchange();
-    var fetchMarkets_1 = require_fetchMarkets2();
-    var searchMarkets_1 = require_searchMarkets2();
-    var searchEvents_1 = require_searchEvents2();
-    var getMarketsBySlug_1 = require_getMarketsBySlug2();
-    var fetchOHLCV_1 = require_fetchOHLCV2();
-    var fetchOrderBook_1 = require_fetchOrderBook2();
-    var fetchTrades_1 = require_fetchTrades2();
-    var auth_1 = require_auth2();
-    var websocket_1 = require_websocket4();
+    var fetchMarkets_1 = require_fetchMarkets3();
+    var searchMarkets_1 = require_searchMarkets3();
+    var searchEvents_1 = require_searchEvents3();
+    var getMarketsBySlug_1 = require_getMarketsBySlug3();
+    var fetchOHLCV_1 = require_fetchOHLCV3();
+    var fetchOrderBook_1 = require_fetchOrderBook3();
+    var fetchTrades_1 = require_fetchTrades3();
+    var auth_1 = require_auth3();
+    var websocket_1 = require_websocket5();
     var KalshiExchange = class extends BaseExchange_1.PredictionMarketExchange {
       constructor(options) {
         let credentials;
@@ -106233,9 +107062,11 @@ var require_app = __commonJS({
     var express_1 = __importDefault(require_express2());
     var cors_1 = __importDefault(require_lib3());
     var polymarket_1 = require_polymarket();
+    var limitless_1 = require_limitless();
     var kalshi_1 = require_kalshi();
     var defaultExchanges = {
       polymarket: null,
+      limitless: null,
       kalshi: null
     };
     async function startServer(port, accessToken) {
@@ -106299,6 +107130,13 @@ var require_app = __commonJS({
             apiSecret: credentials?.apiSecret || process.env.POLYMARKET_API_SECRET,
             passphrase: credentials?.passphrase || process.env.POLYMARKET_PASSPHRASE
           });
+        case "limitless":
+          return new limitless_1.LimitlessExchange({
+            privateKey: credentials?.privateKey || process.env.LIMITLESS_PK || process.env.LIMITLESS_PRIVATE_KEY,
+            apiKey: credentials?.apiKey || process.env.LIMITLESS_API_KEY,
+            apiSecret: credentials?.apiSecret || process.env.LIMITLESS_API_SECRET,
+            passphrase: credentials?.passphrase || process.env.LIMITLESS_PASSPHRASE
+          });
         case "kalshi":
           return new kalshi_1.KalshiExchange({
             apiKey: credentials?.apiKey || process.env.KALSHI_API_KEY,

pmxt/client.py

@@ -990,3 +990,39 @@ class Kalshi(Exchange):
             base_url=base_url,
             auto_start_server=auto_start_server,
         )
+
+
+class Limitless(Exchange):
+    """
+    Limitless exchange client.
+    
+    Example:
+        >>> # Public data (no auth)
+        >>> limitless = Limitless()
+        >>> markets = limitless.search_markets("Trump")
+        >>> 
+        >>> # Trading (requires auth)
+        >>> limitless = Limitless(private_key=os.getenv("LIMITLESS_PRIVATE_KEY"))
+        >>> balance = limitless.fetch_balance()
+    """
+    
+    def __init__(
+        self,
+        private_key: Optional[str] = None,
+        base_url: str = "http://localhost:3847",
+        auto_start_server: bool = True,
+    ):
+        """
+        Initialize Limitless client.
+        
+        Args:
+            private_key: Ethereum private key (required for trading)
+            base_url: Base URL of the PMXT sidecar server
+            auto_start_server: Automatically start server if not running (default: True)
+        """
+        super().__init__(
+            exchange_name="limitless",
+            private_key=private_key,
+            base_url=base_url,
+            auto_start_server=auto_start_server,
+        )

{pmxt-1.4.1.dist-info → pmxt-1.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pmxt
-Version: 1.4.1
+Version: 1.5.1
 Summary: Unified prediction market data API - The ccxt for prediction markets
 Author: PMXT Contributors
 License: MIT

{pmxt-1.4.1.dist-info → pmxt-1.5.1.dist-info}/RECORD

@@ -1,15 +1,15 @@
-pmxt/__init__.py,sha256=MF02BpWSi_lMTTekzj6fxuZn9EBApLDlxqG9XfyHURs,1150
-pmxt/client.py,sha256=1qa8ObZtf-tdzhDXQXvWWdeLvGbyxsiVHAgQvl8Z4Uk,32955
+pmxt/__init__.py,sha256=boDsiDSOI47zl1FeTA-nuM4IH-PorRyCozDtVScez5s,1178
+pmxt/client.py,sha256=YEArwWnyDbd5Hb_HxMWXIqsihUD0RZDaTrBZh4hOlq4,34026
 pmxt/models.py,sha256=-jiQ9mmv_qnF6mzj3DrvNgEA77tE_Pl0RCblM1VbV7o,8581
 pmxt/server_manager.py,sha256=6uS1LIZ2d5d_K-MtbMUAlCZvbvhZ_iyofKok55HEofc,11606
 pmxt/_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pmxt/_server/bin/pmxt-ensure-server,sha256=kXIond0UbxS52FAVQD7kHmSBaL_s6cbIyapLRr4KZJw,4544
 pmxt/_server/bin/pmxt-ensure-server.js,sha256=kXIond0UbxS52FAVQD7kHmSBaL_s6cbIyapLRr4KZJw,4544
-pmxt/_server/server/bundled.js,sha256=ETpsJ6ZmRtO1gQmBZYwwHWTHJIEI8ooeeMhOwoeDJ84,4198184
-pmxt_internal/__init__.py,sha256=Uxuh0MqjsHQ7vIaFnF5ZFSVlu4uJJFRDkQ_ued-QLHc,7578
-pmxt_internal/api_client.py,sha256=0IalYtBszV5nLMHLkPqwECHqeWVOdE6ROcPrH72zwHs,27889
+pmxt/_server/server/bundled.js,sha256=Os3W7syaDzC9_nYLOWcAzYDEAkGcWluW1rx_q0RSl_o,4228933
+pmxt_internal/__init__.py,sha256=M7ymbKiAUn1HrvEJZ1YBrkd32Xjc18Q_V_PiJT5JGdo,7578
+pmxt_internal/api_client.py,sha256=rUegyKlMlYJOH5qRuJTBNkWgRLJtnWr-5REq-zjE9mE,27889
 pmxt_internal/api_response.py,sha256=eMxw1mpmJcoGZ3gs9z6jM4oYoZ10Gjk333s9sKxGv7s,652
-pmxt_internal/configuration.py,sha256=uo3MWYp8NBZ8lVhNrWRWWSDzSOfuYF0O5RLuV4FUUUs,18320
+pmxt_internal/configuration.py,sha256=edgaKafrUFd_z-2f4zIwaTZg7-xp4_7dhsPR62WvLNQ,18320
 pmxt_internal/exceptions.py,sha256=txF8A7vlan57JS69kFPs-IZF-Qhp7IZobBTJVa4fOaM,6644
 pmxt_internal/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pmxt_internal/rest.py,sha256=FMj4yaV6XLr842u_ScWHSzQsTFdk0jaUeuWLJoRbogQ,9760
@@ -65,7 +65,7 @@ pmxt_internal/models/unified_market.py,sha256=DoYhiH4HycYGlq858PEeB-CIA7haT6rxmJ
 pmxt_internal/models/watch_order_book_request.py,sha256=kavGUI-SLz2-Kam_jcJ_h0GDe0-9UkxqCmVsAi6Uios,3726
 pmxt_internal/models/watch_order_book_request_args_inner.py,sha256=ZHrjmFDGxRG5MXbuz4mUp9KFfo3XS7zuXWTyMNgi4xI,5464
 pmxt_internal/models/watch_trades_request.py,sha256=brrg8JbEe-aeg7mIe_Y2HzRPogp-IfRhkXChrxzqoLU,3722
-pmxt-1.4.1.dist-info/METADATA,sha256=3y8vXwX2n2sDBosp4CCbL3YN7SVpsV7yVF2CHp5B5fw,6449
-pmxt-1.4.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pmxt-1.4.1.dist-info/top_level.txt,sha256=J_jrcouJ-x-5lpcXMxeW0GOSi1HsBVR5_PdSfvigVrw,19
-pmxt-1.4.1.dist-info/RECORD,,
+pmxt-1.5.1.dist-info/METADATA,sha256=yqv45Tbq8HwunZn5FD5IpD1p2SmruMQ0YEAnGsNPwg4,6449
+pmxt-1.5.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pmxt-1.5.1.dist-info/top_level.txt,sha256=J_jrcouJ-x-5lpcXMxeW0GOSi1HsBVR5_PdSfvigVrw,19
+pmxt-1.5.1.dist-info/RECORD,,

pmxt_internal/__init__.py

@@ -14,7 +14,7 @@
 """  # noqa: E501
 
 
-__version__ = "1.4.1"
+__version__ = "1.5.1"
 
 # Define package exports
 __all__ = [

pmxt_internal/api_client.py

@@ -91,7 +91,7 @@ class ApiClient:
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        self.user_agent = 'OpenAPI-Generator/1.4.1/python'
+        self.user_agent = 'OpenAPI-Generator/1.5.1/python'
         self.client_side_validation = configuration.client_side_validation
 
     def __enter__(self):

pmxt_internal/configuration.py

@@ -506,7 +506,7 @@ class Configuration:
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
                "Version of the API: 0.4.4\n"\
-               "SDK Package Version: 1.4.1".\
+               "SDK Package Version: 1.5.1".\
                format(env=sys.platform, pyversion=sys.version)
 
     def get_host_settings(self) -> List[HostSetting]: