@curless/hotel-storefront 0.45.2 → 0.46.0

package/dist/tools.js

@@ -7,6 +7,7 @@ import { amountsIn, formatMoney, keepingAmounts, money, multiplyMoney, toMinor }
 import { roomNamesOf, withTraditional } from './names.js';
 import { MAX_COMPARED, MAX_CONS, MAX_DAYS, MAX_ITEMS_PER_DAY, MAX_MOMENTS, MAX_PROS, buildItinerary, candidatesFor, compareHotels, namesMoreThanOne, } from './present.js';
 import { regionOf } from './regions.js';
+import { activeKeysOf, byRoomType, facetsOf, keyWords, matchesTerms, optionsOf, roomTermsOf, termWords, } from './room-filters.js';
 import { MAX_EXTRA_QUANTITY, MAX_ROOMS_PER_LINE, clampCount, shownOf, tripKey, } from './trip.js';
 import { DEMO_NOTE, branded, catalogue, noteFor, upFirst } from './vocab.js';
 // The eleven things a guest can do: find hotels, look at one on dates, see what
@@ -259,7 +260,7 @@ const allTools = (n, v) => {
     return [
         {
             name: n.listHotels,
-            description: `${upFirst(catalogue(v))}, shown as a card. Asked with no place - or a country of many cities - it answers with the places to choose from: regions, countries and cities, each with how many ${v.nounPlural} it has; \`all\` lists the ${v.nounPlural} themselves. \`city\` (a city or a country) or \`query\` answers with the ${v.nounPlural}: a picture, the city and area, a rating where the ${v.noun} publishes one, and a from-price, and a city usually holds several. With \`checkIn\` and \`checkOut\` every ${v.noun} is priced for those nights - its cheapest room that takes the party, \`rooms\` of it, for the whole stay with taxes - or marked as having no room for them. \`sort\` and \`maxNightly\` order and cap by that price, or by the from-price without dates, where the matches share one currency. \`brand\`, \`facilities\`, \`freeCancellation\` and \`breakfast\` narrow the list, and the answer counts what each would leave. A long list comes a page at a time: the answer says how many more there are and the \`offset\` of the next page. Words or a place that match nothing are widened once, and the answer names what it widened to.${v.hints.search ? ` ${v.hints.search}` : ''}`,
+            description: `${upFirst(catalogue(v))}, shown as a card. Asked with no place - or a country of many cities - it answers with the places to choose from: regions, countries and cities, each with how many ${v.nounPlural} it has; \`all\` lists the ${v.nounPlural} themselves. \`city\` (a city or a country) or \`query\` answers with the ${v.nounPlural}: a picture, the city and area, a rating where the ${v.noun} publishes one, and a from-price, and a city usually holds several. With \`checkIn\` and \`checkOut\` every ${v.noun} is priced for those nights - its cheapest room that takes the party, \`rooms\` of it, for the whole stay with taxes - or marked as having no room for them. \`sort\` and \`maxNightly\` order and cap by that price, or by the from-price without dates, where the matches share one currency. \`brand\`, \`facilities\`, \`freeCancellation\`, \`breakfast\` and \`bed\` narrow the list, and the answer counts what each would leave. A long list comes a page at a time: the answer says how many more there are and the \`offset\` of the next page. Words or a place that match nothing are widened once, and the answer names what it widened to.${v.hints.search ? ` ${v.hints.search}` : ''}`,
             annotations: reads(`Browse ${catalogue(v)}`, open),
             inputSchema: {
                 type: 'object',
@@ -324,6 +325,11 @@ const allTools = (n, v) => {
                         type: 'boolean',
                         description: `Only ${v.nounPlural} with a room that includes breakfast - and, with dates, that room is the one priced`,
                     },
+                    bed: {
+                        type: 'string',
+                        enum: ['king', 'twin'],
+                        description: `Only ${v.nounPlural} with a room that has this bed - \`king\` is one large bed (king, queen or double), \`twin\` is two beds - and, with dates, that room is the one priced. Given with \`freeCancellation\` or \`breakfast\`, one room must have all of them`,
+                    },
                     all: {
                         type: 'boolean',
                         description: `Unnarrowed, or narrowed to a country of many cities, the answer is the places to choose from; true lists the ${v.nounPlural} themselves`,
@@ -333,7 +339,7 @@ const allTools = (n, v) => {
         },
         {
             name: n.getHotel,
-            description: `One ${v.noun} in full: description, amenities, address, and check-in and check-out times where the ${v.noun} publishes them. Given \`checkIn\` and \`checkOut\` it also returns the room types that can be booked for those nights, each with its nightly rate, the stay total including taxes and fees, whether it can be cancelled free and until when, and how many rooms are left. \`rooms\` leaves out the types that have fewer than that many. Without dates it returns the ${v.noun} only, because a room has no price until the nights are known. The ${v.noun} is drawn as a card for the guest to look at.${v.hints.hotel ? ` ${v.hints.hotel}` : ''}`,
+            description: `One ${v.noun} in full: description, amenities, address, and check-in and check-out times where the ${v.noun} publishes them. Given \`checkIn\` and \`checkOut\` it also returns the room types that can be booked for those nights, one line per type at its lowest rate: the nightly rate, the stay total including taxes and fees, whether it can be cancelled free and until when, and how many rates it has. \`rooms\` leaves out the types that have fewer than that many left. \`bed\`, \`breakfast\` and \`freeCancellation\` keep only the rates that meet all of those given; the card still holds every room, with the given filters selected. Without dates it returns the ${v.noun} only, because a room has no price until the nights are known. The ${v.noun} is drawn as a card for the guest to look at.${v.hints.hotel ? ` ${v.hints.hotel}` : ''}`,
             annotations: reads(`View one ${catalogue(v, true)}`, open),
             inputSchema: {
                 type: 'object',
@@ -349,6 +355,19 @@ const allTools = (n, v) => {
                         maximum: MAX_ROOMS_PER_LINE,
                         description: `How many rooms of one type, 1 to ${MAX_ROOMS_PER_LINE}. Default 1`,
                     },
+                    bed: {
+                        type: 'string',
+                        enum: ['king', 'twin'],
+                        description: 'With dates: only rooms with this bed - `king` is one large bed (king, queen or double), `twin` is two beds. A room sold as king or twin has both',
+                    },
+                    breakfast: {
+                        type: 'boolean',
+                        description: 'With dates: only rooms whose rate includes breakfast',
+                    },
+                    freeCancellation: {
+                        type: 'boolean',
+                        description: 'With dates: only rooms that can be cancelled free',
+                    },
                 },
                 required: ['hotel'],
             },
@@ -1029,6 +1048,14 @@ const HOTEL_PAGE = {
     policies: ARR,
     /** Arrivals a few days either side, each re-quoted for the same nights - what the date picker prices its days from. */
     dates: ARR,
+    /**
+     * The room filters this hotel's rooms offer, each with how many rooms (rates)
+     * it keeps - `{ key: 'breakfast' | 'king' | 'twin' | 'freeCancellation', count }`.
+     * Only a kind at least one room has.
+     */
+    roomFilters: ARR,
+    /** The filters the call asked for, as the same keys - the card opens with these selected. */
+    activeFilters: STRS,
 };
 export const buildOutputSchemas = (n) => ({
     [n.listHotels]: {
@@ -1965,6 +1992,107 @@ const labelWords = (r) => {
     ];
     return words.length ? ` [${words.join(', ')}]` : '';
 };
+/** What a rate says about cancelling, as the text puts it. */
+const cancelWords = (r) => r.freeCancellationUntil
+    ? `free to cancel until ${freeUntilText(r)}`
+    : r.refundable
+        ? 'the free cancellation window has closed - cancelling now has a fee'
+        : 'non-refundable';
+/**
+ * What a room is, in a parenthesis: its beds, how many it sleeps and - for one
+ * rate, not a type whose rates differ - breakfast, unless the rate's labels
+ * already say it.
+ */
+const roomFactsWords = (r, rate = false) => {
+    const facts = [
+        r.beds,
+        `sleeps ${r.sleeps}`,
+        rate && facetsOf(r).breakfast && !(r.labels ?? []).some((l) => l.startsWith('breakfast'))
+            ? 'breakfast included'
+            : '',
+    ]
+        .filter(Boolean)
+        .join(', ');
+    return ` (${facts})`;
+};
+/** The cheapest price a rate quotes, as the text says it: "from" a night, or the hours of a block. */
+const fromWords = (r) => r.hourly
+    ? `${formatMoney(r.stayTotal)} for ${r.hourly.hours} hours incl. taxes and fees`
+    : `${formatMoney(r.nightly)} a night, ${formatMoney(r.stayTotal)} for the stay incl. taxes and fees`;
+/**
+ * A hotel's rooms for the nights, one line per ROOM TYPE.
+ *
+ * ⚠️ A TYPE IS ONE LINE, NOT ONE LINE PER RATE CODE. A Huazhu hotel sells a
+ * dozen rates on three types, and every code in one long run buried the types
+ * (robin, 2026-10-23, after Qunar's page). A type with one rate is that rate,
+ * in full; a type with several says how many, its lowest price, which rate that
+ * is - the name `room` takes - and what the rest have, in a few words.
+ * Another rate is reached by narrowing: `bed`, `breakfast`, `freeCancellation`.
+ */
+const roomTypeLines = (rooms, roomsWanted, 
+/** The terms already applied: what they say is true of every rate here, so it is not counted again. */
+terms) => {
+    const forRooms = (r) => roomsWanted > 1
+        ? ` (${formatMoney(multiplyMoney(r.stayTotal, roomsWanted))} for ${roomsWanted} rooms)`
+        : '';
+    return byRoomType(rooms).map((type) => {
+        const cheapest = type.rooms.reduce((a, b) => (b.stayTotal.minor < a.stayTotal.minor ? b : a));
+        const n = type.rooms.length;
+        if (n === 1)
+            return `- ${cheapest.name}${labelWords(cheapest)}${roomFactsWords(cheapest, true)} — ${priceWords(cheapest)}${forRooms(cheapest)}, ${cancelWords(cheapest)}`;
+        const some = (k, all, part) => k === n ? all : k > 0 ? `${k} of ${n} ${part}` : '';
+        const also = [
+            terms?.breakfast
+                ? ''
+                : some(type.rooms.filter((r) => facetsOf(r).breakfast).length, 'all include breakfast', 'include breakfast'),
+            terms?.freeCancellation
+                ? ''
+                : some(type.rooms.filter((r) => facetsOf(r).freeCancellation).length, 'all are free to cancel', 'are free to cancel'),
+        ].filter(Boolean);
+        return `- ${type.name}${roomFactsWords(cheapest)} — ${n} rates from ${fromWords(cheapest)}${forRooms(cheapest)}. Cheapest: "${cheapest.name}"${labelWords(cheapest)}, ${cancelWords(cheapest)}.${also.length ? ` ${also.join('; ')}.` : ''}`;
+    });
+};
+/**
+ * What a hotel's rooms look like to the assistant for the nights: one line per
+ * type, and with filters only the rates that meet ALL of them. None meeting
+ * them is said plainly - which filters were asked, what each leaves on its own
+ * - and that the full list is there without them.
+ */
+const roomsText = (hotelName, 
+/** "3 room types for 2026-11-04 to 2026-11-06, 2 guests" - what the rooms are, counted. */
+counted, 
+/** "2026-11-04 to 2026-11-06" - when, for the sentence that says none fit. */
+when, enough, roomsWanted, terms) => {
+    // A type with several rates is priced from its cheapest: say how to reach another.
+    const lines = (rs) => [
+        ...roomTypeLines(rs, roomsWanted, terms),
+        ...(byRoomType(rs).some((t) => t.rooms.length > 1)
+            ? [
+                'A type with several rates is priced from its cheapest one; bed, breakfast and freeCancellation narrow to the others (the card lists every rate).',
+            ]
+            : []),
+    ];
+    if (!terms)
+        return [`**${hotelName}** · ${counted(enough)}.`, ...lines(enough)];
+    const asked = termWords(terms);
+    const several = activeKeysOf(terms).length > 1;
+    const rates = (n) => `${n} ${n === 1 ? 'rate' : 'rates'}`;
+    const matching = enough.filter((r) => matchesTerms(r, terms));
+    if (matching.length === 0) {
+        const alone = several
+            ? ` On its own, ${activeKeysOf(terms)
+                .map((k) => `${keyWords(k)} fits ${enough.filter((r) => facetsOf(r)[k]).length}`)
+                .join(', ')}.`
+            : '';
+        return [
+            `**${hotelName}** · none of the ${rates(enough.length)} for ${when} has ${asked}${several ? ' together' : ''}.${alone} The full list is there without ${several ? 'those filters' : 'that filter'}.`,
+        ];
+    }
+    return [
+        `**${hotelName}** · ${counted(matching)}, with ${asked} (${matching.length} of ${rates(enough.length)}).`,
+        ...lines(matching),
+    ];
+};
 const PAYMENT_WORDS = {
     awaiting: 'to be paid on the card page',
     issued: 'confirmed on UnionPay - the hotel is being asked to book it',
@@ -2381,6 +2509,7 @@ const filtersOf = (args) => {
         ...(facilities.length ? { facilities } : {}),
         ...(args.freeCancellation === true ? { freeCancellation: true } : {}),
         ...(args.breakfast === true ? { breakfast: true } : {}),
+        ...(args.bed === 'king' || args.bed === 'twin' ? { bed: args.bed } : {}),
         ...(args.hourly === true ? { hourly: true } : {}),
     };
     return Object.keys(f).length ? f : undefined;
@@ -2391,6 +2520,7 @@ const filterWords = (f) => [
     ...(f.facilities ?? []).map((k) => FACILITIES.find((x) => x.key === k)?.label.toLowerCase()),
     f.freeCancellation ? 'free cancellation' : '',
     f.breakfast ? 'breakfast included' : '',
+    f.bed === 'king' ? 'king beds' : f.bed === 'twin' ? 'twin beds' : '',
     f.hourly ? 'rooms by the hour today' : '',
 ]
     .filter(Boolean)
@@ -2401,6 +2531,7 @@ const emptiedBy = (f, before, nouns) => {
         (f.facilities?.length ?? 0) +
         (f.freeCancellation ? 1 : 0) +
         (f.breakfast ? 1 : 0) +
+        (f.bed ? 1 : 0) +
         // By the hour is a term like the others: alone, it is said alone - not
         // "has rooms by the hour today together" (huazhu, 2026-10-13).
         (f.hourly ? 1 : 0);
@@ -3022,7 +3153,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         const applied = (wantedPrice && !oneCurrency) || answer.ignored?.sort ? 'group' : sort;
         // Room terms the backend could not apply are not "filtered to".
         const filtersSaid = asked.filters && answer.ignored?.roomTerms
-            ? { ...asked.filters, freeCancellation: undefined, breakfast: undefined }
+            ? { ...asked.filters, freeCancellation: undefined, breakfast: undefined, bed: undefined }
             : asked.filters;
         const priceNotes = [
             // What the backend was asked and did not do, in its own words.
@@ -3125,7 +3256,15 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         };
         if (!stay) {
             return {
-                structured: { view: 'hotel', ...base, needsDates: true },
+                // ⚠️ THE FILTERS RIDE ALONG WITHOUT DATES: the card prices the dates
+                // itself and draws its chips from this answer, so a model that asked
+                // for breakfast before any night was named still has it asked.
+                structured: {
+                    view: 'hotel',
+                    ...base,
+                    needsDates: true,
+                    activeFilters: activeKeysOf(roomTermsOf(args)),
+                },
                 text: [
                     `**${h.name}** · ${[h.area, h.city].filter(Boolean).join(', ')}`,
                     description.fenced,
@@ -3185,8 +3324,14 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                     .join(' '),
             };
         }
+        // ⚠️ THE CARD KEEPS EVERY ROOM, THE TEXT KEEPS THE ONES THAT MATCH. The
+        // filters narrow what the assistant is told; the card is sent all of them
+        // with what is true of each (`facets`), so a chip switched on or off on the
+        // card needs no call to the server.
+        const terms = roomTermsOf(args);
         const rooms = enough.map((r) => ({
             ...r,
+            facets: facetsOf(r),
             nightly: formatMoney(r.nightly),
             stayTotal: formatMoney(r.stayTotal),
             taxesAndFees: formatMoney(r.taxesAndFees),
@@ -3219,14 +3364,18 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 stay,
                 rooms,
                 rooms_wanted: roomsWanted,
+                roomFilters: optionsOf(enough),
+                activeFilters: activeKeysOf(terms),
                 ...flex.structured,
             },
             text: [
-                byTheHour
-                    ? `**${h.name}** · ${enough.length} ${enough.length === 1 ? 'room' : 'rooms'} by the hour for today, ${stay.checkIn}, ${stay.guests} guests.`
-                    : `**${h.name}** · ${offerCount(enough)} for ${stay.checkIn} to ${stay.checkOut}, ${stay.guests} guests${roomsWanted > 1 ? `, ${roomsWanted} rooms` : ''}.`,
-                ...enough.map((r) => `- ${r.name}${labelWords(r)} — ${priceWords(r)}${roomsWanted > 1 ? ` (${formatMoney(multiplyMoney(r.stayTotal, roomsWanted))} for ${roomsWanted} rooms)` : ''}${r.freeCancellationUntil ? `, free to cancel until ${freeUntilText(r)}` : r.refundable ? ', the free cancellation window has closed - cancelling now has a fee' : ', non-refundable'}`),
-                flex.text,
+                ...roomsText(h.name, byTheHour
+                    ? (rs) => `${rs.length} ${rs.length === 1 ? 'room' : 'rooms'} by the hour for today, ${stay.checkIn}, ${stay.guests} guests`
+                    : (rs) => `${offerCount(rs)} for ${stay.checkIn} to ${stay.checkOut}, ${stay.guests} guests${roomsWanted > 1 ? `, ${roomsWanted} rooms` : ''}`, byTheHour ? `today, ${stay.checkIn}` : `${stay.checkIn} to ${stay.checkOut}`, enough, roomsWanted, terms),
+                // The other arrivals are priced on the cheapest room of any kind.
+                terms && flex.text
+                    ? `${flex.text} (That is the cheapest room of any kind, not only one with ${termWords(terms)}.)`
+                    : flex.text,
                 deps.vocab.demo ? noteFor(deps.vocab) : '',
             ]
                 .filter(Boolean)