@curless/hotel-storefront 0.47.4 → 0.47.6

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 { namedExactly, roomNamesOf, withTraditional } from './names.js';
+import { namedExactly, roomNamesOf, roomTypeNamed, 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';
@@ -747,12 +747,16 @@ const allTools = (n, v) => {
                             properties: {
                                 label: {
                                     type: 'string',
-                                    description: `e.g. "Day 1 — Arrive${places[0] ? ` in ${places[0]}` : ''}"`,
+                                    description: `e.g. "Arrive${places[0] ? ` in ${places[0]}` : ''}" - the card prints each day's date beside it, so leave the date out`,
                                 },
                                 note: {
                                     type: 'string',
                                     description: 'One or two lines on the day, in your own words',
                                 },
+                                why: {
+                                    type: 'string',
+                                    description: `Why the ${v.noun} named on this day suits the days of that stay - near what, good for what - one sentence, in your own words, with no lead-in such as "My pick:" - the card has its own`,
+                                },
                                 items: {
                                     type: 'array',
                                     items: { type: 'string' },
@@ -1321,7 +1325,21 @@ export const buildOutputSchemas = (n) => ({
             demoNote: STR,
             title: STR,
             stay: OBJ,
-            days: ARR,
+            days: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        label: STR,
+                        note: STR,
+                        /** Why the hotel this day names suits the days of that stay - the model's sentence. */
+                        why: STR,
+                        date: STR,
+                        plan: ARR,
+                        items: ARR,
+                    },
+                },
+            },
             /** How many of the planned items are actually in the trip. Computed, never written. */
             inTrip: { type: 'number' },
             planned: { type: 'number' },
@@ -2925,6 +2943,58 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
 const fitsManyOf = (deps, dropped) => dropped.flatMap((d) => d.candidates?.length
     ? [`"${d.name}" ${namesMoreThanOne(d.candidates, branded(deps.vocab, deps.vocab.noun))}`]
     : []);
+/** A stay this long, at one hotel, is worth asking whether the days stay in one area. */
+const LONG_STAY_NIGHTS = 4;
+/** The other areas a long stay's answer names - one hotel each. */
+const OTHER_AREAS_MAX = 4;
+/**
+ * For each priced stay of four nights or more, the other areas of its city that
+ * have a hotel - for the model, in the tool's text, never on the card or in the
+ * schema.
+ *
+ * ⚠️ A WEEK AT ONE HOTEL WAS THE PLAN, AND THE MODEL NEVER SAW WHAT ELSE THE
+ * CITY HAS (the owner, 2026-10-26, on the live Atour connector: both Beijing
+ * weeks, all six nights at one hotel). The instructions say a long stay in a big
+ * city usually spans areas; this is the answer saying it at the moment the plan
+ * has just been drawn that way, with the hotels of the other areas by id, so the
+ * model can plan the stay in parts - or offer the move - without a second
+ * look-up. Nothing where the city has no other area, or the backend cannot say:
+ * a nudge that guesses is worse than none.
+ */
+const longStayNudges = async (deps, stays) => {
+    // The areas the plan already uses are not "other" for any of its stays.
+    const used = new Set(stays.map((x) => x.area?.toLowerCase()).filter(Boolean));
+    const out = [];
+    for (const x of stays) {
+        if ((x.nights ?? 0) < LONG_STAY_NIGHTS || !x.area || !x.city)
+            continue;
+        let hotels;
+        try {
+            hotels = (await deps.backend.searchHotels({ city: x.city, limit: MAX_PAGE })).hotels;
+        }
+        catch {
+            // The plan is already drawn; a city that cannot be read just gets no nudge.
+            continue;
+        }
+        const byArea = new Map();
+        for (const h of hotels) {
+            const area = h.area?.trim();
+            if (!area || h.city !== x.city || h.id === x.id)
+                continue;
+            const lower = area.toLowerCase();
+            if (used.has(lower) || byArea.has(lower))
+                continue;
+            byArea.set(lower, h);
+        }
+        if (byArea.size === 0)
+            continue;
+        const others = [...byArea.values()]
+            .slice(0, OTHER_AREAS_MAX)
+            .map((h) => `${h.area} - ${h.name} (\`${h.id}\`)`);
+        out.push(`${stays.length === 1 ? `All ${x.nights} nights are` : `${x.nights} nights are`} at ${x.name} (${x.area}). ${x.city} also has: ${others.join('; ')}. In your reply, name the planned days that are far from ${x.area} and offer moving those nights to the hotel here nearest them, with the reason in one sentence - or say why every day suits ${x.area}. The plan on screen stays as it is; draw it again only if the guest asks.`);
+    }
+    return out;
+};
 /** The hotel a call named - or the answer that says there is none, or several by that name. */
 const hotelNamed = async (deps, key, wanted) => {
     const detail = await deps.backend.getHotel(wanted);
@@ -2996,7 +3066,7 @@ const putRoomLine = async (deps, t, ctx, key, store, args, detail) => {
                     })),
                 },
                 text: sold.length
-                    ? `${detail.hotel.name} has no room by the hour by that name today. It has: ${sold.map((r) => `${r.name} (\`${r.id}\`, ${windowWords(r.hourly)})`).join('; ')}.`
+                    ? `${detail.hotel.name} has no room by the hour by that name today. It has: ${sold.map((r) => `${r.name} (\`${r.id}\`, ${windowWords(r.hourly)})`).join('; ')}. Call again with the id.`
                     : ((await today)?.noRooms ?? `${detail.hotel.name} has no rooms by the hour today.`),
             };
         }
@@ -3085,12 +3155,37 @@ const putRoomLine = async (deps, t, ctx, key, store, args, detail) => {
             text: dated?.noRooms ?? 'Those nights cannot be booked here.',
         };
     }
-    // ⚠️ BY THE OFFER'S WHOLE NAME, in any language it has: a guest who read
+    // ⚠️ BY THE ID, THE OFFER'S WHOLE NAME, OR A ROOM TYPE'S BARE NAME - in
+    // that order, and in any language the name 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);
+    // a name. A type's bare name ("Deluxe King Room") used to be no room at all
+    // when the type has several rates, and a model that planned a trip by the
+    // type's name was answered "no such room" three times over (the owner,
+    // 2026-10-26, Atour). It now takes the type's CHEAPEST rate that sleeps the
+    // stay's guests and has rooms left - and the answer says which rate that
+    // was and that there are others, so the guest is told what they got. Two
+    // types answering to one name, or none, is still no room.
+    const wanted = Math.max(1, clampCount(args.rooms ?? 1, MAX_ROOMS_PER_LINE));
+    let room = dated.rooms.find((r) => r.id === roomRef) ?? namedExactly(dated.rooms, roomRef);
+    let took = '';
+    const type = room ? undefined : roomTypeNamed(dated.rooms, roomRef);
+    if (type) {
+        const fits = type.rooms.filter((r) => r.sleeps >= stay.guests && r.roomsLeft >= wanted);
+        const [first, ...rest] = fits;
+        const cheapest = first
+            ? rest.reduce((a, b) => (b.stayTotal.minor < a.stayTotal.minor ? b : a), first)
+            : undefined;
+        if (cheapest) {
+            room = cheapest;
+            const others = fits.filter((r) => r !== cheapest);
+            took = `Took ${cheapest.name} (\`${cheapest.id}\`) - ${others.length
+                ? `the lowest of ${type.name}'s ${fits.length} rates for these nights; the others: ${others.map((r) => `${r.name} (\`${r.id}\`)`).join(', ')}.`
+                : `${type.name}'s only rate for these nights.`}`;
+        }
+    }
     if (!room) {
+        const han = /\p{Script=Han}/u.test(roomRef);
         return {
             structured: {
                 view: 'error',
@@ -3104,10 +3199,18 @@ const putRoomLine = async (deps, t, ctx, key, store, args, detail) => {
                 })),
                 // The hotel and the nights, so the card can take the guest straight
                 // back to its rooms rather than to the start (round-2 jury).
-                hotel: { id: detail.hotel.id, name: detail.hotel.name },
+                hotel: {
+                    id: detail.hotel.id,
+                    name: detail.hotel.name,
+                    // The card says the hotel in the guest's language (「没能放进行程：…」).
+                    ...(detail.hotel.names ? { names: detail.hotel.names } : {}),
+                },
                 stay,
             },
-            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(', ')}.`,
+            // ⚠️ EVERY OFFER WITH ITS ID: the model that was told "no such room" by
+            // a list of names it had just tried to match by name tried again by name.
+            // The ids are what it can say, and it says them once.
+            text: `${type ? `${detail.hotel.name} has no ${type.name} that sleeps ${stay.guests} and has ${wanted === 1 ? 'a room' : `${wanted} rooms`} left for those nights.` : `${detail.hotel.name} has no room type by that name for those nights.`} It has: ${dated.rooms.map((r) => `${r.name} (${han && r.names?.zh ? `${r.names.zh}, ` : ''}\`${r.id}\`)`).join(', ')}. Call again with the id.`,
         };
     }
     deps.trips.set(store, {
@@ -3117,7 +3220,8 @@ const putRoomLine = async (deps, t, ctx, key, store, args, detail) => {
         stay,
         rooms: clampCount(args.rooms ?? 1, MAX_ROOMS_PER_LINE),
     });
-    return currentTrip(deps, key, identity(deps, ctx, key), store);
+    const now = await currentTrip(deps, key, identity(deps, ctx, key), store);
+    return took ? { ...now, text: `${took}\n${now.text}` } : now;
 };
 /**
  * Books the rooms in one slot of the trip store for a named guest - THE ONE
@@ -4844,6 +4948,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         const plan = await buildItinerary(deps.backend, days.map((d) => ({
             label: str(d.label),
             note: typeof d.note === 'string' ? d.note : undefined,
+            why: typeof d.why === 'string' ? d.why : undefined,
             items: d.items ?? [],
             ...(Array.isArray(d.plan) ? { plan: d.plan } : {}),
         })), {
@@ -4866,15 +4971,28 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         // Each stay as the trip takes it, for a guest who asks in the chat to put
         // the plan in the trip: without the room, the model opened the hotel to
         // find one - another card - before it could add anything.
-        const stays = plan.days
+        //
+        // ⚠️ BY ID, NEVER BY NAME. A model asked "put the stays on this plan in the
+        // trip" added three rooms by the names it remembered and was answered "no
+        // such room" three times, a whole error card each (the owner, 2026-10-26,
+        // Atour). Each priced stay is listed with the hotel id, the room id and the
+        // nights, which is exactly what add_to_trip takes.
+        const stayItems = plan.days
             .flatMap((day) => day.items)
-            .filter((x) => x.kind === 'hotel' && (x.night ?? 1) === 1 && x.checkIn && x.roomId)
-            .map((x) => `${x.name} (\`${x.id}\`) ${x.checkIn} to ${x.checkOut}, room \`${x.roomId}\`${x.booked ? ` - booked, ${x.booked}` : x.inTrip ? ' - in the trip' : ''}`);
+            .filter((x) => x.kind === 'hotel' && (x.night ?? 1) === 1 && x.checkIn && x.roomId);
+        const stays = stayItems.map((x, i) => `Stay ${i + 1}: ${x.name} (\`${x.id}\`), room \`${x.roomId}\`${x.roomName ? ` (${x.roomName})` : ''}, ${x.checkIn} to ${x.checkOut}${x.nights ? ` (${x.nights} ${x.nights === 1 ? 'night' : 'nights'})` : ''}${x.booked ? ` - booked, ${x.booked}` : x.inTrip ? ' - in the trip' : ''}`);
         return {
             structured: { view: 'itinerary', ...common(deps, key), ...plan, gap },
             text: [
                 `**${plan.title}** · ${plan.days.length} ${plan.days.length === 1 ? 'day' : 'days'}. ${gap}`,
-                stays.length ? `Stays, priced on: ${stays.join('; ')}.` : '',
+                ...(stays.length
+                    ? [
+                        `Priced stays (${plan.stay?.guests ?? 2} guests; ${t.addToTrip} takes each one's hotel id, room id and dates):`,
+                        ...stays,
+                        // ⚠️ IN THE TEXT ONLY - not in `structured`, not in the schema.
+                        ...(await longStayNudges(deps, stayItems)),
+                    ]
+                    : []),
                 ...plan.dropped.map((d) => `Left out: ${d.name} — ${d.why}`),
                 ...fitsManyOf(deps, plan.dropped),
                 deps.vocab.demo ? noteFor(deps.vocab) : '',