@curless/hotel-storefront 0.45.2 → 0.47.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\`, \`freeCancellation\`, \`window\`, \`payment\` and \`family\` 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,32 @@ 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',
+                    },
+                    window: {
+                        type: 'boolean',
+                        description: 'With dates: only rooms with a window (not a partial or an inner one)',
+                    },
+                    payment: {
+                        type: 'string',
+                        enum: ['at-hotel', 'online'],
+                        description: 'With dates: only rooms paid at the hotel (`at-hotel`) or in advance online (`online`)',
+                    },
+                    family: {
+                        type: 'boolean',
+                        description: 'With dates: only rooms that sleep 3 or more',
+                    },
                 },
                 required: ['hotel'],
             },
@@ -1029,6 +1061,24 @@ 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, count }`, `key` one of `breakfast`, `king`, `twin`,
+     * `freeCancellation` (always here, `count` 0 where no room has it) and
+     * `window`, `payAtHotel`, `payOnline`, `family` (here only where some rooms
+     * have it and some do not).
+     */
+    roomFilters: ARR,
+    /** The filters the call asked for, as the same keys - the card opens with these selected. */
+    activeFilters: STRS,
+    /**
+     * Room types with no room to book for these nights (none left, or fewer
+     * than the rooms asked for): `{ id, name, names?, sleeps, ..., left? }`, no
+     * price. The card draws them muted at the end of the list, so a type the
+     * guest saw is said to be sold out and not left out. Absent where there are
+     * none - and never in what the assistant is told.
+     */
+    soldOut: ARR,
 };
 export const buildOutputSchemas = (n) => ({
     [n.listHotels]: {
@@ -1146,6 +1196,8 @@ export const buildOutputSchemas = (n) => ({
             accessibility: BOOL,
             /** One per stay, when the trip held several. */
             bookings: ARR,
+            /** What all of `bookings` come to, where they are in one currency (the card's first screen). */
+            totalAll: STR,
             /**
              * The stays that could not be booked when the others were - each with
              * why, still in the trip, and what could be booked instead (robin,
@@ -1965,6 +2017,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, freeCancellation, window, payment and family 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',
@@ -2093,6 +2246,52 @@ const dateFlex = (dates, stay) => {
         text: `Arriving ${beats.checkIn} instead is ${formatMoney(saved)} less for ${sameNights}.`,
     };
 };
+/**
+ * The room types a guest can no longer book on these nights - for the card to
+ * say so, and not leave them out (r10 #10: a type the guest saw earlier
+ * vanished from the list, and the heading counted one fewer, without a word).
+ *
+ * ⚠️ AN ADDITIVE FIELD, NEVER THE TEXT. What the assistant is told is the rooms
+ * that can be booked, as before; this is only what the card draws, muted, at
+ * the end of the list. A type is listed when
+ *  - the backend sends it with none left (`HotelDetail.soldOut`, or a room with
+ *    `roomsLeft: 0`), or
+ *  - it has some left, but fewer than the rooms asked for (`left`): a guest who
+ *    asked for two rooms and was shown no type with one left was not told why.
+ * Not a type that sleeps fewer than the party (the backend never sends it), and
+ * not a type any of whose rates can be booked. One entry a type, with the facts
+ * the card says of a room and no price.
+ */
+const soldOutTypesOf = (detail, enough, wanted) => {
+    const key = (r) => r.roomType?.id ?? r.id;
+    const open = new Set(enough.map(key));
+    const types = new Map();
+    for (const r of [...(detail.rooms ?? []), ...(detail.soldOut ?? [])]) {
+        if (r.hourly || open.has(key(r)) || r.roomsLeft >= wanted)
+            continue;
+        const seen = types.get(key(r));
+        if (seen)
+            seen.left = Math.max(seen.left, r.roomsLeft);
+        else
+            types.set(key(r), { room: r, left: r.roomsLeft });
+    }
+    return [...types.entries()].map(([id, { room: r, left }]) => ({
+        id,
+        name: r.roomType?.name ?? r.name,
+        ...((r.roomType?.names ?? r.names) ? { names: r.roomType?.names ?? r.names } : {}),
+        sleeps: r.sleeps,
+        ...(r.maxChildren ? { maxChildren: r.maxChildren } : {}),
+        ...(r.sizeSqm ? { sizeSqm: r.sizeSqm } : {}),
+        ...(r.beds ? { beds: r.beds } : {}),
+        ...(r.bedTypes ? { bedTypes: r.bedTypes } : {}),
+        ...(r.view ? { view: r.view } : {}),
+        ...(r.window ? { window: r.window } : {}),
+        ...(r.floor ? { floor: r.floor } : {}),
+        ...(r.imageUrl ? { imageUrl: r.imageUrl } : {}),
+        // Some left, but not as many as were asked for.
+        ...(left > 0 ? { left } : {}),
+    }));
+};
 const identity = (deps, ctx, key, args = {}) => {
     const email = str(args.email);
     const member = deps.members.read(key);
@@ -2381,6 +2580,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 +2591,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 +2602,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 +3224,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 +3327,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 +3395,15 @@ 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 soldOut = soldOutTypesOf(detail, enough, roomsWanted);
         const rooms = enough.map((r) => ({
             ...r,
+            facets: facetsOf(r),
             nightly: formatMoney(r.nightly),
             stayTotal: formatMoney(r.stayTotal),
             taxesAndFees: formatMoney(r.taxesAndFees),
@@ -3219,14 +3436,20 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 stay,
                 rooms,
                 rooms_wanted: roomsWanted,
+                roomFilters: optionsOf(enough),
+                activeFilters: activeKeysOf(terms),
+                // Types with no room to book for these nights, said and not left out.
+                ...(byTheHour || !soldOut.length ? {} : { soldOut }),
                 ...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)
@@ -3869,6 +4092,17 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                         : {}),
                     paid: false,
                     ...(remembered ? { remembered: remembered.kept } : {}),
+                    // What they come to together, said by the server like every figure on
+                    // the card - never added up there (r10, #15). Only in one currency.
+                    ...(several &&
+                        booked.every(({ booking }) => booking.quote.total.currency === first.booking.quote.total.currency)
+                        ? {
+                            totalAll: formatMoney({
+                                minor: booked.reduce((n, { booking }) => n + booking.quote.total.minor, 0),
+                                currency: first.booking.quote.total.currency,
+                            }),
+                        }
+                        : {}),
                     holdUntil: first.booking.holdUntil,
                     total: formatMoney(first.booking.quote.total),
                     ...(first.asked.length ? { requested: first.asked } : {}),