@curless/hotel-storefront 0.23.1 → 0.24.0

package/dist/tools.d.ts

@@ -1,3 +1,4 @@
+import { type BackendCapabilities } from './backend.js';
 import type { HotelBackend } from './backend.js';
 import type { ToolNames } from './config.js';
 import type { Misses } from './limits.js';
@@ -7,7 +8,12 @@ import type { RoomRequestKind } from './types.js';
 import { type Vocabulary } from './vocab.js';
 /** How many ${nounPlural} one look-up reads - a city's worth, and what a comparison can hold and then some. */
 export declare const LOOK_UP_MAX = 6;
-export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
+/**
+ * The tools this deployment offers: every tool, less the ones its backend
+ * cannot do, and with the descriptions of the rest saying only what is true
+ * of it - see `BackendCapabilities`.
+ */
+export declare const buildTools: (n: ToolNames, v: Vocabulary, caps?: BackendCapabilities) => ({
     readonly name: `list_${string}${string}`;
     readonly description: `${string} ${string}, 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 ${string} it has; \`all\` lists the ${string} themselves. \`city\` (a city or a country) or \`query\` answers with the ${string}: a picture, the city and area, a rating where the ${string} publishes one, and a from-price, and a city usually holds several. With \`checkIn\` and \`checkOut\` every ${string} 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.${string}`;
     readonly annotations: {
@@ -87,7 +93,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
             };
         };
     };
-}, {
+} | {
     readonly name: `get_${string}${string}`;
     readonly description: `One ${string} in full: description, amenities, address, check-in and check-out times. 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 ${string} only, because a room has no price until the nights are known. The ${string} is drawn as a card for the guest to look at.${string}`;
     readonly annotations: {
@@ -123,7 +129,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
         };
         readonly required: readonly ["hotel"];
     };
-}, {
+} | {
     readonly name: `look_up_${string}${string}`;
     readonly description: `Reads up to 6 ${string} - a \`city\`'s (or a country's), or the ones named in \`${string}\` - and returns them as text, with nothing drawn and nothing shown to the guest: each one's id, area, rating, description and amenities, its add-ons with their ids and prices, and, given \`checkIn\` and \`checkOut\`, its rooms priced for those nights with taxes in. The ids are the ones a comparison and a plan take.`;
     readonly annotations: {
@@ -158,7 +164,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
             };
         };
     };
-}, {
+} | {
     readonly name: `list_${string}extras`;
     readonly description: `What one ${string} offers beside the room: airport transfers, dinners, guided experiences, spa and family add-ons, each with its price and whether it is charged per stay, per person or per night, drawn as a card for the guest to look at.`;
     readonly annotations: {
@@ -197,7 +203,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
             };
         };
     };
-}, {
+} | {
     readonly name: `add_to_${string}trip`;
     readonly description: `Puts room nights or an add-on into the trip and returns the whole trip, priced. A room line needs the ${string}, the room type and the dates; \`rooms\` books more than one of that room type. An add-on line needs the ${string} and the add-on. A line is replaced, not stacked: sending the same room and dates again sets that line's room count, and 0 removes it.`;
     readonly annotations: {
@@ -245,7 +251,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
         };
         readonly required: readonly ["hotel"];
     };
-}, {
+} | {
     readonly name: `view_${string}trip`;
     readonly description: "The trip as it stands: every room line and add-on with its own total, the taxes and fees, and the all-in total, laid out day by day on the card.";
     readonly annotations: {
@@ -259,7 +265,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
         readonly type: "object";
         readonly properties: {};
     };
-}, {
+} | {
     readonly name: `clear_${string}trip`;
     readonly description: "Empties the trip.";
     readonly annotations: {
@@ -273,7 +279,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
         readonly type: "object";
         readonly properties: {};
     };
-}, {
+} | {
     readonly name: `request_${string}booking`;
     readonly description: `Asks ${string} to hold the trip's rooms for a named guest and returns a confirmation code and the moment the hold lapses. No payment is taken and no card is collected; the rooms are held, not paid for. Preferences - a bed type, a floor, a late arrival - ride along on the booking as requests the desk tries to meet.`;
     readonly annotations: {
@@ -321,7 +327,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
         };
         readonly required: readonly ["name", "email"];
     };
