@curless/hotel-storefront 0.46.0 → 0.47.1

package/dist/tools.js

@@ -4,7 +4,7 @@ import { FACILITIES } from './facilities.js';
 import { DESCRIPTION_MAX, POLICY_MAX, guestText, hotelText } from './fence.js';
 import { clockOf, minutesOf, startProblem, stayWords, windowWords } from './hourly.js';
 import { amountsIn, formatMoney, keepingAmounts, money, multiplyMoney, toMinor } from './money.js';
-import { roomNamesOf, withTraditional } from './names.js';
+import { namedExactly, 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';
@@ -339,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, 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}` : ''}`,
+            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',
@@ -368,6 +368,19 @@ const allTools = (n, v) => {
                         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'],
             },
@@ -923,6 +936,8 @@ const CANCEL_SCHEMA = {
         demoHold: BOOL,
         addOnsFree: BOOL,
         fee: STR,
+        /** What the booking being cancelled came to, taxes in - the fee is read against it. */
+        bookingTotal: STR,
         refund: STR,
         rule: STR,
         freeUntil: STR,
@@ -1050,12 +1065,22 @@ const HOTEL_PAGE = {
     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.
+     * 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]: {
@@ -1173,6 +1198,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,
@@ -1457,6 +1484,10 @@ const holderOf = (deps, supplier) => {
 const bookingForCard = (b) => ({
     ...b,
     quote: quoteForCard(b.quote),
+    // What a cancelled booking was charged to cancel, as text like every amount the
+    // card is given: "Cancelled" in My bookings says it beside the struck-out total
+    // (r10 #21). `cancellationFee` stays the money it was.
+    ...(b.cancellationFee ? { cancellationFeeText: formatMoney(b.cancellationFee) } : {}),
     ...(b.payment
         ? {
             payment: {
@@ -1720,6 +1751,9 @@ const quoteForCard = (quote, groupOf) => ({
         ...(l.ordered !== undefined ? { ordered: l.ordered } : {}),
         unit: formatMoney(l.unit),
         total: formatMoney(l.total),
+        // The line with its taxes in, where the backend knows them per line: what the
+        // review and the trip show, as the hotel's page does (r10 #23).
+        ...(l.totalWithTaxes ? { totalWithTaxes: formatMoney(l.totalWithTaxes) } : {}),
         refundable: l.refundable,
         freeCancellationUntil: l.freeCancellationUntil,
         // The deadline on the hotel's clock, where the backend knows it - the
@@ -2068,7 +2102,7 @@ when, enough, roomsWanted, terms) => {
         ...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).',
+                '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).',
             ]
             : []),
     ];
@@ -2221,6 +2255,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);
@@ -3329,6 +3409,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         // 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),
@@ -3366,6 +3447,8 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 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: [
@@ -3659,7 +3742,10 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         const today = (startTime || !asStay(args)
             ? deps.backend.hourlyRooms?.(hotelId, guestsOf(args), who)
             : undefined);
-        const byTheHour = async () => (await today)?.rooms?.find((r) => r.hourly && (r.id === roomRef || r.name.toLowerCase() === roomRef.toLowerCase()));
+        const byTheHour = async () => {
+            const sold = ((await today)?.rooms ?? []).filter((r) => r.hourly);
+            return sold.find((r) => r.id === roomRef) ?? namedExactly(sold, roomRef);
+        };
         if (startTime && deps.backend.hourlyRooms) {
             const hourlyRoom = await byTheHour();
             if (!hourlyRoom?.hourly) {
@@ -3766,7 +3852,11 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 text: dated?.noRooms ?? 'Those nights cannot be booked here.',
             };
         }
-        const room = dated.rooms.find((r) => r.id === roomRef || r.name.toLowerCase() === roomRef.toLowerCase());
+        // ⚠️ BY THE OFFER'S WHOLE NAME, in any language it has: a guest who read
+        // 「豪华大床房 · 双早 · 不可取消」 on the card says that, and it is the same offer
+        // as "Deluxe King Room · Breakfast for 2 · Non-refundable". Never a part of
+        // it, and never a room type's bare name when it has several rates.
+        const room = dated.rooms.find((r) => r.id === roomRef) ?? namedExactly(dated.rooms, roomRef);
         if (!room) {
             return {
                 structured: {
@@ -3784,7 +3874,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                     hotel: { id: detail.hotel.id, name: detail.hotel.name },
                     stay,
                 },
-                text: `${detail.hotel.name} has no room type by that name for those nights. It has: ${dated.rooms.map((r) => r.name).join(', ')}.`,
+                text: `${detail.hotel.name} has no room type by that name for those nights. It has: ${dated.rooms.map((r) => (/\p{Script=Han}/u.test(roomRef) && r.names?.zh ? `${r.name} (${r.names.zh})` : r.name)).join(', ')}.`,
             };
         }
         deps.trips.set(key, {
@@ -4018,6 +4108,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 } : {}),
@@ -4437,6 +4538,8 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                     : {}),
                 ...ownDemo,
                 fee: formatMoney(preview.fee),
+                // What the booking came to, so the fee is read against it (r10 #22).
+                ...(booked ? { bookingTotal: formatMoney(booked.quote.total) } : {}),
                 // ⚠️ NO "REFUND": nothing was ever paid here - a demonstration takes no
                 // money and a hotel's own booking is paid at the hotel - so a figure
                 // called a refund is money that is not coming back (2026-10-05 audit, P3).