hotelzero 1.3.0 → 1.4.0

package/dist/browser.d.ts

@@ -23,7 +23,6 @@ export interface HotelSearchParams {
     currency?: string;
     sortBy?: "popularity" | "price_lowest" | "price_highest" | "rating" | "distance";
     limit?: number;
-    offset?: number;
 }
 export interface HotelFilters {
     minRating?: number;
@@ -125,6 +124,29 @@ export interface HotelResult {
     matchScore?: number;
     matchReasons?: string[];
 }
+export interface HotelDetails {
+    name: string;
+    url: string;
+    rating: number | null;
+    ratingText: string;
+    reviewCount: number | null;
+    starRating: number | null;
+    address: string;
+    description: string;
+    highlights: string;
+    pricePerNight: number | null;
+    priceDisplay: string;
+    totalPrice: string;
+    checkInTime: string;
+    checkOutTime: string;
+    popularFacilities: string[];
+    allFacilities: string[];
+    roomTypes: string[];
+    photos: string[];
+    nearbyAttractions: string[];
+    guestReviewHighlights: string[];
+    locationInfo: string;
+}
 export declare class HotelBrowser {
     private browser;
     private page;
@@ -144,4 +166,12 @@ export declare class HotelBrowser {
     getHotelDetails(hotelUrl: string): Promise<Record<string, unknown>>;
     takeScreenshot(path: string): Promise<void>;
     getPageContent(): Promise<string>;
+    /**
+     * Get detailed hotel information for comparison
+     */
+    getHotelDetailsForComparison(hotelUrl: string): Promise<HotelDetails>;
+    /**
+     * Compare multiple hotels side-by-side
+     */
+    compareHotels(hotelUrls: string[]): Promise<HotelDetails[]>;
 }

package/dist/browser.js

@@ -251,7 +251,7 @@ export class HotelBrowser {
         }
     }
     buildBookingUrl(params, filters) {
-        const { destination, checkIn, checkOut, guests, rooms, currency, sortBy, offset } = params;
+        const { destination, checkIn, checkOut, guests, rooms, currency, sortBy } = params;
         const url = new URL("https://www.booking.com/searchresults.html");
         url.searchParams.set("ss", destination);
         url.searchParams.set("checkin", checkIn);
@@ -259,10 +259,6 @@ export class HotelBrowser {
         url.searchParams.set("group_adults", guests.toString());
         url.searchParams.set("no_rooms", rooms.toString());
         url.searchParams.set("selected_currency", currency || "USD");
-        // Pagination offset
-        if (offset && offset > 0) {
-            url.searchParams.set("offset", offset.toString());
-        }
         // Sort order
         if (sortBy) {
             const sortMap = {
@@ -625,33 +621,42 @@ export class HotelBrowser {
     async scrollToLoadMore(targetResults = 25) {
         if (!this.page)
             return;
-        // Calculate how many scroll iterations needed
-        // Each scroll typically loads ~15-25 more results
-        // We start with ~25, so to get to targetResults we need (targetResults - 25) / 20 more scrolls
-        const scrollsNeeded = Math.max(1, Math.ceil((targetResults - 25) / 20));
-        const maxScrolls = Math.min(scrollsNeeded, 5); // Cap at 5 scrolls to avoid excessive loading
-        // Scroll down to load more results
-        for (let i = 0; i < maxScrolls; i++) {
-            await this.page.evaluate(() => {
-                window.scrollBy(0, window.innerHeight);
-            });
+        // If we only need 25 or fewer, minimal scrolling
+        if (targetResults <= 25) {
+            // Just one scroll to ensure initial results are loaded
+            await this.page.evaluate(() => window.scrollBy(0, window.innerHeight));
             await this.page.waitForTimeout(1000);
-            // Check if "Load more" button exists and click it
+            await this.page.evaluate(() => window.scrollTo(0, 0));
+            return;
+        }
+        // For larger limits, we need to scroll and click "Load more" multiple times
+        // Booking.com loads ~25 results initially, then ~25 more per "Load more" click
+        const clicksNeeded = Math.ceil((targetResults - 25) / 25);
+        const maxClicks = Math.min(clicksNeeded, 4); // Cap at 4 clicks (~125 results max)
+        for (let i = 0; i < maxClicks; i++) {
+            // Scroll to bottom to trigger lazy loading and find "Load more" button
+            await this.page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
+            await this.page.waitForTimeout(1500);
+            // Try to click "Load more" button
             try {
                 const loadMoreBtn = await this.page.$('button[data-testid="load-more-results"]');
                 if (loadMoreBtn) {
                     await loadMoreBtn.click();
-                    await this.page.waitForTimeout(1500);
+                    await this.page.waitForTimeout(2000); // Wait for results to load
+                }
+                else {
+                    // No more "Load more" button, we've loaded all available results
+                    break;
                 }
             }
             catch {
-                // Ignore if button not found
+                // Button not found or click failed
+                break;
             }
         }
         // Scroll back to top
-        await this.page.evaluate(() => {
-            window.scrollTo(0, 0);
-        });
+        await this.page.evaluate(() => window.scrollTo(0, 0));
+        await this.page.waitForTimeout(500);
     }
     async extractHotelDetails() {
         if (!this.page)
@@ -969,4 +974,273 @@ export class HotelBrowser {
             throw new Error("Browser not initialized");
         return await this.page.content();
     }
+    /**
+     * Get detailed hotel information for comparison
+     */
+    async getHotelDetailsForComparison(hotelUrl) {
+        if (!this.page) {
+            throw new HotelSearchError("Browser not initialized. Call init() first.", ErrorCodes.BROWSER_NOT_INITIALIZED, false);
+        }
+        return await retryWithBackoff(async () => {
+            await this.enforceRateLimit();
+            try {
+                await this.page.goto(hotelUrl, {
+                    waitUntil: "networkidle",
+                    timeout: 30000
+                });
+            }
+            catch (error) {
+                const err = error;
+                if (err.message.includes("timeout") || err.message.includes("Timeout")) {
+                    throw new HotelSearchError("Page load timed out.", ErrorCodes.TIMEOUT, true);
+                }
+                throw new HotelSearchError(`Navigation failed: ${err.message}`, ErrorCodes.NAVIGATION_FAILED, true);
+            }
+            await this.page.waitForTimeout(2000);
+            await this.checkForBlocking();
+            await this.dismissPopups();
+            // Extract comprehensive hotel details using evaluate with string to avoid __name compilation issues
+            const details = await this.page.evaluate(`
+          (function() {
+            function getText(selector) {
+              var el = document.querySelector(selector);
+              return el && el.textContent ? el.textContent.trim() : "";
+            }
+            
+            function getTexts(selector) {
+              var elements = document.querySelectorAll(selector);
+              var result = [];
+              for (var i = 0; i < elements.length; i++) {
+                var text = elements[i].textContent;
+                if (text) {
+                  text = text.trim();
+                  if (text.length > 0) result.push(text);
+                }
+              }
+              return result;
+            }
+            
+            function getUniqueTexts(selector) {
+              var texts = getTexts(selector);
+              var seen = {};
+              var result = [];
+              for (var i = 0; i < texts.length; i++) {
+                if (!seen[texts[i]]) {
+                  seen[texts[i]] = true;
+                  result.push(texts[i]);
+                }
+              }
+              return result;
+            }
+
+            // Name - h2 is cleaner than h1 on Booking.com property pages
+            var name = getText('h2');
+            if (!name) name = getText('h1').split('(')[0].trim(); // fallback, strip suffix
+
+            // Rating - parse from review-score-component which contains "Scored 7.4 7.4Rated good Good · 11 reviews"
+            var ratingEl = document.querySelector('[data-testid="review-score-component"]');
+            var ratingFullText = ratingEl ? ratingEl.textContent || "" : "";
+            
+            // Extract numeric rating (first number after "Scored")
+            var ratingMatch = ratingFullText.match(/Scored\\s+([\\d.]+)/i);
+            var rating = ratingMatch ? parseFloat(ratingMatch[1]) : null;
+            
+            // Extract rating description (Good, Excellent, etc.)
+            var descMatch = ratingFullText.match(/Rated\\s*\\w+\\s*(\\w+)/i);
+            var ratingDesc = descMatch ? descMatch[1] : "";
+            if (!ratingDesc) {
+              // Try alternate pattern
+              var altMatch = ratingFullText.match(/(Exceptional|Superb|Excellent|Very Good|Good|Pleasant|Review score)/i);
+              ratingDesc = altMatch ? altMatch[1] : "";
+            }
+            
+            // Review count - look for number followed by "review"
+            var reviewMatch = ratingFullText.match(/([\\d,]+)\\s*reviews?/i);
+            var reviewCount = reviewMatch ? parseInt(reviewMatch[1].replace(/,/g, "")) : null;
+
+            // Star rating (for hotels)
+            var starEl = document.querySelector('[data-testid="rating-stars"]');
+            var starCount = starEl ? starEl.querySelectorAll('span[class*="star"], svg').length : null;
+            // Sometimes stars are indicated by aria-label
+            if (!starCount) {
+              var starLabel = document.querySelector('[aria-label*="star"]');
+              if (starLabel) {
+                var labelMatch = starLabel.getAttribute('aria-label').match(/(\\d+)/);
+                starCount = labelMatch ? parseInt(labelMatch[1]) : null;
+              }
+            }
+
+            // Address - from header address wrapper, clean up extra content
+            var address = "";
+            var addressWrapper = document.querySelector('[data-testid="PropertyHeaderAddressDesktop-wrapper"]');
+            if (addressWrapper) {
+              // Get all spans and find the one with the actual address
+              var spans = addressWrapper.querySelectorAll('span');
+              for (var i = 0; i < spans.length; i++) {
+                var text = spans[i].textContent ? spans[i].textContent.trim() : "";
+                // Address typically contains comma-separated parts ending with country
+                if (text.length > 10 && text.indexOf(",") > 0) {
+                  // Cut off at common suffixes that indicate end of address
+                  var cutoffs = ["Excellent location", "Great location", "Good location", "Very good location", "show map", "– rated", "After booking"];
+                  for (var j = 0; j < cutoffs.length; j++) {
+                    var idx = text.indexOf(cutoffs[j]);
+                    if (idx > 0) {
+                      text = text.substring(0, idx).trim();
+                      break;
+                    }
+                  }
+                  if (text.length > 10) {
+                    address = text;
+                    break;
+                  }
+                }
+              }
+            }
+            if (!address) address = getText('[data-testid="property-header-location"]');
+
+            // Description
+            var description = getText('[data-testid="property-description"]');
+
+            // Property highlights (size, bathroom, etc.)
+            var highlights = getText('[data-testid="property-highlights"]');
+
+            // Price - look in the reservation/booking section
+            var priceDisplay = "";
+            var pricePerNight = null;
+            
+            // Try multiple price selectors
+            var priceSelectors = [
+              '[data-testid="price-and-discounted-price"]',
+              '[class*="prco-valign-middle-helper"]',
+              '[class*="bui-price-display__value"]',
+              'span[class*="price"]'
+            ];
+            
+            for (var i = 0; i < priceSelectors.length; i++) {
+              var priceEl = document.querySelector(priceSelectors[i]);
+              if (priceEl && priceEl.textContent) {
+                var text = priceEl.textContent.trim();
+                // Look for currency symbol followed by number
+                var match = text.match(/[\\$€£¥]\\s*([\\d,]+)/);
+                if (match) {
+                  priceDisplay = text;
+                  pricePerNight = parseInt(match[1].replace(/,/g, ""));
+                  break;
+                }
+              }
+            }
+
+            // Check-in/out times - try multiple approaches
+            var checkInTime = getText('[data-testid="check-in-time"]');
+            var checkOutTime = getText('[data-testid="check-out-time"]');
+            
+            // If not found, look in policies section
+            if (!checkInTime) {
+              var policyText = getText('[data-testid="policy-summary"]') || "";
+              var checkInMatch = policyText.match(/check-in[:\\s]*(\\d{1,2}:\\d{2})/i);
+              checkInTime = checkInMatch ? checkInMatch[1] : "";
+            }
+            if (!checkOutTime) {
+              var policyText = getText('[data-testid="policy-summary"]') || "";
+              var checkOutMatch = policyText.match(/check-out[:\\s]*(\\d{1,2}:\\d{2})/i);
+              checkOutTime = checkOutMatch ? checkOutMatch[1] : "";
+            }
+
+            // Popular facilities - from the wrapper, get unique spans
+            var facilitiesWrapper = document.querySelector('[data-testid="property-most-popular-facilities-wrapper"]');
+            var popularFacilities = [];
+            if (facilitiesWrapper) {
+              var spans = facilitiesWrapper.querySelectorAll('span');
+              var seen = {};
+              for (var i = 0; i < spans.length; i++) {
+                var text = spans[i].textContent ? spans[i].textContent.trim() : "";
+                // Skip labels like "Most popular amenities" and short items
+                if (text && text.length > 2 && text.length < 50 && !seen[text] && 
+                    text.indexOf("Most popular") === -1 && text.indexOf("amenities") === -1) {
+                  seen[text] = true;
+                  popularFacilities.push(text);
+                }
+              }
+            }
+            
+            // If still empty, try property-highlights
+            if (popularFacilities.length === 0 && highlights) {
+              // Parse highlights like "Private bathroomFree WifiShower..."
+              var items = highlights.split(/(?=[A-Z][a-z])/);
+              for (var i = 0; i < items.length; i++) {
+                var item = items[i].trim();
+                if (item && item.length > 2) popularFacilities.push(item);
+              }
+            }
+
+            // All facilities from facilities section
+            var allFacilities = getUniqueTexts('[data-testid="property-section-facilities"] li');
+            if (allFacilities.length === 0) {
+              allFacilities = getUniqueTexts('[data-testid="Property-Facilities-Tab-Content"] li');
+            }
+
+            // Room types
+            var roomTypes = getUniqueTexts('[data-testid="room-name"]');
+
+            // Photos from gallery
+            var photoEls = document.querySelectorAll('[data-testid="GalleryUnifiedDesktop-wrapper"] img, [class*="gallery"] img');
+            var photos = [];
+            var seenPhotos = {};
+            for (var i = 0; i < photoEls.length && photos.length < 5; i++) {
+              var src = photoEls[i].src;
+              if (src && src.indexOf("data:") === -1 && !seenPhotos[src]) {
+                seenPhotos[src] = true;
+                photos.push(src);
+              }
+            }
+
+            // Location info from map
+            var locationInfo = getText('[data-testid="map-entry-point-desktop"]');
+
+            return {
+              name: name,
+              rating: rating,
+              ratingText: ratingDesc,
+              reviewCount: reviewCount,
+              starRating: starCount,
+              address: address,
+              description: description.slice(0, 500),
+              highlights: highlights,
+              pricePerNight: pricePerNight,
+              priceDisplay: priceDisplay,
+              totalPrice: "",
+              checkInTime: checkInTime,
+              checkOutTime: checkOutTime,
+              popularFacilities: popularFacilities.slice(0, 15),
+              allFacilities: allFacilities.slice(0, 30),
+              roomTypes: roomTypes.slice(0, 5),
+              photos: photos,
+              nearbyAttractions: [],
+              guestReviewHighlights: [],
+              locationInfo: locationInfo
+            };
+          })()
+        `);
+            return {
+                ...details,
+                url: hotelUrl,
+            };
+        }, DEFAULT_RETRY_CONFIG, (attempt, error, delayMs) => {
+            console.error(`Get hotel details attempt ${attempt} failed: ${error.message}. Retrying in ${Math.round(delayMs / 1000)}s...`);
+        });
+    }
+    /**
+     * Compare multiple hotels side-by-side
+     */
+    async compareHotels(hotelUrls) {
+        if (hotelUrls.length < 2 || hotelUrls.length > 3) {
+            throw new HotelSearchError("Please provide 2-3 hotel URLs to compare", "INVALID_INPUT", false);
+        }
+        const results = [];
+        for (const url of hotelUrls) {
+            const details = await this.getHotelDetailsForComparison(url);
+            results.push(details);
+        }
+        return results;
+    }
 }

package/dist/index.js

@@ -42,7 +42,6 @@ const FindHotelsSchema = z.object({
     sortBy: z.enum(["popularity", "price_lowest", "price_highest", "rating", "distance"]).optional().describe("Sort results by"),
     // Pagination
     limit: z.number().min(1).max(100).optional().describe("Maximum number of results to return (default: 25, max: 100)"),
-    offset: z.number().min(0).optional().describe("Number of results to skip for pagination (default: 0)"),
     // Rating & Price
     minRating: z.number().optional().describe("Minimum rating (6=Pleasant, 7=Good, 8=Very Good, 9=Wonderful)"),
     minPrice: z.number().optional().describe("Minimum price per night"),
@@ -124,6 +123,9 @@ const FindHotelsSchema = z.object({
 const HotelDetailsSchema = z.object({
     url: z.string().describe("Booking.com URL for the hotel"),
 });
+const CompareHotelsSchema = z.object({
+    urls: z.array(z.string()).min(2).max(3).describe("Array of 2-3 Booking.com hotel URLs to compare"),
+});
 // Global browser instance (reuse for efficiency)
 let browser = null;
 async function getBrowser() {
@@ -165,10 +167,146 @@ function formatHotelResult(hotel, index) {
     }
     return lines.join("\n");
 }
+function formatHotelComparison(hotels) {
+    const lines = [];
+    // Header
+    lines.push("=".repeat(60));
+    lines.push("HOTEL COMPARISON");
+    lines.push("=".repeat(60));
+    lines.push("");
+    // Create comparison sections
+    const sections = [
+        {
+            title: "OVERVIEW",
+            rows: [
+                { label: "Name", getValue: (h) => h.name || "Unknown" },
+                { label: "Rating", getValue: (h) => h.rating ? `${h.rating}/10 ${h.ratingText}` : "N/A" },
+                { label: "Reviews", getValue: (h) => h.reviewCount ? `${h.reviewCount.toLocaleString()} reviews` : "N/A" },
+                { label: "Stars", getValue: (h) => h.starRating ? "★".repeat(h.starRating) : "N/A" },
+                { label: "Location", getValue: (h) => h.address || h.locationInfo || "N/A" },
+            ],
+        },
+        {
+            title: "PRICING",
+            rows: [
+                { label: "Per Night", getValue: (h) => h.priceDisplay || "N/A" },
+                { label: "Total", getValue: (h) => h.totalPrice || "N/A" },
+            ],
+        },
+        {
+            title: "CHECK-IN/OUT",
+            rows: [
+                { label: "Check-in", getValue: (h) => h.checkInTime || "N/A" },
+                { label: "Check-out", getValue: (h) => h.checkOutTime || "N/A" },
+            ],
+        },
+        {
+            title: "PROPERTY HIGHLIGHTS",
+            rows: [
+                { label: "Highlights", getValue: (h) => h.highlights || "N/A" },
+            ],
+        },
+    ];
+    // Render each section
+    for (const section of sections) {
+        lines.push(`--- ${section.title} ---`);
+        lines.push("");
+        for (const row of section.rows) {
+            const values = hotels.map(h => row.getValue(h));
+            lines.push(`${row.label}:`);
+            values.forEach((v, i) => {
+                lines.push(`  ${i + 1}. ${v}`);
+            });
+            lines.push("");
+        }
+    }
+    // Facilities comparison
+    lines.push("--- TOP FACILITIES ---");
+    lines.push("");
+    hotels.forEach((h, i) => {
+        const facilities = h.popularFacilities.length > 0 ? h.popularFacilities : h.allFacilities;
+        lines.push(`${i + 1}. ${h.name}:`);
+        facilities.slice(0, 8).forEach(f => {
+            lines.push(`   • ${f}`);
+        });
+        lines.push("");
+    });
+    // Find common and unique facilities
+    if (hotels.length >= 2) {
+        const allFacilitySets = hotels.map(h => {
+            const facilities = [...h.popularFacilities, ...h.allFacilities];
+            return new Set(facilities.map(f => f.toLowerCase()));
+        });
+        // Find facilities in all hotels
+        const commonFacilities = [];
+        const firstHotelFacilities = [...hotels[0].popularFacilities, ...hotels[0].allFacilities];
+        for (const facility of firstHotelFacilities) {
+            const lowerFacility = facility.toLowerCase();
+            if (allFacilitySets.every(set => set.has(lowerFacility))) {
+                commonFacilities.push(facility);
+            }
+        }
+        if (commonFacilities.length > 0) {
+            lines.push("--- COMMON FACILITIES ---");
+            commonFacilities.slice(0, 10).forEach(f => {
+                lines.push(`• ${f}`);
+            });
+            lines.push("");
+        }
+    }
+    // Room types
+    const hasRoomTypes = hotels.some(h => h.roomTypes.length > 0);
+    if (hasRoomTypes) {
+        lines.push("--- ROOM TYPES ---");
+        lines.push("");
+        hotels.forEach((h, i) => {
+            lines.push(`${i + 1}. ${h.name}:`);
+            if (h.roomTypes.length > 0) {
+                h.roomTypes.slice(0, 3).forEach(r => {
+                    lines.push(`   • ${r}`);
+                });
+            }
+            else {
+                lines.push(`   (Room types not available)`);
+            }
+            lines.push("");
+        });
+    }
+    // Quick verdict based on data
+    lines.push("--- QUICK COMPARISON ---");
+    lines.push("");
+    // Best rating
+    const withRatings = hotels.filter(h => h.rating !== null);
+    if (withRatings.length > 0) {
+        const bestRated = withRatings.reduce((a, b) => (a.rating > b.rating ? a : b));
+        lines.push(`Highest Rated: ${bestRated.name} (${bestRated.rating}/10)`);
+    }
+    // Best price
+    const withPrices = hotels.filter(h => h.pricePerNight !== null);
+    if (withPrices.length > 0) {
+        const cheapest = withPrices.reduce((a, b) => (a.pricePerNight < b.pricePerNight ? a : b));
+        lines.push(`Lowest Price: ${cheapest.name} (${cheapest.priceDisplay})`);
+    }
+    // Most reviews
+    const withReviews = hotels.filter(h => h.reviewCount !== null);
+    if (withReviews.length > 0) {
+        const mostReviewed = withReviews.reduce((a, b) => (a.reviewCount > b.reviewCount ? a : b));
+        lines.push(`Most Reviews: ${mostReviewed.name} (${mostReviewed.reviewCount?.toLocaleString()})`);
+    }
+    lines.push("");
+    lines.push("=".repeat(60));
+    // Add URLs for reference
+    lines.push("BOOKING LINKS:");
+    hotels.forEach((h, i) => {
+        const shortUrl = h.url.split("?")[0];
+        lines.push(`${i + 1}. ${shortUrl}`);
+    });
+    return lines.join("\n");
+}
 // Create MCP server
 const server = new Server({
     name: "hotelzero",
-    version: "1.3.0",
+    version: "1.4.0",
 }, {
     capabilities: {
         tools: {},
@@ -197,7 +335,6 @@ const findHotelsInputSchema = {
         },
         // Pagination
         limit: { type: "number", description: "Maximum results to return (default: 25, max: 100)", default: 25 },
-        offset: { type: "number", description: "Number of results to skip for pagination", default: 0 },
         // Property Type
         propertyType: {
             type: "string",
@@ -340,6 +477,23 @@ Results are scored and ranked by how well they match the criteria.`,
                     required: ["url"],
                 },
             },
+            {
+                name: "compare_hotels",
+                description: "Compare 2-3 hotels side-by-side. Provide Booking.com URLs from search results to see a detailed comparison of ratings, prices, amenities, and facilities.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        urls: {
+                            type: "array",
+                            items: { type: "string" },
+                            minItems: 2,
+                            maxItems: 3,
+                            description: "Array of 2-3 Booking.com hotel URLs to compare"
+                        },
+                    },
+                    required: ["urls"],
+                },
+            },
         ],
     };
 });
@@ -360,12 +514,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     currency: parsed.currency,
                     sortBy: parsed.sortBy,
                     limit: parsed.limit,
-                    offset: parsed.offset,
                 };
                 // Build filters object from all parsed parameters
                 const filters = {};
                 // Copy all filter properties (exclude search params)
-                const filterKeys = Object.keys(parsed).filter(k => !['destination', 'checkIn', 'checkOut', 'guests', 'rooms', 'currency', 'sortBy', 'limit', 'offset'].includes(k));
+                const filterKeys = Object.keys(parsed).filter(k => !['destination', 'checkIn', 'checkOut', 'guests', 'rooms', 'currency', 'sortBy', 'limit'].includes(k));
                 for (const key of filterKeys) {
                     const value = parsed[key];
                     if (value !== undefined && value !== null) {
@@ -436,20 +589,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const filtersLine = activeFilters.length > 0
                     ? `Filters: ${activeFilters.join(", ")}\n\n`
                     : "\n";
-                // Pagination info
-                const offset = parsed.offset || 0;
-                const displayLimit = parsed.limit || 25;
-                const paginationLine = offset > 0
-                    ? `Showing results ${offset + 1}-${offset + results.length} of available hotels\n\n`
-                    : "";
                 const hotelList = results
-                    .map((h, i) => formatHotelResult(h, i + offset))
+                    .map((h, i) => formatHotelResult(h, i))
                     .join("\n\n");
                 return {
                     content: [
                         {
                             type: "text",
-                            text: header + filtersLine + paginationLine + hotelList,
+                            text: header + filtersLine + hotelList,
                         },
                     ],
                 };
@@ -489,6 +636,19 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            case "compare_hotels": {
+                const parsed = CompareHotelsSchema.parse(args);
+                const hotels = await b.compareHotels(parsed.urls);
+                const comparison = formatHotelComparison(hotels);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: comparison,
+                        },
+                    ],
+                };
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
@@ -557,7 +717,7 @@ process.on("SIGTERM", async () => {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("HotelZero v1.3.0 running on stdio");
+    console.error("HotelZero v1.4.0 running on stdio");
 }
 main().catch((error) => {
     console.error("Fatal error:", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hotelzero",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "MCP server for searching hotels on Booking.com with 80+ filters",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",