-}, {
+} | {
     readonly name: `list_my_${string}bookings`;
     readonly description: "The bookings made in this conversation, newest to oldest, with their status, dates and confirmation codes. A booking made elsewhere is added when both its confirmation code and the email it was made with are given.";
     readonly annotations: {
@@ -348,7 +354,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
             };
         };
     };
-}, {
+} | {
     readonly name: `preview_${string}cancellation`;
     readonly description: "What cancelling a booking would cost and what would be refunded, with the rule it was worked out from and the free-cancellation deadline where the rate has one. Nothing is cancelled.";
     readonly annotations: {
@@ -372,7 +378,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
         };
         readonly required: readonly ["booking"];
     };
-}, {
+} | {
     readonly name: `cancel_${string}booking`;
     readonly description: "Cancels a booking. Called without `confirmed` it returns the cancellation preview - the fee, the refund and the rule behind them - and cancels nothing; it cancels only when `confirmed` is true.";
     readonly annotations: {
@@ -404,7 +410,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
         };
         readonly required: readonly ["booking"];
     };
-}, {
+} | {
     readonly name: `preview_${string}booking_change`;
     readonly description: `What moving a booking to other nights, another room type or a different number of rooms - or putting an add-on on it, taking one off or changing how many - would cost: what it holds now, what it would hold, and the difference between them. The new nights are priced at what those nights cost today, not at the rate the booking was made on. A rate that cannot be moved, a ${string} that has no room left for the new nights and a booking that is already gone are each said in those words. Nothing is changed.`;
     readonly annotations: {
@@ -452,7 +458,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
         };
         readonly required: readonly ["booking"];
     };
-}, {
+} | {
     readonly name: `change_${string}booking`;
     readonly description: "Moves a booking to other nights, another room type or a different number of rooms, or sets one of its add-ons (`extra` and `quantity`; 0 takes it off). Called without `confirmed` it returns the same preview - the two stays and the difference - and changes nothing; it changes only when `confirmed` is true. The confirmation code stays the same.";
     readonly annotations: {
@@ -504,7 +510,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
         };
         readonly required: readonly ["booking"];
     };
-}, {
+} | {
     readonly name: `compare_${string}${string}`;
     readonly description: `Puts two to four ${string} side by side as one card. Each column's price, rate, cancellation terms, breakfast and rooms left come from the ${string}'s own record; the arguments carry only the ids, one line on who each suits, and its pros and cons. With \`checkIn\`/\`checkOut\` the columns carry each ${string}'s cheapest room for those nights; without them, a from-price.`;
     readonly annotations: {
@@ -574,7 +580,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
         };
         readonly required: readonly ["entries"];
     };
-}, {
+} | {
     readonly name: `show_${string}itinerary`;
     readonly description: `A day-by-day plan as one card: each day carries its own label, an optional note, the moments of the day in order, and the ${string} and add-ons attached to it, with their details filled in from their own records - a ${string} with its photograph and, given dates, the price of its nights. Each stay is marked with whether it is booked, in the trip or only in the plan, and the card says how many of each. Nothing is added to the trip.`;
     readonly annotations: {
@@ -656,7 +662,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
         };
         readonly required: readonly ["title", "days"];
     };
-}, {
+} | {
     readonly name: `sign_in_${string}member`;
     readonly description: `Signs a ${string} loyalty member in for this conversation with their membership number and the surname on it, and answers with their tier, their point balance and what the tier takes off the public rate. Room rates and trip totals are then quoted at the member rate until they are signed out.`;
     readonly annotations: {
@@ -680,7 +686,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
         };
         readonly required: readonly ["number", "surname"];
     };
-}, {
+} | {
     readonly name: `sign_out_${string}member`;
     readonly description: "Ends the membership sign-in for this conversation. Rates go back to the public ones; the trip and any bookings are left as they are.";
     readonly annotations: {
@@ -694,7 +700,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
         readonly type: "object";
         readonly properties: {};
     };
-}, {
+} | {
     readonly name: `forget_${string}preferences`;
     readonly description: `Forgets the room preferences saved on the signed-in ${string} membership - a bed type, a floor, a quiet or connecting room. Bookings already made keep what they asked for.`;
     readonly annotations: {
@@ -708,7 +714,7 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
         readonly type: "object";
         readonly properties: {};
     };
-}, {
+} | {
     readonly name: `get_${string}${string}_policies`;
     readonly description: `What one ${string} publishes about cancellation, check-in and check-out, children and extra beds, pets, deposits and accessibility. With \`topic\` it returns that topic; without, all of them.`;
     readonly annotations: {
@@ -732,10 +738,17 @@ export declare const buildTools: (n: ToolNames, v: Vocabulary) => readonly [{
         };
         readonly required: readonly ["hotel"];
     };
-}];
+})[];
+/** The tool names a backend with these capabilities leaves out. */
+export declare const withheldTools: (n: ToolNames, caps: BackendCapabilities) => Set<string>;
 export declare const buildOutputSchemas: (n: ToolNames) => Record<string, unknown>;
 export type ToolDeps = {
     backend: HotelBackend;
+    /**
+     * The tool names this deployment offers, when it offers fewer than all -
+     * the card is sent only these, so it draws no button for a missing tool.
+     */
+    offered?: ReadonlySet<string>;
     trips: TripStore;
     members: MemberStore;
     tools: ToolNames;

package/dist/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAI7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAgBhD,OAAO,EAGL,KAAK,SAAS,EAGf,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAYV,eAAe,EAIhB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAa,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAkExD,+GAA+G;AAC/G,eAAO,MAAM,WAAW,IAAI,CAAC;AAE7B,eAAO,MAAM,UAAU,GAAI,GAAG,SAAS,EAAE,GAAG,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6frD,CAAC;AAgFF,eAAO,MAAM,kBAAkB,GAAI,GAAG,SAAS,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAyMtE,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG;IACrB,OAAO,EAAE,YAAY,CAAC;IACtB,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,EAAE,WAAW,CAAC;IACrB,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oFAAoF;IACpF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,0FAA0F;IAC1F,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AA8pB/E;;;;GAIG;AACH,eAAO,MAAM,eAAe,IAAI,CAAC;AA+IjC,eAAO,MAAM,UAAU,GACrB,MAAM,QAAQ,EACd,MAAM,MAAM,EACZ,SAAS,OAAO,EAChB,KAAK,WAAW,KACf,OAAO,CAAC,UAAU,CAMpB,CAAC"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"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"}

package/dist/tools.js

@@ -1,4 +1,4 @@
-import { DEFAULT_PAGE, LASTING_REQUESTS, MAX_PAGE, REQUEST_KINDS, REQUEST_NOTE_MAX, } from './backend.js';
+import { DEFAULT_PAGE, FULL_CAPABILITIES, LASTING_REQUESTS, MAX_PAGE, REQUEST_KINDS, REQUEST_NOTE_MAX, } from './backend.js';
 import { isDay, nights as nightsBetween } from './dates.js';
 import { FACILITIES } from './facilities.js';
 import { DESCRIPTION_MAX, POLICY_MAX, hotelText } from './fence.js';
@@ -63,7 +63,69 @@ const cancels = (title, openWorld) => ({
 const DATE = (what) => ({ type: 'string', description: `${what}, as YYYY-MM-DD` });
 /** How many ${nounPlural} one look-up reads - a city's worth, and what a comparison can hold and then some. */
 export const LOOK_UP_MAX = 6;
-export const buildTools = (n, v) => {
+/**
+ * The tools this deployment offers: every tool, less the ones its backend
+ * cannot do, and with the descriptions of the rest saying only what is true
+ * of it - see `BackendCapabilities`.
+ */
+export const buildTools = (n, v, caps = FULL_CAPABILITIES) => forCapabilities(allTools(n, v), n, v, caps);
+/** The tool names a backend with these capabilities leaves out. */
+export const withheldTools = (n, caps) => new Set([
+    ...(caps.members ? [] : [n.signIn, n.signOut, n.forgetPreferences]),
+    ...(caps.extras ? [] : [n.listExtras]),
+    ...(caps.changes || caps.extras ? [] : [n.previewChange, n.changeBooking]),
+]);
+const forCapabilities = (tools, n, v, caps) => {
+    const withheld = withheldTools(n, caps);
+    const without = (schema, ...keys) => {
+        const s = schema;
+        const properties = { ...(s.properties ?? {}) };
+        for (const k of keys)
+            delete properties[k];
+        return { ...s, properties };
+    };
+    return tools
+        .filter((t) => !withheld.has(t.name))
+        .map((t) => {
+        let out = t;
+        if (!caps.extras) {
+            if (t.name === n.addToTrip) {
+                out = {
+                    ...out,
+                    description: `Puts room nights into the trip and returns the whole trip, priced. A room line needs the ${v.noun}, the room type and the dates; \`rooms\` books more than one of that room type. A line is replaced, not stacked: sending the same room and dates again sets that line's room count, and 0 removes it.`,
+                    inputSchema: without(out.inputSchema, 'extra', 'quantity'),
+                };
+            }
+            if (t.name === n.viewTrip) {
+                out = {
+                    ...out,
+                    description: 'The trip as it stands: every room line with its own total, the taxes and fees, and the all-in total, laid out day by day on the card.',
+                };
+            }
+            if (t.name === n.lookUp) {
+                out = {
+                    ...out,
+                    description: out.description.replace(', its add-ons with their ids and prices', ''),
+                };
+            }
+            if (t.name === n.itinerary) {
+                out = JSON.parse(JSON.stringify(out).replaceAll(' and add-ons', ''));
+            }
+        }
+        if (t.name === n.requestBooking) {
+            if (!caps.members)
+                out = { ...out, inputSchema: without(out.inputSchema, 'rememberRequests') };
+            if (caps.booking === 'pay-at-hotel') {
+                out = {
+                    ...out,
+                    description: `Books the trip's rooms with ${v.brand} for a named guest: each stay becomes the hotel's own reservation, with its own confirmation code, paid at the hotel. No payment is taken here and no card is collected. All of the trip is booked or none of it. Preferences - a bed type, a floor, a late arrival - ride along on the booking as requests the desk tries to meet.`,
+                };
+            }
+        }
+        return out;
+    });
+};
+const allTools = (n, v) => {
     const open = !v.demo;
     const stayProps = {
         checkIn: DATE('The arrival date'),
@@ -578,6 +640,7 @@ const TRIP_SCHEMA = {
         view: { enum: ['trip', 'needs-dates', 'error'] },
         brand: STR,
         toolNames: OBJ,
+        bookingMode: STR,
         vocab: OBJ,
         demo: BOOL,
         demoNote: STR,
@@ -601,6 +664,7 @@ const CANCEL_SCHEMA = {
         view: { enum: ['cancellation-preview', 'cancelled', 'booking-not-found'] },
         brand: STR,
         toolNames: OBJ,
+        bookingMode: STR,
         demo: BOOL,
         demoNote: STR,
         booking: OBJ,
@@ -619,6 +683,7 @@ const CHANGE_SCHEMA = {
         view: { enum: ['change-preview', 'changed', 'booking-not-found'] },
         brand: STR,
         toolNames: OBJ,
+        bookingMode: STR,
         demo: BOOL,
         demoNote: STR,
         booking: OBJ,
@@ -641,6 +706,7 @@ export const buildOutputSchemas = (n) => ({
             view: { enum: ['hotels', 'no-hotels', 'destinations'] },
             brand: STR,
             toolNames: OBJ,
+            bookingMode: STR,
             vocab: OBJ,
             demo: BOOL,
             demoNote: STR,
@@ -669,6 +735,7 @@ export const buildOutputSchemas = (n) => ({
             view: { enum: ['hotel', 'no-rooms', 'hotel-not-found'] },
             brand: STR,
             toolNames: OBJ,
+            bookingMode: STR,
             vocab: OBJ,
             demo: BOOL,
             demoNote: STR,
@@ -693,6 +760,7 @@ export const buildOutputSchemas = (n) => ({
             view: { enum: ['extras', 'hotel-not-found'] },
             brand: STR,
             toolNames: OBJ,
+            bookingMode: STR,
             demo: BOOL,
             demoNote: STR,
             hotel: OBJ,
@@ -709,6 +777,7 @@ export const buildOutputSchemas = (n) => ({
             view: { enum: ['booking', 'needs-guest', 'empty-trip', 'error'] },
             brand: STR,
             toolNames: OBJ,
+            bookingMode: STR,
             demo: BOOL,
             demoNote: STR,
             booking: OBJ,
@@ -729,6 +798,7 @@ export const buildOutputSchemas = (n) => ({
             view: { const: 'bookings' },
             brand: STR,
             toolNames: OBJ,
+            bookingMode: STR,
             demo: BOOL,
             demoNote: STR,
             bookings: ARR,
@@ -746,6 +816,7 @@ export const buildOutputSchemas = (n) => ({
             view: { enum: ['comparison', 'nothing-to-compare'] },
             brand: STR,
             toolNames: OBJ,
+            bookingMode: STR,
             demo: BOOL,
             demoNote: STR,
             title: STR,
@@ -764,6 +835,7 @@ export const buildOutputSchemas = (n) => ({
             view: { enum: ['itinerary', 'empty-itinerary'] },
             brand: STR,
             toolNames: OBJ,
+            bookingMode: STR,
             demo: BOOL,
             demoNote: STR,
             title: STR,
@@ -782,6 +854,7 @@ export const buildOutputSchemas = (n) => ({
             view: { enum: ['member', 'member-not-found'] },
             brand: STR,
             toolNames: OBJ,
+            bookingMode: STR,
             demo: BOOL,
             demoNote: STR,
             member: OBJ,
@@ -799,6 +872,7 @@ export const buildOutputSchemas = (n) => ({
             view: { enum: ['member', 'no-member'] },
             brand: STR,
             toolNames: OBJ,
+            bookingMode: STR,
             member: OBJ,
         },
         required: ['view'],
@@ -811,6 +885,7 @@ export const buildOutputSchemas = (n) => ({
             view: { enum: ['look-up', 'nothing-found'] },
             brand: STR,
             toolNames: OBJ,
+            bookingMode: STR,
             demo: BOOL,
             hotels: ARR,
             stay: OBJ,
@@ -825,6 +900,7 @@ export const buildOutputSchemas = (n) => ({
             view: { enum: ['policy', 'policies', 'policy-missing', 'hotel-not-found'] },
             brand: STR,
             toolNames: OBJ,
+            bookingMode: STR,
             demo: BOOL,
             hotel: OBJ,
             topic: STR,
@@ -872,10 +948,32 @@ const memberBadge = (deps, key) => {
         }
         : { signedIn: false };
 };
+/**
+ * What was made, in one sentence - which depends on what asking MAKES here.
+ *
+ * ⚠️ HELD IS NOT BOOKED, AND BOOKED IS NOT PAID. The demonstration holds rooms
+ * until a moment and then lets them go; a group's own system makes its own
+ * reservation, kept until cancelled and paid at the hotel. Saying "held until"
+ * of a reservation invents a deadline, and saying "booked" of a hold invents a
+ * room - and a booking whose confirmation has not come back yet is neither,
+ * and is said as exactly that.
+ */
+const bookedLine = (deps, b) => {
+    const total = formatMoney(b.quote.total);
+    if ((deps.backend.capabilities ?? FULL_CAPABILITIES).booking === 'pay-at-hotel') {
+        return b.status === 'requested'
+            ? `${total} all in, to be paid at the hotel. ${deps.vocab.brand} has not confirmed this booking yet - that takes up to eight minutes, and ${deps.tools.listBookings} shows when it has. Nothing has been charged.`
+            : `${total} all in, paid at the hotel. **Nothing has been charged here** - this is ${deps.vocab.brand}'s own reservation, kept until it is cancelled, and ${b.guest.name} pays at check-in.`;
+    }
+    return `${total} all in. **Nothing has been charged** - the rooms are held until ${b.holdUntil?.slice(0, 16).replace('T', ' ')} UTC, and ${b.guest.name} presents a card at check-in.`;
+};
 const common = (deps, key) => ({
     brand: deps.vocab.brand,
     ...(deps.logoUrl ? { logoUrl: deps.logoUrl } : {}),
-    toolNames: deps.tools,
+    toolNames: deps.offered
+        ? Object.fromEntries(Object.entries(deps.tools).filter(([, name]) => deps.offered?.has(name)))
+        : deps.tools,
+    bookingMode: (deps.backend.capabilities ?? FULL_CAPABILITIES).booking,
     vocab: { noun: deps.vocab.noun, nounPlural: deps.vocab.nounPlural },
     ...(deps.vocab.demo ? { demo: true, demoNote: DEMO_NOTE } : { demo: false }),
     ...(key ? memberBadge(deps, key) : {}),
@@ -1882,8 +1980,14 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         // which narrowing would make the question answerable.
         const oneCurrency = answer.currencies.length === 1;
         const wantedPrice = sort === 'price-low' || sort === 'price-high';
-        const applied = wantedPrice && !oneCurrency ? 'group' : sort;
+        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;
         const priceNotes = [
+            // What the backend was asked and did not do, in its own words.
+            ...(answer.unapplied ?? []),
             wantedPrice && !oneCurrency
                 ? `These are quoted in ${answer.currencies.length} currencies (${answer.currencies.join(', ')}), and no rate is applied here, so they are not in price order — one city or one country gives one currency.`
                 : '',
@@ -1893,7 +1997,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             answer.overBudget && hotels.length
                 ? `${answer.overBudget} more matched and came in over the ceiling.`
                 : '',
-            asked.filters ? `Filtered to ${filterWords(asked.filters)}.` : '',
+            filtersSaid && filterWords(filtersSaid) ? `Filtered to ${filterWords(filtersSaid)}.` : '',
             // What the prices on a dated list are, in one line - and how many cannot
             // be had at all, so a sold-out hotel is not described as a choice.
             ask.stay
@@ -2054,7 +2158,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             },
             text: [
                 `**${h.name}** · ${enough.length} room ${enough.length === 1 ? 'type' : 'types'} for ${stay.checkIn} to ${stay.checkOut}, ${stay.guests} guests${roomsWanted > 1 ? `, ${roomsWanted} rooms` : ''}.`,
-                ...enough.map((r) => `- ${r.name} — ${formatMoney(r.nightly)} a night, ${formatMoney(r.stayTotal)} for the stay incl. taxes and fees${roomsWanted > 1 ? ` (${formatMoney(multiplyMoney(r.stayTotal, roomsWanted))} for ${roomsWanted} rooms)` : ''}${r.freeCancellationUntil ? `, free to cancel until ${r.freeCancellationUntil.slice(0, 10)}` : r.refundable ? ', the free cancellation window has closed - cancelling costs a night' : ', non-refundable'}`),
+                ...enough.map((r) => `- ${r.name} — ${formatMoney(r.nightly)} a night, ${formatMoney(r.stayTotal)} for the stay incl. taxes and fees${roomsWanted > 1 ? ` (${formatMoney(multiplyMoney(r.stayTotal, roomsWanted))} for ${roomsWanted} rooms)` : ''}${r.freeCancellationUntil ? `, free to cancel until ${r.freeCancellationUntil.slice(0, 10)}` : r.refundable ? ', the free cancellation window has closed - cancelling now has a fee' : ', non-refundable'}`),
                 flex.text,
                 deps.vocab.demo ? DEMO_NOTE : '',
             ]
@@ -2270,7 +2374,9 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                         error: 'no-such-extra',
                         query: extraRef,
                     },
-                    text: `${detail.hotel.name} does not offer that. ${t.listExtras} lists what it has.`,
+                    text: (deps.backend.capabilities ?? FULL_CAPABILITIES).extras
+                        ? `${detail.hotel.name} does not offer that. ${t.listExtras} lists what it has.`
+                        : `${deps.vocab.brand} ${deps.vocab.nounPlural} sell rooms only here - there are no add-ons.`,
                 };
             }
             const line = {
@@ -2469,11 +2575,11 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 },
                 text: [
                     several
-                        ? `${booked.length} bookings, one for each stay - each hotel holds its own nights under its own code, and each is changed or cancelled on its own.`
+                        ? `${booked.length} bookings, one for each stay - each hotel keeps its own nights under its own code, and each is ${(deps.backend.capabilities ?? FULL_CAPABILITIES).changes ? 'changed or cancelled' : 'cancelled'} on its own.`
                         : '',
                     ...booked.flatMap(({ booking, asked }) => [
                         `**${booking.confirmationCode}** · ${booking.hotelName} · ${booking.stay.checkIn} to ${booking.stay.checkOut}`,
-                        `${formatMoney(booking.quote.total)} all in. **Nothing has been charged** - the rooms are held until ${booking.holdUntil?.slice(0, 16).replace('T', ' ')} UTC, and ${booking.guest.name} presents a card at check-in.`,
+                        bookedLine(deps, booking),
                         ...asked,
                     ]),
                     remembered?.line ?? '',
@@ -2737,18 +2843,23 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         const cancelled = await deps.backend.cancelBooking(ref, who, str(args.reason) || undefined);
         if (!cancelled)
             return asPreview;
+        // ⚠️ WHAT THE HOTEL SAYS IT CHARGED, once it has said. A group's own system
+        // answers a cancellation with its penalty; the preview was our reading of
+        // the rate's terms, and where the two differ the hotel's is the one that
+        // will be charged.
+        const charged = cancelled.cancellationFee ?? preview.fee;
         return {
             structured: {
                 view: 'cancelled',
                 ...common(deps, key),
                 booking: { ...cancelled, quote: quoteForCard(cancelled.quote) },
-                fee: formatMoney(preview.fee),
+                fee: formatMoney(charged),
                 refund: formatMoney(preview.refund),
                 rule: preview.rule,
                 cancellable: false,
             },
             text: [
-                `${cancelled.confirmationCode} is cancelled. ${preview.fee.minor === 0 ? 'No fee.' : `The hotel charges ${formatMoney(preview.fee)}.`}`,
+                `${cancelled.confirmationCode} is cancelled. ${charged.minor === 0 ? 'No fee.' : `The hotel charges ${formatMoney(charged)}.`}`,
                 deps.vocab.demo ? DEMO_NOTE : '',
             ]
                 .filter(Boolean)
@@ -2832,10 +2943,18 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         // with one room actually added looks exactly like a booking unless
         // somebody says otherwise, and this counts it rather than describing it.
         const gap = planGap(plan);
+        // 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
+            .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' : ''}`);
         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('; ')}.` : '',
                 ...plan.dropped.map((d) => `Left out: ${d.name} — ${d.why}`),
                 deps.vocab.demo ? DEMO_NOTE : '',
             ]