@fortrip/agent-contract 2.0.0 → 3.0.0

package/dist/index.js

@@ -55,10 +55,10 @@ function passesLuhn(digits) {
 }
 
 // src/commands.ts
-import { z as z3 } from "zod";
+import { z as z6 } from "zod";
 
 // src/inputs.ts
-import { z as z2 } from "zod";
+import { z as z5 } from "zod";
 
 // src/dates.ts
 var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
@@ -79,243 +79,391 @@ function addIsoDateDays(date, days) {
   return value.toISOString().slice(0, 10);
 }
 
-// src/fields.ts
+// src/conventions/ids.ts
 import { z } from "zod";
+function prefixed(prefix, name) {
+  const error = `${name} must be ${prefix}_ followed by 20 letters or digits`;
+  return z.string({ error }).regex(new RegExp(`^${prefix}_[0-9A-Za-z]{20}$`), { error });
+}
+var hotelId = prefixed("htl", "hotelId");
+var offerId = prefixed("off", "offerId");
+var orderId = prefixed("ord", "orderId");
+var placeId = z.string({ error: "placeId must be plc_ followed by 1 to 12 digits" }).regex(/^plc_\d{1,12}$/, {
+  error: "placeId must be plc_ followed by 1 to 12 digits"
+});
+
+// src/conventions/money.ts
+import { z as z2 } from "zod";
+var amountError = "amount must be a decimal string such as 132.40";
+var currencyError = "currency must be a 3-letter uppercase ISO 4217 code";
+var money = z2.looseObject({
+  amount: z2.string({ error: amountError }).regex(/^\d+(\.\d+)?$/, {
+    error: amountError
+  }),
+  currency: z2.string({ error: currencyError }).regex(/^[A-Z]{3}$/, {
+    error: currencyError
+  })
+});
+var usdMoney = z2.strictObject(
+  {
+    amount: z2.string({ error: amountError }).regex(/^\d+(\.\d+)?$/, { error: amountError }).describe("Decimal string such as 132.40, never a number."),
+    currency: z2.literal("USD", { error: "currency must be USD" }).describe("Always USD in a request.")
+  },
+  {
+    error: (issue) => issue.code === "unrecognized_keys" ? `Unknown field(s): ${issue.keys.join(", ")}` : "Expected a Money object"
+  }
+);
+function formatMoney(m) {
+  return `${m.currency} ${m.amount}`;
+}
+
+// src/conventions/time.ts
+import { z as z3 } from "zod";
+var instant = z3.string({ error: "must be an RFC 3339 UTC instant such as 2026-10-23T08:00:00Z" }).regex(/^\d{4}-\d{2}-\d{2}T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?Z$/, {
+  error: "must be an RFC 3339 UTC instant such as 2026-10-23T08:00:00Z"
+}).refine((s) => isIsoDate(s.slice(0, 10)), { error: "must be a real instant" });
+var localDate = z3.string({ error: "must be a real yyyy-MM-dd calendar date" }).refine(isIsoDate, { error: "must be a real yyyy-MM-dd calendar date" });
+var localTime = z3.string({ error: "must be a local time such as 14:00" }).regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/, {
+  error: "must be a local time such as 14:00"
+});
+function isIanaZone(s) {
+  if (!/^[A-Za-z][A-Za-z0-9_+-]*(?:\/[A-Za-z0-9_+-]+)*$/.test(s)) return false;
+  try {
+    new Intl.DateTimeFormat("en", { timeZone: s });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var timeZone = z3.string({ error: "must be an IANA time zone such as Asia/Shanghai" }).refine(isIanaZone, { error: "must be an IANA time zone such as Asia/Shanghai" });
+
+// src/fields.ts
+import { z as z4 } from "zod";
 function strictInput(shape) {
-  return z.strictObject(shape, {
+  return z4.strictObject(shape, {
     error: (issue) => issue.code === "unrecognized_keys" ? `Unknown argument(s): ${issue.keys.join(", ")}` : "Expected a JSON object"
   });
 }
 function wholeNumber(name, min, max) {
   const error = `${name} must be a whole number from ${min} to ${max}`;
-  return z.number({ error }).int({ error }).min(min, { error }).max(max, { error });
-}
-function positiveId(name) {
-  const error = `${name} must be a positive whole number`;
-  return z.number({ error }).int({ error }).positive({ error });
-}
-function isoDate(name) {
-  const error = `${name} must be a real yyyy-MM-dd calendar date`;
-  return z.string({ error }).refine(isIsoDate, { error });
+  return z4.number({ error }).int({ error }).min(min, { error }).max(max, { error });
 }
 function nonEmpty(name) {
   const error = `${name} must be a non-empty string`;
-  return z.string({ error }).min(1, { error });
+  return z4.string({ error }).min(1, { error });
 }
 function text(name, min, max) {
   const error = `${name} must be text of ${min} to ${max} characters`;
-  return z.string({ error }).min(min, { error }).max(max, { error });
+  return z4.string({ error }).min(min, { error }).max(max, { error });
 }
 function oneOf(name, values) {
-  return z.enum(values, {
+  return z4.enum(values, {
     error: `${name} must be one of: ${values.join(", ")}`
   });
 }
 function flag(name) {
-  return z.boolean({ error: `${name} must be true or false` });
-}
-function childrenAges(max) {
-  const error = `childrenAges must list each child's age (0 to 17) in one room, at most ${max}`;
-  return z.array(wholeNumber("Each child's age", 0, 17), { error }).max(max, { error });
+  return z4.boolean({ error: `${name} must be true or false` });
 }
 
 // src/limits.ts
 var LIMITS = {
   rooms: 8,
   adultsPerRoom: 8,
-  childrenPerRoom: 8,
+  childrenPerRoom: 4,
   childAgeMax: 17,
-  nights: 15,
-  ratesHotels: 15,
-  facilities: 10,
-  queryLength: 128,
-  nearRadiusKm: 200,
-  page: 100,
-  pageSize: 50,
+  nightsFortrip: 30,
+  nightsSupplier: 15,
+  offersHotels: 15,
+  offersPerHotelDefault: 5,
+  offersPerHotelMax: 20,
+  pageSizeDefault: 20,
+  pageSizeMax: 50,
+  textLength: 128,
+  radiusMetersMax: 8e4,
+  radiusMetersDefault: 8e3,
+  amenityFilters: 9,
   guestName: 60,
-  contactName: 120,
+  contactFirstName: 59,
+  contactLastName: 59,
   contactPhoneMin: 3,
   contactPhoneMax: 40,
   specialRequests: 500,
-  maxRoomsPerHotel: 200
+  poolLimit: 3e3,
+  candidatesShown: 8,
+  candidatesCounted: 200,
+  localitiesShown: 8
 };
-var BOARD_CODES = [
-  "RO",
-  "BB",
-  "HB",
-  "FB",
-  "BL",
-  "BD",
-  "HBBL",
-  "HBLD",
-  "AI"
+var DISPLAY_CURRENCIES = ["USD", "CNY"];
+var SUPPORT_EMAIL = "info@fortrip.ai";
+
+// src/vocabulary.ts
+var FILTERABLE_AMENITIES = [
+  "parking",
+  "wifi",
+  "laundry",
+  "restaurant",
+  "room_service",
+  "bar",
+  "non_smoking",
+  "business_center",
+  "pool"
+];
+var AMENITY_CODES = [
+  ...FILTERABLE_AMENITIES,
+  "airport_shuttle",
+  "spa",
+  "gym",
+  "accessible",
+  "ev_charging",
+  "air_conditioning",
+  "pets_allowed",
+  "kitchen",
+  "other"
 ];
-var CURRENCIES = ["CNY", "USD"];
 var SEARCH_SORTS = [
-  "recommended",
-  "price-asc",
-  "price-desc",
-  "star-desc",
-  "distance"
+  "distance",
+  "relevance",
+  "stars_desc",
+  "price_asc",
+  "price_desc"
 ];
-var SUPPORT_EMAIL = "info@fortrip.ai";
 
 // src/inputs.ts
-var FACILITY_NAME_MAX = 64;
-var MAX_HOTEL_ID = 2147483647;
-var DEFAULT_MAX_ROOMS_PER_HOTEL = 10;
-var stayDescriptions = {
-  checkIn: "Check-in date, yyyy-MM-dd.",
-  checkOut: `Check-out date, yyyy-MM-dd. Stays are 1 to ${LIMITS.nights} nights.`
-};
-var displayCurrency = oneOf("currency", CURRENCIES).default("CNY").describe(
-  "Currency to show prices in. Prices are converted from the supplier's at Stripe's exchange rate; the response's `fx` says how."
+var locale = oneOf("locale", ["en", "zh"]).describe(
+  "Language for names and text in the response: en or zh."
 );
-function bounded(name, min, max) {
-  const error = `${name} must be a number from ${min} to ${max}`;
-  return z2.number({ error }).min(min, { error }).max(max, { error });
-}
-var queryError = `query must be text of 1 to ${LIMITS.queryLength} characters`;
-var facilitiesError = `facilities must list 1 to ${LIMITS.facilities} catalogue facility names (1 to ${FACILITY_NAME_MAX} characters each)`;
-var radiusError = `near.radiusKm must be more than 0, at most ${LIMITS.nearRadiusKm}`;
-var searchHotelsInput = strictInput({
-  query: z2.string({ error: queryError }).trim().min(1, { error: queryError }).max(LIMITS.queryLength, { error: queryError }).optional().describe(
-    "Hotel name, brand or city to search for. Provide at least one of `query`, `cityCode` or `near`."
-  ),
-  cityCode: positiveId("cityCode").optional().describe("Catalogue city code, as returned in `hotels[].cityCode`."),
-  near: strictInput({
-    lat: bounded("near.lat", -90, 90).describe("Latitude."),
-    lng: bounded("near.lng", -180, 180).describe("Longitude."),
-    radiusKm: z2.number({ error: radiusError }).positive({ error: radiusError }).max(LIMITS.nearRadiusKm, { error: radiusError }).describe("Radius in kilometres.")
-  }).optional().describe("Search around a point."),
-  starMin: bounded("starMin", 0, 5).optional().describe("Lowest star rating to include."),
-  starMax: bounded("starMax", 0, 5).optional().describe("Highest star rating to include."),
-  facilities: z2.array(
-    z2.string({ error: facilitiesError }).trim().min(1, { error: facilitiesError }).max(FACILITY_NAME_MAX, { error: facilitiesError }),
-    { error: facilitiesError }
-  ).min(1, { error: facilitiesError }).max(LIMITS.facilities, { error: facilitiesError }).transform((names) => [...new Set(names)]).optional().describe(
-    "Facilities every hotel must have. Names must match the catalogue exactly (case-insensitive), e.g. `Swimming pool`, `Parking`."
-  ),
-  checkIn: isoDate("checkIn").describe(stayDescriptions.checkIn),
-  checkOut: isoDate("checkOut").describe(stayDescriptions.checkOut),
-  currency: displayCurrency,
-  priceMin: z2.number({ error: "priceMin must be a number, 0 or more" }).nonnegative({ error: "priceMin must be a number, 0 or more" }).optional().describe(
-    "Lowest average nightly price, in `currency`. Applied to indicative prices."
+var displayCurrency = oneOf("displayCurrency", [
+  "USD",
+  "CNY"
+]).describe(
+  "Currency to show prices in, USD or CNY. It never changes what is charged: payment is in USD."
+);
+var cursor = nonEmpty("cursor");
+var nightsError = (name) => `${name} must be after the check-in date and at most ${LIMITS.nightsFortrip} nights later`;
+var stay = strictInput({
+  checkIn: localDate.describe(
+    "Check-in date in the hotel's calendar, yyyy-MM-dd."
   ),
-  priceMax: z2.number({ error: "priceMax must be a number above 0" }).positive({ error: "priceMax must be a number above 0" }).optional().describe("Highest average nightly price, in `currency`."),
-  sortBy: oneOf("sortBy", SEARCH_SORTS).default("recommended").describe(
-    "Result order. `recommended` sorts by distance with `near`, by relevance with `query`, otherwise by catalogue weight. `distance` requires `near`."
+  checkOut: localDate.describe(
+    `Check-out date in the hotel's calendar, yyyy-MM-dd. Stays are 1 to ${LIMITS.nightsFortrip} nights.`
   ),
-  page: wholeNumber("page", 1, LIMITS.page).default(1).describe("Page number."),
-  pageSize: wholeNumber("pageSize", 1, LIMITS.pageSize).default(20).describe("Hotels per page.")
-}).superRefine((input, ctx) => {
-  if (!input.query && input.cityCode === void 0 && !input.near) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["query"],
-      message: "Provide query, cityCode or near"
-    });
-  }
-  if (input.sortBy === "distance" && !input.near) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["sortBy"],
-      message: "distance sort requires near"
-    });
-  }
-  if (input.starMin !== void 0 && input.starMax !== void 0 && input.starMin > input.starMax) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["starMax"],
-      message: "starMax must be >= starMin"
-    });
-  }
-  if (input.priceMin !== void 0 && input.priceMax !== void 0 && input.priceMin > input.priceMax) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["priceMax"],
-      message: "priceMax must be >= priceMin"
-    });
-  }
-  if (!isIsoDate(input.checkIn) || !isIsoDate(input.checkOut)) return;
-  const earliest = addIsoDateDays((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), -1);
-  if (input.checkIn < earliest) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["checkIn"],
-      message: "checkIn must not be in the past"
-    });
-  }
-  const nights = countIsoDateDays(input.checkIn, input.checkOut);
-  if (nights < 1) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["checkOut"],
-      message: "checkOut must be after checkIn"
-    });
-  } else if (nights > LIMITS.nights) {
+  rooms: z5.array(
+    strictInput({
+      adults: wholeNumber("adults", 1, LIMITS.adultsPerRoom).describe(
+        "Adults in this room."
+      ),
+      childrenAges: z5.array(wholeNumber("Each child's age", 0, LIMITS.childAgeMax), {
+        error: `childrenAges must list each child's age (0 to ${LIMITS.childAgeMax}) in this room, at most ${LIMITS.childrenPerRoom}`
+      }).max(LIMITS.childrenPerRoom, {
+        error: `childrenAges must list each child's age (0 to ${LIMITS.childAgeMax}) in this room, at most ${LIMITS.childrenPerRoom}`
+      }).describe(
+        "Age of each child in this room, 0 to 17. An empty list means no children."
+      )
+    }),
+    { error: `rooms must list 1 to ${LIMITS.rooms} rooms` }
+  ).min(1, { error: `rooms must list 1 to ${LIMITS.rooms} rooms` }).max(LIMITS.rooms, {
+    error: `rooms must list 1 to ${LIMITS.rooms} rooms`
+  }).describe(
+    `The rooms wanted, 1 to ${LIMITS.rooms}, each with its own party.`
+  )
+}).superRefine((value, ctx) => {
+  if (!isIsoDate(value.checkIn) || !isIsoDate(value.checkOut)) return;
+  const nights = countIsoDateDays(value.checkIn, value.checkOut);
+  if (nights < 1 || nights > LIMITS.nightsFortrip) {
     ctx.addIssue({
       code: "custom",
       path: ["checkOut"],
-      message: `search supports at most ${LIMITS.nights} nights`
+      message: nightsError("checkOut")
     });
   }
 });
-var hotelIdError = "hotelId must be a positive whole number";
-var getHotelInput = z2.object(
+var countryCode = z5.string({ error: "countryCode must be an ISO 3166-1 alpha-2 code" }).regex(/^[A-Z]{2}$/, {
+  error: "countryCode must be 2 uppercase letters (ISO 3166-1 alpha-2)"
+});
+var radiusMeters = wholeNumber("radiusMeters", 1, LIMITS.radiusMetersMax).optional().describe(
+  `Search radius around the destination in meters, 1 to ${LIMITS.radiusMetersMax}. Left out, the service picks one.`
+);
+function bounded(name, min, max) {
+  const error = `${name} must be a number from ${min} to ${max}`;
+  return z5.number({ error }).min(min, { error }).max(max, { error });
+}
+var KINDS = ["place_name", "place", "point", "country", "locality"];
+var destination = z5.discriminatedUnion(
+  "kind",
+  [
+    strictInput({
+      kind: z5.literal("place_name", { error: "kind must be place_name" }).describe("A place named in words, with its country."),
+      name: text("name", 1, LIMITS.textLength).describe(
+        "The place name, in any language, e.g. Tokyo or \u4E1C\u4EAC."
+      ),
+      countryCode: countryCode.describe(
+        "ISO 3166-1 alpha-2 country the place is in, e.g. JP."
+      ),
+      radiusMeters
+    }),
+    strictInput({
+      kind: z5.literal("place", { error: "kind must be place" }).describe("A place id from an earlier response."),
+      placeId: placeId.describe("placeId from an earlier response."),
+      radiusMeters
+    }),
+    strictInput({
+      kind: z5.literal("point", { error: "kind must be point" }).describe("A point on the map."),
+      location: strictInput({
+        lat: bounded("lat", -90, 90).describe("Latitude, WGS84."),
+        lng: bounded("lng", -180, 180).describe("Longitude, WGS84.")
+      }).describe("The point, WGS84."),
+      radiusMeters
+    }),
+    strictInput({
+      kind: z5.literal("country", { error: "kind must be country" }).describe("A whole country."),
+      countryCode: countryCode.describe("ISO 3166-1 alpha-2 country, e.g. JP.")
+    }),
+    strictInput({
+      kind: z5.literal("locality", { error: "kind must be locality" }).describe("A locality (hub) listed in an earlier search response."),
+      placeId: placeId.describe("placeId of the locality."),
+      radiusMeters
+    })
+  ],
   {
-    hotelId: z2.coerce.number({ error: hotelIdError }).int({ error: hotelIdError }).positive({ error: hotelIdError }).max(MAX_HOTEL_ID, { error: hotelIdError }).describe("hotelId from search_hotels"),
-    includeRooms: flag("includeRooms").optional().describe("Also return the catalogue room list (adds a few KB)")
-  },
-  { error: "Expected a JSON object" }
+    error: `destination.kind must be one of: ${KINDS.join(", ")}`
+  }
 );
-var hotelIdsError = `hotelIds must list 1 to ${LIMITS.ratesHotels} hotelIds`;
-var boardCodesError = `boardCodes must list meal codes from: ${BOARD_CODES.join(", ")}`;
-var getRatesInput = strictInput({
-  hotelIds: z2.array(positiveId("Each hotelId"), { error: hotelIdsError }).min(1, { error: hotelIdsError }).max(LIMITS.ratesHotels, { error: hotelIdsError }).describe("Hotels to price. Each call takes about 15 seconds."),
-  checkIn: isoDate("checkIn").describe(stayDescriptions.checkIn),
-  checkOut: isoDate("checkOut").describe(stayDescriptions.checkOut),
-  rooms: wholeNumber("rooms", 1, LIMITS.rooms).describe(
-    "Number of rooms; every room has the same occupancy"
-  ),
-  adults: wholeNumber("adults (per room)", 1, LIMITS.adultsPerRoom).describe(
-    "Adults per room, not in total (2 rooms for 4 adults = rooms 2, adults 2)"
-  ),
-  childrenAges: childrenAges(LIMITS.childrenPerRoom).optional().describe("Age of each child in one room (0-17), per room"),
-  nationality: z2.string({ error: "nationality must be a 2-letter ISO 3166-1 code" }).regex(/^[A-Z]{2}$/, {
-    error: "nationality must be a 2-letter ISO 3166-1 code, upper case"
+var textQuery = z5.string({
+  error: `text must be text of 1 to ${LIMITS.textLength} characters`
+}).trim().min(1, {
+  error: `text must be text of 1 to ${LIMITS.textLength} characters`
+}).max(LIMITS.textLength, {
+  error: `text must be text of 1 to ${LIMITS.textLength} characters`
+});
+var starsError = "must be from 1 to 5 in steps of 0.5";
+function starBound(name) {
+  return z5.number({ error: `${name} ${starsError}` }).min(1, { error: `${name} ${starsError}` }).max(5, { error: `${name} ${starsError}` }).refine((value) => Number.isInteger(value * 2), {
+    error: `${name} ${starsError}`
+  });
+}
+var amenitiesError = `amenities must list 1 to ${LIMITS.amenityFilters} codes from: ${AMENITY_CODES.join(", ")}`;
+var searchFilters = strictInput({
+  stars: strictInput({
+    min: starBound("stars.min").optional().describe("Lowest star rating, 1 to 5 in steps of 0.5."),
+    max: starBound("stars.max").optional().describe("Highest star rating, 1 to 5 in steps of 0.5.")
+  }).superRefine((value, ctx) => {
+    if (value.min !== void 0 && value.max !== void 0 && value.min > value.max) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["max"],
+        message: "stars.max must be at least stars.min"
+      });
+    }
   }).optional().describe(
-    "Guest nationality, ISO 3166-1 alpha-2 in upper case, e.g. `CN`. Some rates are restricted by nationality; booking doesn't send it, so such a rate may change or be refused at booking"
+    "Star rating range. Unrated hotels are left out whenever it is set."
   ),
-  currency: displayCurrency,
-  // One hotel can return thousands of rate plans; these keep a response
-  // small enough for an agent's context.
-  bookableOnly: flag("bookableOnly").default(true).describe("Keep only rates that are bookable on every night."),
-  boardCodes: z2.array(oneOf("Each boardCode", BOARD_CODES), { error: boardCodesError }).min(1, { error: boardCodesError }).optional().describe(
-    "Keep only these meal plans: `RO` room only, `BB` breakfast, `HB` half board, `FB` full board, `AI` all inclusive, and so on."
+  amenities: z5.array(oneOf("Each amenity", AMENITY_CODES), { error: amenitiesError }).min(1, { error: amenitiesError }).max(LIMITS.amenityFilters, { error: amenitiesError }).optional().describe(
+    "Amenities every hotel must list. Only some codes can filter; asking for one that cannot is answered with the list that can."
+  ),
+  price: strictInput({
+    maxPerRoomNight: usdMoney.describe(
+      "Highest price per room per night, in USD."
+    )
+  }).optional().describe("Price limit. Needs indicative pricing, so a stay.")
+}).optional().describe("Filters every hotel in the answer must pass.");
+var NEXT_PAGE_KEYS = /* @__PURE__ */ new Set(["cursor", "limit"]);
+function createSearchHotelsInput(now = Date.now) {
+  return strictInput({
+    destination: destination.optional().describe("Where to search. A first page needs this or `text`."),
+    text: textQuery.optional().describe(
+      `Hotel name, brand or area to match, 1 to ${LIMITS.textLength} characters. A first page needs this or \`destination\`.`
+    ),
+    stay: stay.optional().describe(
+      "Dates and party. Needed for indicative prices. Search uses only the dates when the rooms differ."
+    ),
+    pricing: oneOf("pricing", ["indicative", "none"]).optional().describe(
+      "`indicative` adds an approximate price per hotel and needs a stay; `none` skips prices. Default: indicative with a stay, otherwise none."
+    ),
+    filters: searchFilters,
+    sort: oneOf("sort", SEARCH_SORTS).optional().describe(
+      "Result order. `distance` needs a destination, `relevance` needs `text`, `price_asc` and `price_desc` need indicative pricing. Default: relevance with `text`, otherwise distance."
+    ),
+    limit: wholeNumber("limit", 1, LIMITS.pageSizeMax).optional().describe(
+      `Hotels per page, 1 to ${LIMITS.pageSizeMax}. Default ${LIMITS.pageSizeDefault}.`
+    ),
+    cursor: cursor.optional().describe(
+      "`nextCursor` from the previous response. A next page is the cursor and, optionally, `limit`; nothing else."
+    ),
+    locale: locale.optional(),
+    displayCurrency: displayCurrency.optional()
+  }).superRefine((input, ctx) => {
+    const issue = (path, message) => ctx.addIssue({ code: "custom", path, message });
+    if (input.cursor !== void 0) {
+      for (const [key, value] of Object.entries(input)) {
+        if (value !== void 0 && !NEXT_PAGE_KEYS.has(key)) {
+          issue(
+            [key],
+            `${key} cannot be sent with cursor: a next page is the cursor and limit only`
+          );
+        }
+      }
+      return;
+    }
+    if (input.destination === void 0 && input.text === void 0) {
+      issue(["destination"], "Provide a destination or text");
+    }
+    if (input.sort === "distance" && input.destination === void 0) {
+      issue(["sort"], "sort distance needs a destination");
+    }
+    if (input.sort === "relevance" && input.text === void 0) {
+      issue(["sort"], "sort relevance needs text");
+    }
+    const indicative = (input.pricing ?? (input.stay ? "indicative" : "none")) === "indicative";
+    if (input.pricing === "indicative" && input.stay === void 0) {
+      issue(["stay"], "pricing indicative needs a stay");
+    }
+    if (!indicative) {
+      const reason = input.pricing === "none" ? 'pricing is "none"' : "there is no stay";
+      if (input.sort === "price_asc" || input.sort === "price_desc") {
+        issue(
+          ["sort"],
+          `${input.sort} needs indicative pricing, but ${reason}`
+        );
+      }
+      if (input.filters?.price !== void 0) {
+        issue(
+          ["filters", "price"],
+          `filters.price needs indicative pricing, but ${reason}`
+        );
+      }
+    }
+    const checkIn = input.stay?.checkIn;
+    if (checkIn !== void 0 && isIsoDate(checkIn)) {
+      const earliest = new Date(now() - 12 * 36e5).toISOString().slice(0, 10);
+      if (checkIn < earliest) {
+        issue(["stay", "checkIn"], "stay.checkIn must not be in the past");
+      }
+    }
+  });
+}
+var searchHotelsInput = createSearchHotelsInput();
+var getHotelInput = strictInput({
+  hotelId: hotelId.describe("hotelId from a search response."),
+  include: oneOf("include", ["rooms"]).optional().describe("`rooms` adds the room list."),
+  locale: locale.optional()
+});
+var hotelIdsError = `hotelIds must list 1 to ${LIMITS.offersHotels} distinct hotelIds`;
+var hotelOffersInput = strictInput({
+  hotelIds: z5.array(hotelId, { error: hotelIdsError }).min(1, { error: hotelIdsError }).max(LIMITS.offersHotels, { error: hotelIdsError }).refine((ids) => new Set(ids).size === ids.length, {
+    error: hotelIdsError
+  }).describe(`Hotels to price, 1 to ${LIMITS.offersHotels}, no repeats.`),
+  stay: stay.describe(
+    "Dates and party. One party per call: every room must be the same."
   ),
-  freeCancellation: flag("freeCancellation").optional().describe(
-    "Keep only rates that can still be cancelled free of charge right now."
+  filters: strictInput({
+    requireBreakfast: flag("requireBreakfast").optional().describe("Keep only offers that include breakfast."),
+    requireFreeCancellation: flag("requireFreeCancellation").optional().describe("Keep only offers that can still be cancelled free of charge.")
+  }).optional().describe("Filters every offer must pass."),
+  limitPerHotel: wholeNumber("limitPerHotel", 1, LIMITS.offersPerHotelMax).default(LIMITS.offersPerHotelDefault).describe(
+    `Offers per hotel, 1 to ${LIMITS.offersPerHotelMax}. Default ${LIMITS.offersPerHotelDefault}.`
   ),
-  maxRoomsPerHotel: wholeNumber("maxRoomsPerHotel", 1, LIMITS.maxRoomsPerHotel).default(DEFAULT_MAX_ROOMS_PER_HOTEL).describe(
-    "Return the N cheapest rooms per hotel. The MCP tool defaults to 5, the CLI to 10."
-  )
-}).superRefine((input, ctx) => {
-  if (!isIsoDate(input.checkIn) || !isIsoDate(input.checkOut)) return;
-  const nights = countIsoDateDays(input.checkIn, input.checkOut);
-  if (nights < 1) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["checkOut"],
-      message: "checkOut must be after checkIn"
-    });
-  } else if (nights > LIMITS.nights) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["checkOut"],
-      message: `rates support at most ${LIMITS.nights} nights`
-    });
-  }
+  locale: locale.optional(),
+  displayCurrency: displayCurrency.optional()
 });
 function cardFreeText(name, min, max, minDigits) {
   return text(name, min, max).refine(
@@ -334,271 +482,322 @@ function guestName(name) {
     { error: GUEST_NAME_MESSAGE }
   );
 }
+function contactName(name, max) {
+  return z5.string({ error: `${name} must be text of 1 to ${max} characters` }).refine((value) => !containsCardNumber(value), {
+    error: CARD_NUMBER_MESSAGE,
+    abort: true
+  }).refine(
+    (value) => {
+      const length = normalizeGuestName(value).length;
+      return length >= 1 && length <= max;
+    },
+    { error: `${name} must be text of 1 to ${max} characters` }
+  );
+}
+var emailError = "email must be an email address";
 var guestsError = "guests must list at least one guest per room";
-var roomNoError = `roomNo must be a whole number from 1 to ${LIMITS.rooms}`;
-var contactEmailError = "contactEmail must be an email address";
-var createBookingInput = strictInput({
-  hotelId: positiveId("hotelId").describe("Hotel id."),
-  roomId: nonEmpty("roomId").describe("roomId from get_hotel_rates"),
-  ratePlanCode: nonEmpty("ratePlanCode").describe(
-    "ratePlanCode from get_hotel_rates"
-  ),
-  checkIn: isoDate("checkIn").describe(stayDescriptions.checkIn),
-  checkOut: isoDate("checkOut").describe(stayDescriptions.checkOut),
-  rooms: wholeNumber("rooms", 1, LIMITS.rooms).describe(
-    "Number of rooms, as in get_hotel_rates; every room has the same occupancy"
-  ),
-  adults: wholeNumber("adults (per room)", 1, LIMITS.adultsPerRoom).describe(
-    "Adults per room, not in total, as in get_hotel_rates (2 rooms for 4 adults = rooms 2, adults 2)"
-  ),
-  childrenAges: childrenAges(LIMITS.childrenPerRoom).default([]).describe(
-    "Age of each child in one room (0-17), per room, as in get_hotel_rates"
-  ),
-  guests: z2.array(
+var maxGuestsPerRoom = LIMITS.adultsPerRoom + LIMITS.childrenPerRoom;
+var createOrderInput = strictInput({
+  contact: strictInput({
+    firstName: contactName("firstName", LIMITS.contactFirstName).describe(
+      `Contact person's first name, at most ${LIMITS.contactFirstName} characters.`
+    ),
+    lastName: contactName("lastName", LIMITS.contactLastName).describe(
+      `Contact person's last name, at most ${LIMITS.contactLastName} characters.`
+    ),
+    email: z5.string({ error: emailError }).trim().pipe(z5.email({ error: emailError })).describe("Contact email; the confirmation is sent here."),
+    // Only cards of 16+ digits: a phone number has at most 15 (E.164).
+    phone: cardFreeText(
+      "phone",
+      LIMITS.contactPhoneMin,
+      LIMITS.contactPhoneMax,
+      16
+    ).describe("Contact phone number, with country code.")
+  }).describe("Who the hotel and the confirmation reach."),
+  items: z5.array(
     strictInput({
-      firstName: guestName("firstName").describe("First name."),
-      lastName: guestName("lastName").describe("Last name."),
-      // A numeric string ("1") booked before; the action takes either.
-      roomNo: z2.coerce.number({ error: roomNoError }).int({ error: roomNoError }).min(1, { error: roomNoError }).max(LIMITS.rooms, { error: roomNoError }).describe("Room the guest stays in, starting at 1.")
+      offerId: offerId.describe("offerId from an offers response."),
+      hotel: strictInput({
+        rooms: z5.array(
+          strictInput({
+            guests: z5.array(
+              strictInput({
+                firstName: guestName("firstName").describe(
+                  "Guest's first name, in Latin letters as on the passport; transliterate accents (M\xFCller \u2192 Mueller)."
+                ),
+                lastName: guestName("lastName").describe(
+                  "Guest's last name, in Latin letters as on the passport."
+                )
+              }),
+              { error: guestsError }
+            ).min(1, { error: guestsError }).max(maxGuestsPerRoom, {
+              error: `guests must list at most ${maxGuestsPerRoom} guests per room`
+            }).describe(
+              "Guests staying in this room: at least one, no more than the room sleeps."
+            )
+          }),
+          { error: `rooms must list 1 to ${LIMITS.rooms} rooms` }
+        ).min(1, { error: `rooms must list 1 to ${LIMITS.rooms} rooms` }).max(LIMITS.rooms, {
+          error: `rooms must list 1 to ${LIMITS.rooms} rooms`
+        }).describe("One entry per room of the offer, in order."),
+        specialRequests: cardFreeText(
+          "specialRequests",
+          0,
+          LIMITS.specialRequests
+        ).optional().describe("Requests for the hotel, in English. Not guaranteed.")
+      }).describe("What the hotel needs to know.")
     }),
-    { error: guestsError }
-  ).min(1, { error: guestsError }).describe(
-    "At least one guest per room, no more than the room sleeps. Names in Latin letters as on the passport; transliterate accents (M\xFCller \u2192 Mueller)."
-  ),
-  contactName: cardFreeText("contactName", 1, LIMITS.contactName).describe(
-    "Contact person for the booking."
+    { error: "items must list exactly one offer" }
+  ).min(1, { error: "items must list exactly one offer" }).max(1, { error: "items must list exactly one offer" }).describe("The offer to book. Exactly one in v1.")
+});
+var getOrderInput = strictInput({
+  orderId: orderId.describe("orderId from create order or list orders."),
+  locale: locale.optional()
+});
+var listLimitError = `limit must be a whole number from 1 to ${LIMITS.pageSizeMax}`;
+var listOrdersInput = strictInput({
+  cursor: cursor.optional().describe("`nextCursor` from the previous page of orders."),
+  limit: z5.coerce.number({ error: listLimitError }).int({ error: listLimitError }).min(1, { error: listLimitError }).max(LIMITS.pageSizeMax, { error: listLimitError }).optional().describe(
+    `Orders per page, 1 to ${LIMITS.pageSizeMax}. Default ${LIMITS.pageSizeDefault}.`
   ),
-  // Only cards of 16+ digits: a phone number has at most 15 (E.164), so
-  // its digits aren't mistaken for a card.
-  contactPhone: cardFreeText(
-    "contactPhone",
-    LIMITS.contactPhoneMin,
-    LIMITS.contactPhoneMax,
-    16
-  ).describe("Contact phone number."),
-  // Blank means none, as it did before: the booking sends no email then.
-  contactEmail: z2.string({ error: contactEmailError }).trim().refine((value) => value === "" || z2.email().safeParse(value).success, {
-    error: contactEmailError
-  }).optional().describe("Contact email."),
-  specialRequests: cardFreeText("specialRequests", 0, LIMITS.specialRequests).optional().describe("Requests for the hotel, in English. Not guaranteed.")
-}).superRefine((input, ctx) => {
-  if (!isIsoDate(input.checkIn) || !isIsoDate(input.checkOut)) return;
-  const nights = countIsoDateDays(input.checkIn, input.checkOut);
-  if (nights < 1) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["checkOut"],
-      message: "checkOut must be after checkIn"
-    });
-  } else if (nights > LIMITS.nights) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["checkOut"],
-      message: `A booking covers at most ${LIMITS.nights} nights; book a longer stay as separate bookings`
-    });
-  }
+  locale: locale.optional()
 });
 
 // src/commands.ts
-function fieldDescription(json, field) {
+function fieldDescription(json, field, sets = {}) {
   let node = json;
+  const path = [];
   for (const part of field.split(".")) {
-    node = (node?.properties ?? node?.items?.properties)?.[part];
+    if (node?.type === "array") node = node.items;
+    const at = path.join(".");
+    const variants = node?.oneOf ?? node?.anyOf ?? (node ? [node] : []);
+    node = variants.find(
+      (variant) => variant.properties?.[part] && Object.entries(sets).every(
+        ([key, value]) => !key.startsWith(`${at}.`) || variant.properties?.[key.slice(at.length + 1)]?.const === value
+      )
+    )?.properties?.[part];
+    path.push(part);
   }
   if (!node?.description) throw new Error(`No description for field ${field}`);
   return node.description;
 }
 function flagsOf(input, defs) {
-  const json = z3.toJSONSchema(input, { io: "input" });
+  const json = z6.toJSONSchema(input, { io: "input" });
   return defs.map((def) => ({
     ...def,
-    description: def.description ?? fieldDescription(json, def.field)
+    description: def.description ?? fieldDescription(json, def.field, def.sets)
   }));
 }
-var ID = "<id>";
+function positional(input, name, description) {
+  const json = z6.toJSONSchema(input, { io: "input" });
+  return {
+    name,
+    field: name,
+    description: description ?? fieldDescription(json, name)
+  };
+}
 var COUNT = "<n>";
 var DATE = "YYYY-MM-DD";
+var ROOM = "<adults[:age,\u2026]>";
+var LOCALES = "en|zh";
+var kind = (value) => ({ "destination.kind": value });
+var localeFlag = {
+  flag: "locale",
+  field: "locale",
+  type: "string",
+  placeholder: LOCALES
+};
+var displayCurrencyFlag = {
+  flag: "display-currency",
+  field: "displayCurrency",
+  type: "string",
+  placeholder: DISPLAY_CURRENCIES.join("|")
+};
+function stayFlags(roomDescription) {
+  return [
+    { flag: "check-in", field: "stay.checkIn", type: "string", placeholder: DATE },
+    { flag: "check-out", field: "stay.checkOut", type: "string", placeholder: DATE },
+    {
+      flag: "room",
+      field: "stay.rooms",
+      type: "string",
+      multiple: true,
+      placeholder: ROOM,
+      description: roomDescription
+    }
+  ];
+}
+var ROOM_FORMAT = "as `adults` or `adults:age,age` with each child's age, e.g. `2` or `2:6,9`";
 var searchFlags = flagsOf(searchHotelsInput, [
   {
-    flag: "query",
-    short: "q",
-    field: "query",
+    flag: "place-name",
+    field: "destination.name",
     type: "string",
-    placeholder: "<text>",
-    description: "Hotel name, brand or city to search for. Provide at least one of `--query`, `--city-code` or `--near`."
+    sets: kind("place_name"),
+    placeholder: "<name>",
+    description: "Search a place by its name, in any language (e.g. Tokyo or \u4E1C\u4EAC), with its country in `--country`."
   },
-  { flag: "city-code", field: "cityCode", type: "id", placeholder: COUNT },
   {
-    flag: "near",
-    field: "near",
+    flag: "country",
+    field: "destination.countryCode",
     type: "string",
-    placeholder: "<lat,lng,km>",
-    description: `Search around a point, as \`lat,lng,radiusKm\` (radius up to ${LIMITS.nearRadiusKm}), e.g. \`13.75,100.5,5\`.`
+    sets: kind("place_name"),
+    placeholder: "<CC>",
+    description: "The country of `--place-name`, ISO 3166-1 alpha-2, e.g. JP."
   },
-  { flag: "check-in", field: "checkIn", type: "string", placeholder: DATE },
-  { flag: "check-out", field: "checkOut", type: "string", placeholder: DATE },
-  { flag: "star-min", field: "starMin", type: "number", placeholder: COUNT },
-  { flag: "star-max", field: "starMax", type: "number", placeholder: COUNT },
   {
-    flag: "facility",
-    field: "facilities",
+    flag: "place",
+    field: "destination.placeId",
     type: "string",
-    multiple: true,
-    placeholder: "<name>"
+    sets: kind("place"),
+    placeholder: "<plc_>",
+    description: "Search a place by its placeId from an earlier answer."
   },
-  { flag: "price-min", field: "priceMin", type: "number", placeholder: COUNT },
-  { flag: "price-max", field: "priceMax", type: "number", placeholder: COUNT },
   {
-    flag: "sort",
-    field: "sortBy",
+    flag: "locality",
+    field: "destination.placeId",
     type: "string",
-    placeholder: SEARCH_SORTS.join("|")
+    sets: kind("locality"),
+    placeholder: "<plc_>",
+    description: "Search a locality by its placeId, as an earlier search listed it under localities."
   },
-  { flag: "page", field: "page", type: "number", placeholder: COUNT },
-  { flag: "page-size", field: "pageSize", type: "number", placeholder: COUNT },
   {
-    flag: "currency",
-    field: "currency",
+    flag: "point",
+    field: "destination.location",
     type: "string",
-    placeholder: CURRENCIES.join("|")
-  }
-]);
-var hotelFlags = flagsOf(getHotelInput, [
-  { flag: "with-rooms", field: "includeRooms", type: "boolean" }
-]);
-var ratesFlags = flagsOf(getRatesInput, [
-  {
-    flag: "hotel",
-    field: "hotelIds",
-    type: "id",
-    multiple: true,
-    placeholder: ID,
-    description: `Hotels to price, by id from \`hotels search\`: repeat the flag or comma-separate, up to ${LIMITS.ratesHotels}. Each call takes about 15 seconds.`
+    sets: kind("point"),
+    placeholder: "<lat,lng>",
+    description: "Search around a point, as `lat,lng` (WGS84), e.g. `13.75,100.5`."
   },
-  { flag: "check-in", field: "checkIn", type: "string", placeholder: DATE },
-  { flag: "check-out", field: "checkOut", type: "string", placeholder: DATE },
-  { flag: "rooms", field: "rooms", type: "number", placeholder: COUNT },
   {
-    flag: "adults",
-    field: "adults",
-    type: "number",
-    placeholder: COUNT,
-    description: "Adults per room, not in total (2 rooms for 4 adults = `--rooms 2 --adults 2`)"
+    flag: "country-only",
+    field: "destination.countryCode",
+    type: "string",
+    sets: kind("country"),
+    placeholder: "<CC>",
+    description: "Search a whole country, ISO 3166-1 alpha-2, e.g. JP."
   },
   {
-    flag: "child-age",
-    field: "childrenAges",
+    flag: "radius-meters",
+    field: "destination.radiusMeters",
     type: "number",
-    multiple: true,
-    placeholder: "<age>"
+    placeholder: COUNT
   },
   {
-    flag: "nationality",
-    field: "nationality",
+    flag: "text",
+    field: "text",
     type: "string",
-    placeholder: "<CC>"
+    placeholder: "<text>",
+    description: `Hotel name, brand or area to match, 1 to ${LIMITS.textLength} characters. A first page needs this or a destination.`
   },
+  ...stayFlags(
+    `A room, ${ROOM_FORMAT}. Repeat for each room, up to ${LIMITS.rooms}; rooms may differ.`
+  ),
   {
-    flag: "board",
-    field: "boardCodes",
+    flag: "pricing",
+    field: "pricing",
     type: "string",
-    multiple: true,
-    placeholder: BOARD_CODES.join("|")
-  },
-  { flag: "free-cancellation", field: "freeCancellation", type: "boolean" },
-  {
-    flag: "include-unbookable",
-    field: "bookableOnly",
-    type: "boolean",
-    description: "Also keep rates that are not bookable on every night (by default only bookable rates are returned)."
+    placeholder: "indicative|none"
   },
+  { flag: "stars-min", field: "filters.stars.min", type: "number", placeholder: COUNT },
+  { flag: "stars-max", field: "filters.stars.max", type: "number", placeholder: COUNT },
   {
-    flag: "max-rooms",
-    field: "maxRoomsPerHotel",
-    type: "number",
-    placeholder: COUNT,
-    description: "Return the N cheapest rooms per hotel. Default 10."
+    flag: "amenity",
+    field: "filters.amenities",
+    type: "string",
+    multiple: true,
+    placeholder: FILTERABLE_AMENITIES.join("|"),
+    description: `An amenity every hotel must list; repeat for each, up to ${LIMITS.amenityFilters}.`
   },
   {
-    flag: "currency",
-    field: "currency",
+    flag: "price-max-per-room-night",
+    field: "filters.price.maxPerRoomNight",
     type: "string",
-    placeholder: CURRENCIES.join("|")
-  }
-]);
-var bookFlags = flagsOf(createBookingInput, [
-  { flag: "hotel", field: "hotelId", type: "id", placeholder: ID },
+    placeholder: "<USD decimal>",
+    description: "Highest indicative price per room per night, in USD, e.g. `150` or `149.50`. Needs a stay."
+  },
   {
-    flag: "room-id",
-    field: "roomId",
+    flag: "sort",
+    field: "sort",
     type: "string",
-    placeholder: ID,
-    description: "`roomId` from `hotels rates`"
+    placeholder: SEARCH_SORTS.join("|")
   },
+  { flag: "limit", field: "limit", type: "number", placeholder: COUNT },
   {
-    flag: "rate-plan",
-    field: "ratePlanCode",
+    flag: "cursor",
+    field: "cursor",
     type: "string",
-    placeholder: "<code>",
-    description: "`ratePlanCode` from `hotels rates`"
+    placeholder: "<cursor>",
+    description: "`nextCursor` from the previous page. A next page takes only `--cursor` and `--limit`."
   },
-  { flag: "check-in", field: "checkIn", type: "string", placeholder: DATE },
-  { flag: "check-out", field: "checkOut", type: "string", placeholder: DATE },
+  localeFlag,
+  displayCurrencyFlag
+]);
+var hotelFlags = flagsOf(getHotelInput, [
   {
     flag: "rooms",
-    field: "rooms",
-    type: "number",
-    placeholder: COUNT,
-    description: "Number of rooms, as in `hotels rates`; every room has the same occupancy"
-  },
-  {
-    flag: "adults",
-    field: "adults",
-    type: "number",
-    placeholder: COUNT,
-    description: "Adults per room, not in total, as in `hotels rates` (2 rooms for 4 adults = `--rooms 2 --adults 2`)"
-  },
-  {
-    flag: "child-age",
-    field: "childrenAges",
-    type: "number",
-    multiple: true,
-    placeholder: "<age>",
-    description: "Age of each child in one room (0-17), per room, as in `hotels rates`"
+    field: "include",
+    type: "boolean",
+    value: "rooms",
+    description: "Add the hotel's rooms."
   },
+  localeFlag
+]);
+var offersFlags = flagsOf(hotelOffersInput, [
   {
-    flag: "guest",
-    field: "guests",
+    flag: "hotel",
+    field: "hotelIds",
     type: "string",
     multiple: true,
-    placeholder: '"First Last[:roomNo]"',
-    description: 'A guest, as "First Last" (room 1) or "First Last:roomNo", e.g. "Mary Ann Lee:2": the last word is the last name, the rest the first name. Repeat for each guest. At least one guest per room, no more than the room sleeps. Names in Latin letters as on the passport; transliterate accents (M\xFCller \u2192 Mueller).'
+    placeholder: "<htl_>",
+    description: `A hotel to price, by hotelId from \`hotels search\`; repeat for each, up to ${LIMITS.offersHotels}.`
   },
+  ...stayFlags(
+    `A room, ${ROOM_FORMAT}. Repeat for each room, up to ${LIMITS.rooms}; every room must be the same.`
+  ),
+  { flag: "require-breakfast", field: "filters.requireBreakfast", type: "boolean" },
   {
-    flag: "contact-name",
-    field: "contactName",
-    type: "string",
-    placeholder: "<name>"
+    flag: "require-free-cancellation",
+    field: "filters.requireFreeCancellation",
+    type: "boolean"
   },
+  { flag: "limit-per-hotel", field: "limitPerHotel", type: "number", placeholder: COUNT },
+  localeFlag,
+  displayCurrencyFlag
+]);
+var bookFlags = flagsOf(createOrderInput, [
   {
-    flag: "contact-phone",
-    field: "contactPhone",
+    flag: "offer",
+    field: "items.offerId",
     type: "string",
-    placeholder: "<phone>"
+    placeholder: "<off_>",
+    description: "The offer to order, by offerId from `hotels offers`."
   },
   {
-    flag: "contact-email",
-    field: "contactEmail",
+    flag: "guest",
+    field: "items.hotel.rooms.guests",
     type: "string",
-    placeholder: "<email>"
+    multiple: true,
+    placeholder: "<room>:<first>:<last>",
+    description: "A guest, as `room:first:last`, e.g. `1:John:Smith` for room 1. Repeat for each guest: at least one per room of the offer, no more than the room sleeps. Names in Latin letters as on the passport; transliterate accents (M\xFCller \u2192 Mueller)."
   },
+  { flag: "first-name", field: "contact.firstName", type: "string", placeholder: "<name>" },
+  { flag: "last-name", field: "contact.lastName", type: "string", placeholder: "<name>" },
+  { flag: "email", field: "contact.email", type: "string", placeholder: "<email>" },
+  { flag: "phone", field: "contact.phone", type: "string", placeholder: "<phone>" },
   {
     flag: "special-requests",
-    field: "specialRequests",
+    field: "items.hotel.specialRequests",
     type: "string",
     placeholder: "<english text>"
   }
 ]);
+var orderFlags = flagsOf(getOrderInput, [localeFlag]);
+var ordersListFlags = flagsOf(listOrdersInput, [
+  { flag: "cursor", field: "cursor", type: "string", placeholder: "<cursor>" },
+  { flag: "limit", field: "limit", type: "number", placeholder: COUNT },
+  localeFlag
+]);
 var BODY_OPTION = {
   flag: "body",
   type: "string",
@@ -606,13 +805,14 @@ var BODY_OPTION = {
   description: "The raw request body as a JSON object, or `@file.json` to read it from a file. Flags override its fields."
 };
 var COMMAND_GROUPS = [
-  { name: "hotels", summary: "Search, price and book hotels" }
+  { name: "hotels", summary: "Search hotels, get offers and order one" },
+  { name: "orders", summary: "Your orders and their status" }
 ];
 var COMMANDS = [
   {
     group: "hotels",
     name: "search",
-    summary: "Find hotels with indicative prices",
+    summary: "Find hotels in a place, near a point or by name, with indicative prices",
     tool: "search_hotels",
     flags: searchFlags,
     options: [BODY_OPTION]
@@ -620,27 +820,42 @@ var COMMANDS = [
   {
     group: "hotels",
     name: "get",
-    summary: "Static hotel detail: description, policies, facilities and photos",
+    summary: "Hotel details: description, policies, amenities and rooms",
     tool: "get_hotel",
     flags: hotelFlags,
-    positionals: ["hotelId"]
+    positionals: [positional(getHotelInput, "hotelId")]
   },
   {
     group: "hotels",
-    name: "rates",
-    summary: `Live rooms and rates for up to ${LIMITS.ratesHotels} hotels`,
-    tool: "get_hotel_rates",
-    flags: ratesFlags,
+    name: "offers",
+    summary: `Live bookable offers for up to ${LIMITS.offersHotels} hotels`,
+    tool: "get_hotel_offers",
+    flags: offersFlags,
     options: [BODY_OPTION]
   },
   {
     group: "hotels",
     name: "book",
-    summary: "Create an order and get a payment link",
+    summary: "Order an offer: an unpaid order with a payment link",
     tool: "book_hotel",
     flags: bookFlags,
     options: [BODY_OPTION]
   },
+  {
+    group: "orders",
+    name: "get",
+    summary: "Show an order and its status",
+    tool: "get_order",
+    flags: orderFlags,
+    positionals: [positional(getOrderInput, "orderId")]
+  },
+  {
+    group: "orders",
+    name: "list",
+    summary: "List your orders, newest first",
+    tool: "list_orders",
+    flags: ordersListFlags
+  },
   {
     group: null,
     name: "login",
@@ -675,7 +890,14 @@ var COMMANDS = [
     summary: "Print the guide for AI agents (Markdown)",
     tool: "get_planning_guide",
     flags: [],
-    positionals: ["topic"]
+    positionals: [
+      {
+        name: "topic",
+        field: null,
+        optional: true,
+        description: "`planning` for the planning guide; left out, the main guide."
+      }
+    ]
   },
   {
     group: null,
@@ -700,22 +922,139 @@ var GLOBAL_FLAGS = [
     short: "v",
     type: "boolean",
     description: "Print the CLI version."
+  },
+  {
+    flag: "json",
+    type: "boolean",
+    description: "Print the answer as its JSON on one line instead of text; an error prints its JSON envelope, on stderr."
   }
 ];
 
+// src/conventions/open.ts
+import { z as z7 } from "zod";
+var OPEN = /* @__PURE__ */ Symbol("fortrip.open");
+function mark(schema, kind2) {
+  schema._zod.def[OPEN] = kind2;
+}
+function openObject(shape) {
+  return z7.looseObject(shape);
+}
+function openEnum(values) {
+  const schema = z7.union([
+    z7.enum(values),
+    z7.string()
+  ]);
+  mark(schema, "enum");
+  return schema;
+}
+function openUnion(discriminator, branches) {
+  const known = /* @__PURE__ */ new Set();
+  for (const branch of branches) {
+    const field = branch.shape[discriminator];
+    const values = field?._zod.values;
+    if (!values) {
+      throw new Error(`openUnion: branch has no literal "${discriminator}"`);
+    }
+    for (const v of values) known.add(v);
+  }
+  const fallback = z7.looseObject({
+    [discriminator]: z7.string().refine((v) => !known.has(v), { error: "malformed value for a known type" })
+  });
+  const schema = z7.union([...branches, fallback]);
+  mark(schema, "union");
+  return schema;
+}
+function parseOpen(schema, value) {
+  return schema.parse(value);
+}
+function strictOutput(schema) {
+  return strictify(schema);
+}
+var LEAVES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "bigint",
+  "null",
+  "undefined",
+  "literal",
+  "enum",
+  "date",
+  "nan",
+  "never",
+  "template_literal",
+  "transform"
+]);
+var WRAPPERS = {
+  optional: "innerType",
+  nullable: "innerType",
+  default: "innerType",
+  prefault: "innerType",
+  nonoptional: "innerType",
+  readonly: "innerType",
+  array: "element"
+};
+function strictify(schema) {
+  const def = schema._zod.def;
+  const kind2 = def[OPEN];
+  const rebuild = (changes) => {
+    const next = { ...def, ...changes };
+    delete next[OPEN];
+    return schema.clone(next);
+  };
+  if (kind2 === "enum") return strictify(def.options[0]);
+  if (kind2 === "union") {
+    return rebuild({ options: def.options.slice(0, -1).map(strictify) });
+  }
+  const inner = WRAPPERS[def.type];
+  if (inner) return rebuild({ [inner]: strictify(def[inner]) });
+  switch (def.type) {
+    case "object": {
+      const shape = def.shape;
+      return rebuild({
+        shape: Object.fromEntries(
+          Object.entries(shape).map(([k, v]) => [k, strictify(v)])
+        ),
+        catchall: z7.never()
+      });
+    }
+    case "union":
+      return rebuild({ options: def.options.map(strictify) });
+    case "tuple":
+      return rebuild({
+        items: def.items.map(strictify),
+        rest: def.rest ? strictify(def.rest) : def.rest
+      });
+    case "record":
+      return rebuild({ valueType: strictify(def.valueType) });
+    case "pipe":
+      return rebuild({
+        in: strictify(def.in),
+        out: strictify(def.out)
+      });
+    case "lazy": {
+      const getter = def.getter;
+      return rebuild({ getter: () => strictify(getter()) });
+    }
+    default:
+      if (LEAVES.has(def.type)) return schema;
+      throw new Error(`strictOutput: cannot close a "${def.type}" schema`);
+  }
+}
+
 // src/guide-data.generated.ts
 var FRAGMENTS = {
-  "booking": '{{#if claude-skill cli}}\n## Booking\n\n{{/if}}\n- Call `{{tool:hotels book}}` only for the rate the user picked{{#if claude-skill cli}}, with exactly the hotel, `{{arg:roomId}}`, `{{arg:ratePlanCode}}`, dates, `{{arg:rooms}}`, `{{arg:adults}}` and `{{arg:childrenAges}}` used in `{{tool:hotels rates}}`{{/if}}.\n- Guest names: Latin letters as on the passport (M\xFCller \u2192 Mueller), first and last name 1\u2013{{limit:guestName}} characters each{{#if cli}}, as `--guest "First Last"` (the last word is the last name; `"First Last:2"` puts the guest in room 2){{/if}}.{{#if claude-skill cli}} At least one guest per room, no more than the room sleeps.{{/if}}\n{{#if claude-skill cli}}\n- A contact name (up to {{limit:contactName}} characters) and phone ({{limit:contactPhoneMin}}\u2013{{limit:contactPhoneMax}} characters) are required; an email is optional. Special requests must be in English and aren\'t guaranteed.\n- One booking covers at most {{limit:nights}} nights; book a longer stay as separate bookings.\n{{/if}}\n- The `{{arg:nationality}}` given to `{{tool:hotels rates}}` isn\'t sent with the booking: a rate restricted by nationality may change or be refused.\n- `{{tool:hotels book}}` can take up to about two minutes{{#if cli}}: allow the command at least 3 minutes{{/if}}. If it times out, {{#if cli}}run it again with identical flags{{/if}}{{#if mcp claude-skill}}call it again with the same details{{/if}}: it resumes the same order{{#if claude-skill cli}}, with the same or a refreshed payment link{{/if}}.\n{{#if cli}}\n- `{{tool:hotels book}}` takes only these fields: a `--body` with any other field (such as `nationality`) is rejected with exit 2.\n{{/if}}\n',
-  "errors": "{{#if claude-skill cli}}\n## Errors\n\n{{#if claude-skill}}A tool error{{/if}}{{#if cli}}An error on stderr{{/if}} carries `error` (what went wrong) and `status`, and most carry a `reason`:\n\n| `reason` | Do this |\n|---|---|\n| `already_booked` (409) | This stay is already paid or completed: show `orderUrl` and don't book again |\n| `price_or_terms_changed` (409) | The rate changed; `changes` says how. Show the user what changed and re-run `{{tool:hotels rates}}`; if they still want it, call `{{tool:hotels book}}` again and confirm the new price and terms before giving the link |\n| `rate_unavailable` (422) | The rate can no longer be booked: re-run `{{tool:hotels rates}}` and let the user choose again |\n| `supplier_unavailable` (503 or 504) | Wait `retryAfterSeconds` and retry once with the same details; if it fails again, tell the user |\n| `refused` (422) | The booking was refused (a guest name, too many attempts, bookings paused): read `error` and explain it to the user |\n{{#if claude-skill}}\n\nWithout a `reason`:\n\n- **429**: wait `retryAfterSeconds`, then retry once.\n- **503** with `retryable: true` is a brief failure on Fortrip's side (for example, the same booking started twice at once): wait `retryAfterSeconds`, then retry once with the same details.\n- **500** and **502** are generic failures: read `error` and tell the user instead of guessing.\n{{/if}}\n{{/if}}\n",
-  "meals": "{{#if claude-skill cli}}\n## Presenting a rate\n\nGive the user, for each option:\n\n- the meal plan: `boardCode` (RO room only, BB breakfast, HB breakfast + dinner, FB breakfast + lunch + dinner, BL lunch, BD dinner, HBBL breakfast + lunch, HBLD lunch + dinner, AI all inclusive) with `boardCount`, how many guests per room the meal plan covers. Fewer than the adults per room means not everyone gets the meals (BB with `boardCount` 1 for 2 adults is breakfast for 1 of 2): say who is covered;\n- cancellation: `refundable` and `freeCancelUntil`;\n- confirmation: `isInstantConfirm`;\n- any `fees`: taxes paid at the hotel, in their own currency.\n{{/if}}\n",
-  "occupancy": "{{#if claude-skill cli}}\n## Occupancy\n\n{{/if}}\n- `{{tool:hotels rates}}` and `{{tool:hotels book}}` both require `{{arg:rooms}}` and `{{arg:adults}}`. `{{arg:adults}}` and `{{arg:childrenAges}}` are **per room**, the same in every room: 2 rooms for 4 adults is {{#if cli}}`--rooms 2 --adults 2`{{/if}}{{#if mcp claude-skill}}`rooms: 2, adults: 2`{{/if}}.\n{{#if claude-skill cli}}\n- If the party doesn't divide evenly across the rooms (3 adults in 2 rooms), ask the user whether to price every room for the larger number or to price and book each occupancy as its own stay.\n- Ask each child's age; `{{tool:hotels rates}}` and `{{tool:hotels book}}` need it.\n- Limits: 1\u2013{{limit:rooms}} rooms, 1\u2013{{limit:adultsPerRoom}} adults and 0\u2013{{limit:childrenPerRoom}} children (aged 0\u2013{{limit:childAgeMax}}) per room, 1\u2013{{limit:nights}} nights, up to {{limit:ratesHotels}} hotels per `{{tool:hotels rates}}` call.\n{{/if}}\n",
-  "order": '{{#if claude-skill cli}}\n## Workflow\n\n1. **Search** with `{{tool:hotels search}}` for candidate hotels and indicative prices. It needs `{{arg:checkIn}}` and `{{arg:checkOut}}`.\n{{#if cli}}\n\n   ```bash\n   {{tool:hotels search}} --query "Bangkok" --check-in 2026-11-10 --check-out 2026-11-12 \\\n     --star-min 4 --sort price-asc --page-size 10\n   ```\n\n{{/if}}\n2. **Details** (optional) with `{{tool:hotels get}}`, when the user asks about a hotel or a stated preference needs evidence (a pool, a policy, room size). For a details-only question, call it directly when you know the hotel\'s id; otherwise find the hotel with `{{tool:hotels search}}` using the user\'s dates (ask for them if they gave none).\n{{#if cli}}\n\n   ```bash\n   {{tool:hotels get}} 266000 [--with-rooms]\n   ```\n\n{{/if}}\n3. **Rates** with `{{tool:hotels rates}}` for a few shortlisted hotels, using the dates and occupancy the user will book. It takes about 15 seconds. A hotel is available only once this returns a live option for it.\n{{#if cli}}\n\n   ```bash\n   {{tool:hotels rates}} --hotel 266000 --hotel 266001 --check-in 2026-11-10 \\\n     --check-out 2026-11-12 --rooms 1 --adults 2 [--child-age 6] \\\n     [--nationality CN] [--board BB] [--free-cancellation] [--currency USD]\n   ```\n\n{{/if}}\n4. **Book** with `{{tool:hotels book}}`, once the user has picked one rate and given the guest details (see Booking).\n{{#if cli}}\n\n   ```bash\n   {{tool:hotels book}} --hotel 266000 --room-id 9191658 --rate-plan "<ratePlanCode>" \\\n     --check-in 2026-11-10 --check-out 2026-11-12 --rooms 1 --adults 2 \\\n     --guest "John Smith" --contact-name "John Smith" \\\n     --contact-phone "+8613800000000" [--contact-email john@example.com]\n   ```\n\n{{/if}}\n5. **Confirm, then give the payment link**, as in "Before giving the payment link" below.\n\n## Search\n\n{{/if}}\n- Search prices come from a minimum-price feed, not live rates: quote `{{tool:hotels rates}}` prices, and never call a search result available or bookable.{{#if claude-skill cli}} When you show search prices, say they are indicative minimums, not quotes.{{/if}}\n- A search that matches too many hotels fails with `matched` and `maxMatches`: narrow it{{#if claude-skill cli}} (a city, an area, stars or a price range){{/if}}.\n{{#if claude-skill cli}}\n- Use `{{arg:near}}` for "near X"{{#if cli}} (`lat,lng,radiusKm`){{/if}}, and `{{arg:cityCode}}` when you know the city\'s code.\n- Facility names in `{{arg:facilities}}` must match the catalogue exactly (`Swimming pool`, `Parking`); near-synonyms match nothing.\n{{/if}}\n',
-  "payment-link": "{{#if claude-skill cli}}\n## Before giving the payment link\n\n`{{tool:hotels book}}` returns `paymentUrl`, `statusUrl`, `orderUrl`, `amount`, `currency`, `terms` and `stay`. Nothing is charged until the user pays.\n\n1. Show the `stay` (hotel, room, dates, nights, rooms, adults and children's ages per room), the `amount` and `currency` to be charged, and every item in `terms`: meal plan (`boardCode` with `boardCount`), cancellation (`refundable`, `freeCancelUntil`, the `cancellation` ladder), confirmation (`isInstantConfirm`, `confirmByMins`) and `payAtHotelFees`.\n2. End that reply by asking the user to confirm, and wait for a clear yes. Urgency is not consent.\n3. Then give `paymentUrl` exactly as returned: don't shorten, rebuild or re-encode it. It opens a Fortrip page that recaps the booking and continues to payment on Stripe.\n\n{{/if}}\n{{#if mcp}}\n- Before you give `paymentUrl`, show the user the `stay`, `amount`, `currency` and every item in `terms` that `{{tool:hotels book}}` returned, end that reply by asking the user to confirm, and wait for a clear yes. Then give `paymentUrl` exactly as returned, to this user only: anyone holding it can pay.\n{{/if}}\n- If `amount` or `terms` is null, don't give the link: call `{{tool:hotels book}}` again with the same details, and if either is still null, tell the user to contact {{support}}.\n{{#if claude-skill cli}}\n- `paymentUrl` works like a payment credential: anyone holding it can pay. Give it to this user only, never in shared channels, documents, logs or tickets. It expires about 3 hours 45 minutes after it was created; for a fresh one, call `{{tool:hotels book}}` again with the same details.\n- `statusUrl` is the same page: after payment it shows the booking's confirmation progress, without signing in. `orderUrl` is the user's signed-in order page.\n{{/if}}\n- Never ask for, accept or pass on payment card details; payment happens only on the payment page.{{#if claude-skill cli}} A card number in a guest name, the contact name or the special requests is rejected{{#if cli}} with exit 2{{/if}}.{{/if}}\n",
-  "planning": "# Planning a hotel stay\n\nRead this when the request is more than one hotel for fixed dates: flexible dates, a budget, split stays, several destinations, or \"find me the best\". The rules in {{#if mcp}}the server instructions{{/if}}{{#if claude-skill}}SKILL.md{{/if}}{{#if cli}}`{{tool:guide}}`{{/if}} still apply (call order, occupancy per room, confirming the terms `{{tool:hotels book}}` returns before giving the payment link); this covers what to ask, how to compare and how to present.{{#if cli}} As there, `fortrip` is short for `npx -y fortrip@latest`.{{/if}}\n\n## What to collect\n\nKeep track of: dates (or the flexible window), nights, destination(s), rooms and the guests in each room, room constraints (beds, connecting rooms, accessibility), budget, and what the user said matters most (cheapest, most flexible, closest to X).\n\nOccupancy is per room and the same in every room, so if the party doesn't split evenly across the rooms, ask how it splits.\n\nAsk only for what changes which hotels qualify or how they rank. If children come along, ask each child's age; `{{tool:hotels rates}}` and `{{tool:hotels book}}` need it. Don't ask for trip type or style: infer it from the conversation or leave it general.\n\n## Evidence\n\n- A `{{tool:hotels search}}` price is an indicative minimum, not a quote. Never call a search result available or bookable.\n- Use `{{tool:hotels get}}` only when a stated preference needs evidence (a pool, a policy, room size).\n- A hotel is available only once `{{tool:hotels rates}}` returned a live option for it.\n- Anything {{#if mcp claude-skill}}the tools{{/if}}{{#if cli}}the CLI{{/if}} didn't return, such as reviews, style, price trends or exchange rates other than `fx`, is unknown. Say so instead of filling it in.\n\n## Ranking\n\n1. Drop options that break a hard constraint (dates, guests, budget cap, required facility). Compare a budget in the unit the user gave it: per night, per room or for the whole stay.\n2. Keep only options with a live rate.\n3. Order by the user's stated main goal. Goals they didn't state don't count.\n4. Use other preferences only to break ties.\n\nUse the cheapest comparable live room as the baseline unless the user fixed the room type. Show at most three plans, each with its price difference from the baseline and what it trades off (meal plan, cancellation, location, instant confirmation). Keep hotel names as returned and dates in the user's notation.\n\nFor a split stay or several destinations, price each leg with its own `{{tool:hotels rates}}` call and add up the legs. Each leg is a separate `{{tool:hotels book}}` call, with its own confirmation and its own payment link.\n\n## Stop and say so\n\n- `{{tool:hotels rates}}` covers up to {{limit:ratesHotels}} hotels per call and takes about 15 seconds. If the request needs more hotels or date combinations than a few calls can cover, narrow it with the user, or present the result as a comparison of the hotels you priced, not the best overall.\n- Urgency is not consent. Call `{{tool:hotels book}}` only for the rate the user picked, and give its payment link only after the user confirms the amount, currency, stay and terms that `{{tool:hotels book}}` returned.\n",
-  "prices": "{{#if claude-skill cli}}\n## Prices and currency\n\n{{/if}}\n- In `{{tool:hotels rates}}`, `totalPrice` is the whole stay for all rooms, and `dailyPrices` are per room per night.{{#if claude-skill cli}} To compare with a per-night or per-room budget, divide the total by the nights and rooms, or use `dailyPrices`.{{/if}}\n- Pass `{{arg:currency}}`{{#if claude-skill cli}} to `{{tool:hotels search}}` and `{{tool:hotels rates}}`{{/if}}: `CNY` (the default) or `USD`, to suit the user's language or location.{{#if cli}} Without `--currency`, the CLI uses the currency in `--body`, then `FORTRIP_CURRENCY`, then `CNY`.{{/if}}{{#if claude-skill cli}} Prices are converted at Stripe's exchange rate, or a fixed fallback rate when Stripe is unavailable; `fx` says which, and is `null` when nothing needed converting.{{/if}}\n{{#if claude-skill cli}}\n- `{{arg:priceMin}}` and `{{arg:priceMax}}` on `{{tool:hotels search}}` bound the indicative nightly price, in that currency.\n{{/if}}\n- The charge is the `amount` in the `currency` that `{{tool:hotels book}}` returns (currently USD). A converted price is a reference: never present it as the charge.{{#if claude-skill cli}} Stripe's page may also show the charge in the user's local currency, at Stripe's rate. Fees paid at the hotel are separate, in their own currency.{{/if}}\n",
-  "scope": "{{#if claude-skill cli}}\n# Fortrip hotel stays\n\n{{/if}}\nFortrip: hotel search, live rates and booking payment links.{{#if claude-skill cli}} Not for flights, activities, or changing or cancelling an existing booking.{{/if}}\n\n{{#if mcp}}\nCall order: `{{tool:hotels search}}` \u2192 (optional) `{{tool:hotels get}}` \u2192 `{{tool:hotels rates}}` \u2192 `{{tool:hotels book}}`. `{{tool:guide}}` returns Fortrip's guidance for flexible dates, budgets, split stays, several destinations or \"find the best\" requests.\n{{/if}}\n{{#if claude-skill}}\nThe tools are on Fortrip's MCP server, named `fortrip` in this plugin (a Fortrip connector added on claude.ai can show under its own name). They're written `fortrip:<tool>` below:\n{{/if}}\n{{#if cli}}\nThe `fortrip` CLI (npm package `fortrip`) calls Fortrip as the signed-in user and prints JSON:\n{{/if}}\n{{#if claude-skill cli}}\n\n| {{#if claude-skill}}Tool{{/if}}{{#if cli}}Command{{/if}} | Returns |\n|---|---|\n| `{{tool:hotels search}}` | Hotels by name, brand or city (`{{arg:query}}`), `{{arg:cityCode}}`, or a point and radius (`{{arg:near}}`), with indicative prices |\n| `{{tool:hotels get}}` | One hotel's address, check-in and check-out times, policies, facilities and photos; no prices |\n| `{{tool:hotels rates}}` | Live rooms, meal plans, cancellation terms and prices for up to {{limit:ratesHotels}} hotels |\n| `{{tool:hotels book}}` | An unpaid booking for one rate, with its terms and a payment link |\n\nFor flexible dates, a budget, split stays, several destinations or \"find me the best\", {{#if claude-skill}}read [references/planning.md](references/planning.md){{/if}}{{#if cli}}also run `{{tool:guide}} planning`{{/if}} before searching.\n{{/if}}\n",
-  "setup": "{{#if cli}}\n## Setup\n\nRun every command as `npx -y fortrip@latest <command>` (Node.js 22 or newer). The examples below shorten that to `fortrip`; `fortrip <command> --help` lists a command's flags. `{{tool:hotels search}}`, `{{tool:hotels rates}}` and `{{tool:hotels book}}` also take `--body '<json>'` (or `--body @file.json`), the raw request body; flags override its fields.\n\nWhen the user first asks about hotels, run `{{tool:whoami}}` before asking follow-up questions, so the sign-in can happen while they answer.\n\n{{/if}}\n{{#if claude-skill cli}}\n## Sign-in\n\n{{/if}}\nSign-in happens only in the browser. Never ask the user to paste a token.\n{{#if claude-skill}}\n\nIf none of these tools are available, Fortrip isn't connected: tell the user to add the Fortrip connector or plugin and sign in.\n{{/if}}\n{{#if mcp claude-skill}}\nIf a tool says the user isn't signed in, ask them to reconnect Fortrip and sign in again.\n{{/if}}\n{{#if cli}}\n\nIf a command exits with code **3** and stderr has `loginUrl`, show it to the user as a link together with `userCode`, e.g. \"Sign in to Fortrip: <loginUrl> (code <userCode>), then tell me when you're done.\" When they confirm, rerun the same command; it finishes the sign-in itself. Don't run `{{tool:login}}`: it waits for up to 10 minutes. Commands that exit 3 together share one `loginUrl`; show it once. If the rerun gives a different `loginUrl`, show that one.\n\nWhen Fortrip no longer accepts the saved sign-in (it was revoked, or it expired and couldn't be renewed), the command also exits 3 with a `loginUrl`; handle it the same way. The saved sign-in is kept until the user approves the new link.\n\nIn CI or a sandbox without a browser, the user can set `FORTRIP_TOKEN` instead. Exit 3 with `tokenSource: \"FORTRIP_TOKEN\"` means Fortrip didn't accept that token: tell the user to replace or unset it.\n\n## Exit codes\n\n| Code | Meaning | What to do |\n|---|---|---|\n| 0 | Success; JSON on stdout | Continue |\n| 1 | Any other error: an error from Fortrip (see Errors), a network error or a timeout | Read `error` on stderr. If `retryable` is true, wait `retryAfterSeconds` (or a few seconds) and retry once |\n| 2 | Invalid arguments | Fix the flags; stderr `issues` lists each bad field with a message |\n| 3 | Not signed in | Show `loginUrl` to the user, then rerun (above) |\n| 4 | Rate limited | Wait `retryAfterSeconds`, then retry once |\n\nOutput on stdout or stderr can carry `warning` (with `recoveryFile` when a sign-in couldn't be saved): pass it on to the user.\n{{/if}}\n",
-  "support": "{{#if claude-skill cli}}\n## Changes and support\n\n{{/if}}\n{{#if mcp claude-skill}}These tools{{/if}}{{#if cli}}The CLI{{/if}} can't change or cancel a booking: for changes, cancellations, refunds or other problems with a booking, the user emails {{support}} with the booking's `orderUrl` (never `paymentUrl` or `statusUrl`).\n"
+  "booking": "{{#if claude-skill cli}}\n## Ordering\n\n{{/if}}\n- Call `{{tool:hotels book}}` only for the offer the user picked, with at least one guest per room{{#if claude-skill cli}}, named as the user gave them{{/if}}; never invent guests.{{#if claude-skill cli}} Room 1 is the offer's first room, and a room takes no more guests than it sleeps.{{/if}}\n- Guest names: Latin letters as on the passport (M\xFCller \u2192 Mueller), first and last name 1\u2013{{limit:guestName}} characters each{{#if cli}}, as `--guest 1:John:Smith` (room 1, first name, last name){{/if}}.\n{{#if claude-skill cli}}\n- The contact's first and last name (up to {{limit:contactFirstName}} characters each), email and phone (with its country code) are all required. Special requests must be in English and aren't guaranteed.\n{{/if}}\n- `{{tool:hotels book}}` can take up to about two minutes{{#if cli}}: allow the command at least 3 minutes{{/if}}. If it times out, {{#if cli}}run it again with identical flags{{/if}}{{#if mcp claude-skill}}call it again with the same details{{/if}}: it returns the same order.\n{{#if mcp}}\n- On `offer_changed`, show the user every change and ask again before ordering the new offer.\n{{/if}}\n{{#if cli}}\n- `{{tool:hotels book}}` takes only these fields: a `--body` with any other field (such as `nationality`) is rejected with exit 2.\n{{/if}}\n",
+  "errors": "{{#if claude-skill cli}}\n## Errors\n\n{{#if claude-skill}}A tool error{{/if}}{{#if cli}}An error on stderr{{/if}} carries `code`, `message` and `retryable`, and `retryAfterSeconds` when waiting helps; many carry `details`. Search errors are under Search. Ordering errors:\n\n| `code` | Do this |\n|---|---|\n| `offer_changed` (409) | The price or terms changed since the offer: `changes` lists every change (`worse` says which are worse for the user) and `offer` is the new offer. Show the user every change and ask again; if they still want it, order the new offer, and confirm the new order before giving its link |\n| `offer_expired` (409) | Get offers again and let the user choose again |\n| `offer_unavailable` (422) | The offer is sold out or was refused: get offers again and let the user choose again |\n| `order_in_progress` (409) | The same order is still being created: wait `retryAfterSeconds`, then {{#if claude-skill}}call again with the same details{{/if}}{{#if cli}}run the command again with identical flags{{/if}} |\n| `offer_already_ordered` (409) | This offer was already ordered with other details: show that order (`orderId`) instead. An offer is ordered once |\n| `order_exists` (409) | This stay already has an order (`orderId`, `status`): show it instead of ordering again. This also blocks ordering the same offer, dates and rooms again for another party, ordering a stay again after it was cancelled, ordering while the user's own website checkout for the stay is open (up to 3 hours 45 minutes) and ordering again a stay whose earlier order failed at the hotel. For those, the user emails {{support}} |\n| `order_attempts_exhausted` (409) | This order can't be tried again: the user emails {{support}} with its `reference` |\n| `order_removed` (410) | The order was never completed and no payment is held: get offers again and order the new offer (the order keeps its `orderId`) |\n| `stay_unsupported` (422) | `mixed_occupancy`: order once per party; `max_nights`: at most `max` nights per order |\n| `stay_in_past` (422) | Check-in has passed in the hotel's time zone: ask for new dates |\n| `ordering_paused` (503) | Ordering is paused on Fortrip's side: tell the user, and try again only after `retryAfterSeconds` (10 minutes or more) |\n\nAny code:\n\n- `invalid_request` (400): `details.issues` lists each bad field; fix them. For amenities, `details.filterable` lists those that can filter.\n- `cursor_invalid` (400): the page is gone; search again from the first page.\n- `not_found` (404): no such hotel, or no such order for this user.\n- `rate_limited` (429): wait `retryAfterSeconds`, then retry once.\n- `service_unavailable` (503) and `supplier_unavailable` (503 or 504): wait `retryAfterSeconds`, then retry once with the same details; if it fails again, tell the user.\n- Any other code: read `message`. If `retryable` is true, wait `retryAfterSeconds` and retry once; otherwise tell the user instead of guessing.\n{{/if}}\n",
+  "meals": '{{#if claude-skill cli}}\n## Presenting an offer\n\nGive the user, for each offer:\n\n- the room (`room.name`, beds, size) and the total, as above;\n- the meals: `meals.included` (breakfast, lunch, dinner) or `allInclusive`, with `guestsCoveredPerRoom`. Fewer than the guests per room means not everyone gets the meals (breakfast for 1 with 2 adults in the room): say who is covered. `unspecifiedMainMeals` counts main meals the hotel didn\'t name. With `known: false`, the meals are unknown: say so, and don\'t call it room only;\n- cancellation: `status` (`free`, `partial_penalty`, `non_refundable` or `unknown`), `freeCancellationEndsAt` (null with `free`: free until check-in) and the `penalties`. Times are in UTC: also give them in the hotel\'s `timeZone`;\n- confirmation: `mode` `instant` or `on_request` (within `withinMinutes`);\n- fees payable at the property (`payAtProperty.items`), in the property\'s currency. `disclosure: "incomplete"` means there can be fees not listed: say so.\n\nAn offer expires at `expiresAt`, about 30 minutes after it was made; after that, get offers again.\n\n"Not listed" is not "no": `listed: false` (amenities, policies, rooms), `null` and `unknown` mean the source didn\'t say. Tell the user it\'s unknown instead of turning it into "no".\n{{/if}}\n{{#if mcp}}\n- "Not listed" or "unknown" is not "no".\n{{/if}}\n',
+  "occupancy": "{{#if claude-skill cli}}\n## Rooms and guests\n\n- {{#if mcp claude-skill}}`stay.rooms` lists each room's party as `{ adults, childrenAges }`: two rooms of 2 adults, one with a child of 6, is `[{ adults: 2, childrenAges: [6] }, { adults: 2, childrenAges: [] }]`{{/if}}{{#if cli}}`--room <adults[:age,\u2026]>`, once per room, gives each room's party: two rooms of 2 adults, one with a child of 6, is `--room 2:6 --room 2`{{/if}}.\n- Ask each child's age; offers need it.\n- If the party doesn't split evenly across the rooms (3 adults in 2 rooms), ask the user how it splits.\n{{/if}}\n- Offers and orders take one party per call, every room the same: for different parties, order once per party.{{#if claude-skill cli}} `{{tool:hotels offers}}` answers `stay_unsupported` (`mixed_occupancy`) for mixed rooms; `{{tool:hotels search}}` accepts them but prices only from the dates, with the note `party_split_required`.{{/if}}\n{{#if claude-skill cli}}\n- Limits: 1\u2013{{limit:rooms}} rooms, 1\u2013{{limit:adultsPerRoom}} adults and 0\u2013{{limit:childrenPerRoom}} children (aged 0\u2013{{limit:childAgeMax}}) per room, 1\u2013{{limit:nightsSupplier}} nights, up to {{limit:offersHotels}} hotels per `{{tool:hotels offers}}` call. A longer stay answers `stay_unsupported` (`max_nights`): ask the user whether to split it into consecutive stays, each its own order.\n{{/if}}\n",
+  "order": '{{#if claude-skill cli}}\n## Workflow\n\n1. **Search** with `{{tool:hotels search}}` for candidate hotels: a destination, `{{arg:text}}` or both, and the stay\'s dates and rooms for indicative prices.\n{{#if cli}}\n\n   ```bash\n   {{tool:hotels search}} --place-name Bangkok --country TH --check-in 2026-11-10 \\\n     --check-out 2026-11-12 --room 2 --stars-min 4 --sort price_asc --limit 10\n   ```\n\n{{/if}}\n2. **Details** (optional) with `{{tool:hotels get}}`, when the user asks about a hotel or a stated preference needs evidence (a pool, a policy, room size). For a details-only question, call it directly when you know the hotel\'s `hotelId`; otherwise find the hotel with `{{tool:hotels search}}`.\n{{#if cli}}\n\n   ```bash\n   {{tool:hotels get}} <hotelId> [--rooms]\n   ```\n\n{{/if}}\n3. **Offers** with `{{tool:hotels offers}}` for a few shortlisted hotels, with the dates and rooms the user will order. It takes about 15 seconds. A hotel is available only once this returns an offer for it.\n{{#if cli}}\n\n   ```bash\n   {{tool:hotels offers}} --hotel <hotelId> --hotel <hotelId> --check-in 2026-11-10 \\\n     --check-out 2026-11-12 --room 2 --room 2 [--require-free-cancellation]\n   ```\n\n{{/if}}\n4. **Order** with `{{tool:hotels book}}`, once the user has picked one offer and given the guests and the contact (see Ordering).\n{{#if cli}}\n\n   ```bash\n   {{tool:hotels book}} --offer <offerId> --guest 1:John:Smith --guest 2:Mary:Smith \\\n     --first-name John --last-name Smith --email john@example.com \\\n     --phone "+8613800000000"\n   ```\n\n{{/if}}\n5. **Confirm, then give the payment link**, as in "Before giving the payment link" below.\n6. **After payment**, check the order with `{{tool:orders get}}` (see After payment).\n\n## Search\n\n### Where\n\n- **A place by name:** {{#if mcp claude-skill}}`{ kind: "place_name", name, countryCode }`{{/if}}{{#if cli}}`--place-name <name> --country <CC>`{{/if}}, in any language (Kyoto or \u4EAC\u90FD). The country is required: ask the user when it isn\'t clear. Names match exactly, ignoring only case and spacing: accents, hyphens, apostrophes and periods count ("K\xF6ln" or "Cologne", not "Koln"; "St. Moritz", not "St Moritz").\n- If several places bear the name, the answer is `destination_ambiguous` with up to {{limit:candidatesShown}} candidates and their hotel counts: ask the user which one they mean, then search it by its `placeId`; never pick one yourself.\n- `destination_not_found` with `no_match` means no place of that name in that country: check the spelling and accents, or try another name for the place. Its `nameAsText` counts the hotels that a `{{arg:text}}` search for the name would find.\n- **A place from an earlier answer:** {{#if mcp claude-skill}}`{ kind: "place", placeId }`{{/if}}{{#if cli}}`--place <placeId>`{{/if}}.\n- **Near a point:** {{#if mcp claude-skill}}`{ kind: "point", location: { lat, lng } }`{{/if}}{{#if cli}}`--point <lat,lng>`{{/if}}, for "near X" when you know where X is.\n- **A whole country:** {{#if mcp claude-skill}}`{ kind: "country", countryCode }`{{/if}}{{#if cli}}`--country-only <CC>`{{/if}}, as for the Maldives.\n- Countries, regions (states, provinces), prefecture-level cities in China and main islands cover their whole area. Towns, neighbourhoods, districts, small islands and points cover a circle of {{limit:radiusMetersDefault}} meters; `{{arg:destination.radiusMeters}}` sets another, up to {{limit:radiusMetersMax}} meters, and narrows an area to a circle around its center.\n- **Localities:** an area search lists its `localities`, the towns its hotels belong to, each with a `placeId`, its hotel `count` and the places it `includes` (Patong is part of Phuket). To search one, pass it as {{#if mcp claude-skill}}`{ kind: "locality", placeId }`{{/if}}{{#if cli}}`--locality <placeId>`{{/if}}. A town that isn\'t a locality answers `destination_not_found` with `not_a_locality` and the `hub` it belongs to: search the hub, or the town itself with {{#if mcp claude-skill}}`kind: "place"`{{/if}}{{#if cli}}`--place`{{/if}} for a circle around it.\n- A price sort or price filter over more than {{limit:poolLimit}} hotels (in an area, or for text alone) answers `search_too_broad` with `matched` and the top `localities`: show them and ask the user which they prefer, unless the request already names one of them; search that one by its `placeId` as a locality, never by its name.\n\n### Text\n\n`{{arg:text}}` matches exact words in hotel names and addresses, in Chinese or English:\n\n- Every word must match as written: plurals, accents, spacing and abbreviations count ("hostel" and "hostels", "St Regis" and "Saint Regis" find different hotels). Hyphens and apostrophes don\'t (Ritz-Carlton finds Ritz Carlton).\n- In Chinese, matching follows word segmentation, so part of a name can match unrelated hotels (\u5E0C\u5C14 is not \u5E0C\u5C14\u987F).\n- Use only distinctive words: a hotel or brand name, a district or a landmark. Not "hotel", "near", "cheap" or "best".\n- Typos return nothing: "Shangahi" finds no hotel.\n- Place names belong in the destination: "Maldives" as text finds a hotel named Maldives in China.\n\n### Filters\n\n- Stars run from 1 to 5 in half steps{{#if mcp claude-skill}} (`filters.stars`){{/if}}. "4 stars" as {{#if mcp claude-skill}}`{ min: 4, max: 4 }`{{/if}}{{#if cli}}`--stars-min 4 --stars-max 4`{{/if}} leaves out 4.5: unless the user means exactly 4, use {{#if mcp claude-skill}}`{ min: 4 }`{{/if}}{{#if cli}}`--stars-min 4`{{/if}} or ask. Unrated hotels are left out whenever stars are filtered.\n- `{{arg:filters.amenities}}` takes only the amenities that can filter (such as pool, parking, wifi); others, such as gym or spa, show in `{{tool:hotels get}}` but can\'t filter. A hotel matches only when it lists the amenity, and about half the hotels list no amenities at all (`coverage.excludedNoFacilityData` counts those left out): "not listed" is not "absent".\n- `{{arg:filters.price.maxPerRoomNight}}` bounds the indicative price per room per night, in USD; hotels without one are left out and counted.\n\n### Results\n\n- `notes` explain the answer (a limited pool, a circle around an island, more hotels just outside it): pass on what matters to the user.\n- `coverage` has the counts: `matched` hotels, how many were priced and how many have a price.\n- A next page is {{#if mcp claude-skill}}`cursor` set to `nextCursor` and, optionally, `limit`{{/if}}{{#if cli}}`--cursor <nextCursor>` and, optionally, `--limit`{{/if}}; nothing else.\n{{/if}}\n{{#if mcp}}\n- A place name needs its `countryCode` (ask the user if unclear) and matches exactly (accents and periods count). On `destination_ambiguous`, ask the user which they mean, then search its `placeId`; never pick one yourself.\n- On `search_too_broad`, show its `localities` and ask the user which, unless they already named one; search it as `{ kind: "locality", placeId }`, never by name.\n- `text` matches whole words of hotel names and addresses: use a distinctive name, brand or landmark. A typo finds nothing.\n{{/if}}\n',
+  "payment-link": "{{#if claude-skill cli}}\n## Before giving the payment link\n\n`{{tool:hotels book}}` answers with an unpaid order: `status` `awaiting_payment`, its `reference` (the support number), `price.total`, the stay and its terms, and `payment.url`, a Fortrip page that recaps the order and continues to payment on Stripe. Nothing is charged until the user pays.\n\n1. Show the order's total and currency, the stay (hotel, room, dates, rooms and guests per room) and every term: meals, cancellation (status, deadline, penalties) and fees payable at the property, unknowns included.\n2. End that reply by asking the user to confirm, and wait for a clear yes. Urgency is not consent.\n3. Then give `payment.url` exactly as returned: don't shorten, rebuild or re-encode it.\n\n{{/if}}\n{{#if mcp}}\n- Before you give `payment.url`, show the user the order's total and currency, the stay and every term, end that reply by asking the user to confirm, and wait for a clear yes. Then give `payment.url` exactly as returned, to this user only: anyone holding it can pay.\n{{/if}}\n{{#if claude-skill cli}}\n- `payment.url` works like a payment credential: anyone holding it can pay. Give it to this user only, never in shared channels, documents, logs or tickets. With `requiresSignIn: true` (an order started on the Fortrip website), the user signs in to pay.\n- The link expires at `payment.expiresAt`; the order is then `expired`. To order the stay again, get offers again, and confirm the new order with the user before giving its link.\n- An order `awaiting_payment` whose `payment.url` is null had its link unreadable this time: read it again with `{{tool:orders get}}`.\n{{/if}}\n- Never ask for, accept or pass on payment card details; payment happens only on the payment page.{{#if claude-skill cli}} A card number in a guest name, the contact or the special requests is rejected{{#if cli}} with exit 2{{/if}}.{{/if}}\n{{#if claude-skill cli}}\n\n## After payment\n\nCheck the order with `{{tool:orders get}}`:\n\n- `confirming` while the hotel confirms, then `confirmed` with the hotel's `confirmationNumber`.\n- `failed`: no stay was booked; `payment.status` says whether the payment was released or refunded.\n- `needs_attention`: Fortrip is looking into it; the user can email {{support}} with the `reference`.\n- `manageUrl` is the user's own page for the order.\n{{/if}}\n",
+  "planning": "# Planning a hotel stay\n\nRead this when the request is more than one hotel for fixed dates: flexible dates, a budget, split stays, several destinations, or \"find me the best\". The rules in {{#if mcp}}the server instructions{{/if}}{{#if claude-skill}}SKILL.md{{/if}}{{#if cli}}`{{tool:guide}}`{{/if}} still apply (call order, destinations, one party per offer and order, confirming the order `{{tool:hotels book}}` returns before giving the payment link); this covers what to ask, how to compare and how to present.{{#if cli}} As there, `fortrip` is short for `npx -y fortrip@latest`.{{/if}}\n\n## What to collect\n\nKeep track of: dates (or the flexible window), nights, destination(s) with their country, rooms and the guests in each room, room constraints (beds, connecting rooms, accessibility), budget, and what the user said matters most (cheapest, most flexible, closest to X).\n\nOffers and orders take one party per call, every room the same, so if the party doesn't split evenly across the rooms, ask how it splits. Rooms for different parties are priced and ordered separately, each order with its own payment link.\n\nAsk only for what changes which hotels qualify or how they rank. \"4 stars\" as {{#if mcp claude-skill}}`{ min: 4, max: 4 }`{{/if}}{{#if cli}}`--stars-min 4 --stars-max 4`{{/if}} leaves out 4.5: unless the user means exactly 4, use {{#if mcp claude-skill}}`{ min: 4 }`{{/if}}{{#if cli}}`--stars-min 4`{{/if}} or ask. If children come along, ask each child's age; `{{tool:hotels offers}}` needs it. Don't ask for trip type or style: infer it from the conversation or leave it general. When a place name is ambiguous, ask which place the user means.\n\n## Evidence\n\n- A `{{tool:hotels search}}` price is an indicative estimate per room per night, not a quote. Never call a search result available or bookable, and once you have offers, compare offers only. A hotel without a search price can still have offers.\n- Use `{{tool:hotels get}}` only when a stated preference needs evidence (a pool, a policy, room size). An amenity or policy it doesn't list is unknown, not absent.\n- A hotel is available only once `{{tool:hotels offers}}` returned an offer for it.\n- Anything {{#if mcp claude-skill}}the tools{{/if}}{{#if cli}}the CLI{{/if}} didn't return, such as reviews, style, price trends or exchange rates other than `approx`, is unknown. Say so instead of filling it in.\n\n## Ranking\n\n1. Drop options that break a hard constraint (dates, guests, budget cap, required facility). Compare a budget in the unit the user gave it: per night, per room or for the whole stay. An offer's `price.total` covers the whole stay and every room, in USD.\n2. Keep only options with a live offer.\n3. Order by the user's stated main goal. Goals they didn't state don't count.\n4. Use other preferences only to break ties.\n\nUse the cheapest comparable offer as the baseline unless the user fixed the room type. Show at most three plans, each with its price difference from the baseline and what it trades off (meals, cancellation, location, confirmation). Keep hotel names as returned and dates in the user's notation.\n\nFor a split stay or several destinations, price each leg with its own `{{tool:hotels offers}}` call and add up the legs. Each leg is a separate `{{tool:hotels book}}` call, with its own confirmation and its own payment link.\n\n## Stop and say so\n\n- `{{tool:hotels offers}}` covers up to {{limit:offersHotels}} hotels per call and takes about 15 seconds, and its offers expire after about 30 minutes. If the request needs more hotels or date combinations than a few calls can cover, narrow it with the user, or present the result as a comparison of the hotels you priced, not the best overall.\n- When a search is too broad to price, show its localities and ask the user which they prefer, unless the request already names one of them; never pick one yourself.\n- Urgency is not consent. Call `{{tool:hotels book}}` only for the offer the user picked, and give its payment link only after the user confirms the total, currency, stay and terms of the order `{{tool:hotels book}}` returned.\n",
+  "prices": "{{#if claude-skill cli}}\n## Prices and currency\n\n- A search price (`price.fromPerRoomNight`) is indicative and not bookable: the lowest price of one unit (a room or, at a hostel, possibly a bed) per night, for any party and often any date, and it can be well above or below the offers. Call it an estimate, quote `{{tool:hotels offers}}` prices, and never call a search result available or bookable. `price: null` means there is no indicative price, not that the hotel is full; about half the hotels have none for given dates.\n{{/if}}\n{{#if mcp}}\n- Search prices are indicative, not bookable: quote `{{tool:hotels offers}}` prices.\n{{/if}}\n- {{#if claude-skill cli}}In an offer or order, {{/if}}`price.total` is the whole stay for all rooms and is what is charged, in USD for offers and the orders made from them.{{#if claude-skill cli}} `perNightAllRooms` is the total per night; to compare with a per-room budget, also divide by the rooms.{{/if}} Stripe's page may let the user pay in their card's local currency at Stripe's rate (Adaptive Pricing){{#if claude-skill cli}}: say so plainly, and that the USD total is the price{{/if}}. `approx`{{#if claude-skill cli}}, in `{{arg:displayCurrency}}`, with its `rateDate`,{{/if}} is an estimate, never the charge.\n{{#if claude-skill cli}}\n- `{{arg:displayCurrency}}`{{#if cli}} (or `FORTRIP_DISPLAY_CURRENCY`){{/if}} is `USD` or `CNY`: `CNY` adds `approx` in yuan to suit a user who thinks in it. It never changes the charge.\n- Fees payable at the property (`payAtProperty`) are separate, in the property's own currency, not converted.\n- After payment, `payment.localCharge` is what the card paid in its own currency. Orders made on the Fortrip website can be charged in another currency: `payment.chargeCurrency` says which.\n{{/if}}\n",
+  "scope": "{{#if claude-skill cli}}\n# Fortrip hotel stays\n\n{{/if}}\nFortrip: hotel search, live offers and orders with a payment link.{{#if claude-skill cli}} Not for flights, activities, or changing or cancelling an existing order.{{/if}}\n\n{{#if mcp}}\nCall order: `{{tool:hotels search}}` \u2192 (optional) `{{tool:hotels get}}` \u2192 `{{tool:hotels offers}}` \u2192 `{{tool:hotels book}}`; after the user pays, `{{tool:orders get}}`; `{{tool:orders list}}` lists their orders. `{{tool:guide}}` returns Fortrip's guidance for flexible dates, budgets or several destinations.\n{{/if}}\n{{#if claude-skill}}\nThe tools are on Fortrip's MCP server, named `fortrip` in this plugin (a Fortrip connector added on claude.ai can show under its own name). They're written `fortrip:<tool>` below:\n{{/if}}\n{{#if cli}}\nThe `fortrip` CLI (npm package `fortrip`) calls Fortrip as the signed-in user and prints each answer as compact text (`--json` prints its JSON):\n{{/if}}\n{{#if claude-skill cli}}\n\n| {{#if claude-skill}}Tool{{/if}}{{#if cli}}Command{{/if}} | Returns |\n|---|---|\n| `{{tool:hotels search}}` | Hotels in a place, near a point or matching a name (`{{arg:text}}`), with indicative prices |\n| `{{tool:hotels get}}` | One hotel's address, check-in and check-out times, description, policies, amenities and rooms; no prices |\n| `{{tool:hotels offers}}` | Live offers (room, meals, total in USD, cancellation terms) for up to {{limit:offersHotels}} hotels |\n| `{{tool:hotels book}}` | An unpaid order for one offer, with its terms and a payment link |\n| `{{tool:orders get}}` | One order and its status, including whether the hotel confirmed it |\n| `{{tool:orders list}}` | The user's orders, newest first, including those made on the Fortrip website |\n\nFor flexible dates, a budget, split stays, several destinations or \"find me the best\", {{#if claude-skill}}read [references/planning.md](references/planning.md){{/if}}{{#if cli}}also run `{{tool:guide}} planning`{{/if}} before searching.\n{{/if}}\n",
+  "setup": "{{#if cli}}\n## Setup\n\nRun every command as `npx -y fortrip@latest <command>` (Node.js 22 or newer). The examples below shorten that to `fortrip`; `fortrip <command> --help` lists a command's flags. `{{tool:hotels search}}`, `{{tool:hotels offers}}` and `{{tool:hotels book}}` also take `--body '<json>'` (or `--body @file.json`), the raw request body; flags override its fields. Add `--json` to any command that calls Fortrip to get its answer as one line of JSON instead of text.\n\nWhen the user first asks about hotels, run `{{tool:whoami}}` before asking follow-up questions, so the sign-in can happen while they answer.\n\n{{/if}}\n{{#if claude-skill cli}}\n## Sign-in\n\n{{/if}}\nSign-in happens only in the browser. Never ask the user to paste a token.\n{{#if claude-skill}}\n\nIf none of these tools are available, Fortrip isn't connected: tell the user to add the Fortrip connector or plugin and sign in.\n{{/if}}\n{{#if mcp claude-skill}}\nIf a tool says the user isn't signed in, ask them to reconnect Fortrip.\n{{/if}}\n{{#if cli}}\n\nIf a command exits with code **3** and stderr has `loginUrl`, show it to the user as a link together with `userCode`, e.g. \"Sign in to Fortrip: <loginUrl> (code <userCode>), then tell me when you're done.\" When they confirm, rerun the same command; it finishes the sign-in itself. Don't run `{{tool:login}}`: it waits for up to 10 minutes. Commands that exit 3 together share one `loginUrl`; show it once. If the rerun gives a different `loginUrl`, show that one.\n\nWhen Fortrip no longer accepts the saved sign-in (it was revoked, or it expired and couldn't be renewed), the command also exits 3 with a `loginUrl`; handle it the same way. The saved sign-in is kept until the user approves the new link.\n\nIn CI or a sandbox without a browser, the user can set `FORTRIP_TOKEN` instead. Exit 3 with `tokenSource: \"FORTRIP_TOKEN\"` means Fortrip didn't accept that token: tell the user to replace or unset it.\n\n## Exit codes\n\n| Code | Meaning | What to do |\n|---|---|---|\n| 0 | Success; the answer on stdout | Continue |\n| 1 | Any other error: an error from Fortrip (see Errors), a network error or a timeout | Read the error on stderr. If `retryable` is true, wait `retryAfterSeconds` (or a few seconds) and retry once |\n| 2 | Invalid arguments, or `invalid_request` from Fortrip | Fix the flags; the error lists each bad field with a message |\n| 3 | Not signed in | Show `loginUrl` to the user, then rerun (above) |\n| 4 | Rate limited | Wait `retryAfterSeconds`, then retry once |\n\nOutput on stdout or stderr can carry `warning` (with `recoveryFile` when a sign-in couldn't be saved): pass it on to the user.\n{{/if}}\n",
+  "support": "{{#if claude-skill cli}}\n## Changes and support\n\n{{/if}}\n{{#if mcp claude-skill}}These tools{{/if}}{{#if cli}}The CLI{{/if}} can't change or cancel an order: for changes, cancellations, refunds or other problems, the user emails {{support}} with the order's `reference` (never `payment.url`).\n"
 };
 
 // src/guide.ts
@@ -783,13 +1122,13 @@ function select(text2, surface) {
       }
       continue;
     }
-    const names = tag[1].trim().split(/\s+/);
-    for (const name of names) {
+    const names2 = tag[1].trim().split(/\s+/);
+    for (const name of names2) {
       if (!SURFACES.includes(name)) {
         throw new Error(`Unknown guide surface "${name}" in ${tag[0]}`);
       }
     }
-    open.push(names.includes(surface));
+    open.push(names2.includes(surface));
   }
   if (open.length > 0) throw new Error("Guide has {{#if}} without {{/if}}");
   return out + tagged.slice(from);
@@ -797,18 +1136,18 @@ function select(text2, surface) {
 function resolve(token, surface, shown) {
   const body = token.slice(2, -2);
   if (body === "support") return SUPPORT_EMAIL;
-  const [kind, name, ...rest] = body.split(":");
+  const [kind2, name, ...rest] = body.split(":");
   if (name !== void 0 && rest.length === 0) {
-    if (kind === "limit" && Object.hasOwn(LIMITS, name)) {
+    if (kind2 === "limit" && Object.hasOwn(LIMITS, name)) {
       return String(LIMITS[name]);
     }
-    if (kind === "tool") {
+    if (kind2 === "tool") {
       const spec = COMMANDS.find(
         (command) => commandInvocation(command) === `fortrip ${name}`
       );
       if (spec) return shown ? toolName(spec, surface, token) : token;
     }
-    if (kind === "arg") {
+    if (kind2 === "arg") {
       const flags = new Set(
         COMMANDS.flatMap((command) => command.flags).filter((flag3) => flag3.field === name).map((flag3) => flag3.flag)
       );
@@ -828,170 +1167,1514 @@ function toolName(spec, surface, token) {
   return surface === "mcp" ? spec.tool : `fortrip:${spec.tool}`;
 }
 
-// src/outputs.ts
-import { z as z4 } from "zod";
-var bookingResult = z4.object({
-  agentOrderId: z4.string(),
-  paymentUrl: z4.string().describe(
-    "Fortrip page that recaps the booking and continues to payment. Anyone holding it can pay"
+// src/outputs/account.ts
+import { z as z8 } from "zod";
+var meResult = openObject({
+  userId: z8.string(),
+  email: z8.string().nullable(),
+  name: z8.string().nullable()
+});
+var authConfig = openObject({
+  issuer: z8.string(),
+  clientId: z8.string(),
+  scopes: z8.string(),
+  deviceAuthorizationEndpoint: z8.string(),
+  tokenEndpoint: z8.string(),
+  revocationEndpoint: z8.string()
+});
+
+// src/outputs/common.ts
+import { z as z9 } from "zod";
+var names = openObject({
+  en: z9.string().nullable(),
+  zh: z9.string().nullable()
+});
+var latLng = openObject({ lat: z9.number(), lng: z9.number() });
+var LOCALES2 = ["en", "zh"];
+var knownLocaleText = openObject({
+  text: z9.string(),
+  locale: openEnum(LOCALES2)
+});
+var localizedText = openObject({
+  text: z9.string(),
+  locale: openEnum(LOCALES2).nullable()
+});
+var stayEcho = openObject({
+  checkIn: localDate,
+  checkOut: localDate,
+  rooms: z9.array(
+    openObject({
+      adults: z9.number().int(),
+      childrenAges: z9.array(z9.number().int())
+    })
+  ).min(1)
+});
+
+// src/outputs/error-details.ts
+import { z as z15 } from "zod";
+
+// src/errors.ts
+var ERROR_CODES = {
+  invalid_request: { status: [400], retryable: false },
+  cursor_invalid: { status: [400], retryable: false },
+  unauthenticated: { status: [401], retryable: false },
+  forbidden: { status: [403], retryable: false },
+  not_found: { status: [404], retryable: false },
+  order_removed: { status: [410], retryable: false },
+  offer_expired: { status: [409], retryable: false },
+  offer_changed: { status: [409], retryable: false },
+  offer_already_ordered: { status: [409], retryable: false },
+  order_exists: { status: [409], retryable: false },
+  order_in_progress: { status: [409], retryable: true },
+  order_attempts_exhausted: { status: [409], retryable: false },
+  destination_ambiguous: { status: [422], retryable: false },
+  destination_not_found: { status: [422], retryable: false },
+  search_too_broad: { status: [422], retryable: false },
+  stay_unsupported: { status: [422], retryable: false },
+  stay_in_past: { status: [422], retryable: false },
+  offer_unavailable: { status: [422], retryable: false },
+  rate_limited: { status: [429], retryable: true },
+  ordering_paused: { status: [503], retryable: true },
+  service_unavailable: { status: [503], retryable: true },
+  supplier_unavailable: { status: [503, 504], retryable: true },
+  internal: { status: [500], retryable: false }
+};
+
+// src/outputs/offer.ts
+import { z as z13 } from "zod";
+
+// src/outputs/hotel.ts
+import { z as z12 } from "zod";
+
+// src/outputs/search.ts
+import { z as z11 } from "zod";
+
+// src/outputs/place.ts
+import { z as z10 } from "zod";
+var PLACE_KINDS = [
+  "country",
+  "region",
+  "district",
+  "settlement",
+  "neighbourhood",
+  "island"
+];
+var placeRef = openObject({
+  placeId,
+  name: z10.string(),
+  names
+});
+var place = openObject({
+  placeId,
+  name: z10.string(),
+  names,
+  kind: openEnum(PLACE_KINDS),
+  scope: openEnum(["area", "radius"]),
+  cityLike: z10.boolean().nullable(),
+  population: z10.number().int().nullable(),
+  region: placeRef.nullable(),
+  countryCode: z10.string(),
+  location: latLng
+});
+var CENTER_BASES = [
+  "seat",
+  "capital",
+  "busiest_settlement",
+  "hub",
+  "point"
+];
+var center = openObject({
+  location: latLng,
+  place: placeRef.nullable(),
+  basis: openEnum(CENTER_BASES)
+});
+
+// src/outputs/search.ts
+var SEARCH_NOTE_CODES = [
+  "indicative_prices",
+  "prices_unavailable",
+  "pool_limited",
+  "amenities_listed_only",
+  "place_resolved_dominant",
+  "area_absorbed",
+  "broad_area",
+  "island_radius",
+  "area_retired",
+  "more_outside_radius",
+  "more_elsewhere",
+  "few_hotels_in_scope",
+  "party_split_required",
+  "no_results",
+  "locality_available"
+];
+var indicativePrice = openObject({
+  kind: openEnum(["indicative"]),
+  basis: openEnum(["lowest_unit"]),
+  fromPerRoomNight: money,
+  fromPerRoomStay: money,
+  approx: openObject({
+    fromPerRoomNight: money,
+    fromPerRoomStay: money,
+    rateDate: localDate
+  }).nullable()
+});
+var hotelSummary = openObject({
+  hotelId,
+  name: z11.string(),
+  names,
+  stars: z11.number().nullable(),
+  address: openObject({
+    line: knownLocaleText.nullable(),
+    countryCode: z11.string().nullable(),
+    region: placeRef.nullable()
+  }),
+  location: latLng.nullable(),
+  timeZone: z11.string().nullable(),
+  distanceMeters: z11.number().nullable(),
+  price: indicativePrice.nullable()
+});
+var localities = openObject({
+  items: z11.array(
+    openObject({
+      place: placeRef,
+      count: z11.number().int(),
+      total: z11.number().int(),
+      includes: z11.array(
+        openObject({ place: placeRef, members: z11.number().int() })
+      )
+    })
   ),
-  amount: z4.number().nullable().describe("What the user will be charged, in currency"),
-  currency: z4.string(),
-  orderUrl: z4.string().describe("The signed-in order page"),
-  statusUrl: z4.string().optional().describe("The booking status page; the same page as paymentUrl"),
-  stay: z4.object({
-    hotelId: z4.number(),
-    hotelName: z4.string().nullable(),
-    roomName: z4.string().nullable(),
-    checkIn: z4.string(),
-    checkOut: z4.string(),
-    nights: z4.number(),
-    rooms: z4.number(),
-    adultsPerRoom: z4.number(),
-    childrenAgesPerRoom: z4.array(z4.number())
-  }).describe("The stay as booked; every room has the same occupancy"),
-  terms: z4.object({
-    boardCode: z4.string(),
-    boardCount: z4.number(),
-    refundable: z4.boolean(),
-    freeCancelUntil: z4.string().nullable(),
-    cancellation: z4.array(z4.object({ amount: z4.number(), from: z4.string() })),
-    isInstantConfirm: z4.boolean(),
-    confirmByMins: z4.number().nullable(),
-    payAtHotelFees: z4.array(
-      z4.object({
-        type: z4.string(),
-        isMandatory: z4.boolean(),
-        amount: z4.number(),
-        currency: z4.string()
+  unassigned: z11.number().int(),
+  more: z11.number().int()
+});
+var radiusSource = openEnum(["default", "requested"]);
+var destination2 = openUnion("kind", [
+  openObject({
+    kind: z11.literal("place"),
+    place,
+    resolution: openEnum([
+      "only_match",
+      "dominant",
+      "by_id",
+      "by_country_code",
+      "by_locality"
+    ]),
+    otherMatches: z11.number().int(),
+    scope: openEnum(["area", "radius", "locality"]),
+    center,
+    radiusMeters: z11.number().nullable(),
+    radiusSource: radiusSource.nullable()
+  }),
+  openObject({
+    kind: z11.literal("point"),
+    center,
+    scope: openEnum(["radius"]),
+    radiusMeters: z11.number(),
+    radiusSource
+  })
+]);
+var count = z11.number().int();
+var searchResult = openObject({
+  destination: destination2.nullable(),
+  text: openObject({
+    value: z11.string(),
+    match: openEnum(["exact"])
+  }).nullable(),
+  stay: stayEcho.nullable(),
+  pricing: openObject({
+    mode: openEnum(["indicative", "none"]),
+    scope: openEnum(["page", "pool"]).nullable(),
+    status: openEnum(["ok", "unavailable"]).nullable()
+  }),
+  sort: openEnum([
+    "distance",
+    "relevance",
+    "stars_desc",
+    "price_asc",
+    "price_desc"
+  ]),
+  coverage: openObject({
+    matched: count,
+    priced: count.nullable(),
+    withPrice: count.nullable(),
+    poolRadiusMeters: z11.number().nullable(),
+    excludedNoPrice: count.nullable(),
+    excludedNoFacilityData: count.nullable(),
+    withinMaxRadius: count.nullable(),
+    textAnywhere: count.nullable(),
+    localities: localities.nullable(),
+    nameAsText: count.nullable()
+  }),
+  data: z11.array(hotelSummary),
+  nextCursor: z11.string().nullable(),
+  notes: z11.array(
+    openObject({ code: openEnum(SEARCH_NOTE_CODES), message: z11.string() })
+  )
+});
+
+// src/outputs/hotel.ts
+var POLICY_TOPICS = [
+  "check_in",
+  "important_notices",
+  "booking",
+  "booking_tips",
+  "check_in_out",
+  "check_in_tips",
+  "reception",
+  "deposit",
+  "meal",
+  "extra_bed",
+  "pets",
+  "surroundings",
+  "meetings",
+  "non_smoking",
+  "other"
+];
+var roomFacts = {
+  beds: localizedText.nullable(),
+  areaSqm: openObject({ min: z12.number(), max: z12.number() }).nullable(),
+  maxOccupancy: z12.number().int().nullable(),
+  window: openEnum(["yes", "no", "partial"]).nullable()
+};
+var timeRange = openObject({
+  from: localTime.nullable(),
+  until: localTime.nullable()
+});
+var hotel = openObject({
+  hotelId,
+  name: z12.string(),
+  names,
+  bookable: z12.boolean(),
+  stars: z12.number().nullable(),
+  address: hotelSummary.shape.address,
+  location: latLng.nullable(),
+  timeZone: z12.string().nullable(),
+  description: knownLocaleText.nullable(),
+  checkInTimes: timeRange,
+  checkOutTimes: timeRange,
+  policies: openObject({
+    listed: z12.boolean(),
+    items: z12.array(
+      openObject({
+        topic: openEnum(POLICY_TOPICS),
+        text: z12.string(),
+        locale: openEnum(["en", "zh"]).nullable()
       })
     )
-  }).nullable()
+  }),
+  amenities: openObject({
+    listed: z12.boolean(),
+    items: z12.array(
+      openObject({ code: openEnum(AMENITY_CODES), name: knownLocaleText })
+    )
+  }),
+  breakfastServed: z12.boolean().nullable(),
+  deposit: openObject({
+    required: z12.boolean().nullable(),
+    amount: money.nullable()
+  }),
+  contact: openObject({
+    phone: z12.string().nullable(),
+    website: z12.string().nullable()
+  }),
+  rooms: openObject({
+    listed: z12.boolean(),
+    items: z12.array(openObject({ name: localizedText, ...roomFacts }))
+  }).optional()
+});
+
+// src/outputs/offer.ts
+var meals = openObject({
+  known: z13.boolean(),
+  included: z13.array(openEnum(["breakfast", "lunch", "dinner"])).nullable(),
+  unspecifiedMainMeals: z13.number().int().nullable(),
+  allInclusive: z13.boolean().nullable(),
+  guestsCoveredPerRoom: z13.number().int().nullable(),
+  label: localizedText.nullable()
+});
+var payAtProperty = openObject({
+  disclosure: openEnum(["complete", "incomplete"]),
+  items: z13.array(
+    openObject({
+      label: localizedText.nullable(),
+      amount: money.nullable(),
+      mandatory: z13.boolean(),
+      basis: openEnum([
+        "per_stay",
+        "per_night",
+        "per_person",
+        "per_person_per_night",
+        "unknown"
+      ]),
+      collectedAt: openEnum(["property", "unknown"])
+    })
+  )
+});
+var cancellation = openObject({
+  status: openEnum(["free", "partial_penalty", "non_refundable", "unknown"]),
+  asOf: instant,
+  freeCancellationEndsAt: instant.nullable(),
+  penalties: z13.array(
+    openObject({ startsAt: instant.nullable(), amount: money })
+  ),
+  timeZone: z13.string().nullable()
+});
+var confirmation = openObject({
+  mode: openEnum(["instant", "on_request", "unknown"]),
+  withinMinutes: z13.number().int().nullable()
+});
+var offer = openObject({
+  offerId,
+  type: openEnum(["hotel"]),
+  expiresAt: instant,
+  hotel: openObject({
+    hotelId,
+    room: openObject({ name: localizedText.nullable(), ...roomFacts }),
+    roomCount: z13.number().int(),
+    meals
+  }),
+  price: openObject({
+    total: money,
+    perNightAllRooms: money,
+    approx: openObject({
+      total: money,
+      perNightAllRooms: money,
+      rateDate: localDate
+    }).nullable(),
+    payAtProperty
+  }),
+  cancellation,
+  confirmation
+});
+var omitted = openObject({
+  byNationality: z13.number().int(),
+  byFilters: z13.number().int(),
+  dominated: z13.number().int(),
+  unreadable: z13.number().int(),
+  byLimit: z13.number().int()
+});
+var UNAVAILABLE_REASONS = [
+  "sold_out",
+  "no_matching_offers",
+  "nationality_restricted",
+  "offers_unreadable",
+  "not_found",
+  "supplier_unavailable",
+  "stay_in_past"
+];
+var hotelOffersResult = openObject({
+  stay: stayEcho,
+  hotels: z13.array(
+    openObject({
+      hotel: openObject({ hotelId, name: z13.string(), names }),
+      offers: z13.array(offer),
+      omitted
+    })
+  ),
+  unavailable: z13.array(
+    openObject({
+      hotelId,
+      reason: openEnum(UNAVAILABLE_REASONS),
+      omitted: omitted.nullable()
+    })
+  )
 });
-var meResult = z4.object({
-  userId: z4.string(),
-  email: z4.string().nullable(),
-  name: z4.string().nullable()
+
+// src/outputs/order.ts
+import { z as z14 } from "zod";
+var ORDER_STATUSES = [
+  "awaiting_payment",
+  "expired",
+  "confirming",
+  "confirmed",
+  "failed",
+  "cancelling",
+  "cancelled",
+  "needs_attention"
+];
+var PAYMENT_STATUSES = [
+  "unpaid",
+  "authorized",
+  "paid",
+  "released",
+  "refund_pending",
+  "refunded"
+];
+var orderReference = z14.string().regex(/^FT-[2-9A-HJ-NP-Z]{6}$/);
+var hotelItem = openObject({
+  type: z14.literal("hotel"),
+  hotel: openObject({
+    hotelId: hotelId.nullable(),
+    name: z14.string(),
+    names,
+    checkIn: localDate,
+    checkOut: localDate,
+    timeZone: z14.string().nullable(),
+    rooms: stayEcho.shape.rooms,
+    room: openObject({
+      name: localizedText.nullable(),
+      beds: localizedText.nullable()
+    }),
+    meals,
+    cancellation,
+    payAtProperty,
+    confirmationNumber: z14.string().nullable()
+  })
+});
+var order = openObject({
+  orderId,
+  reference: orderReference,
+  status: openEnum(ORDER_STATUSES),
+  createdAt: instant,
+  updatedAt: instant,
+  items: z14.array(openUnion("type", [hotelItem])).min(1),
+  price: openObject({ total: money }),
+  payment: openObject({
+    status: openEnum(PAYMENT_STATUSES),
+    url: z14.string().nullable(),
+    requiresSignIn: z14.boolean(),
+    expiresAt: instant.nullable(),
+    chargeCurrency: z14.string(),
+    localCurrencyAtCheckout: z14.boolean(),
+    localCharge: money.nullable()
+  }),
+  manageUrl: z14.string()
 });
-var authConfig = z4.object({
-  issuer: z4.string(),
-  clientId: z4.string(),
-  scopes: z4.string(),
-  deviceAuthorizationEndpoint: z4.string(),
-  tokenEndpoint: z4.string(),
-  revocationEndpoint: z4.string()
+var orderList = openObject({
+  data: z14.array(order),
+  nextCursor: z14.string().nullable()
 });
+function change(field, value) {
+  return openObject({
+    field: z14.literal(field),
+    previous: value,
+    current: value,
+    worse: z14.boolean()
+  });
+}
+var offerChange = openUnion("field", [
+  change("price", money),
+  change("meals", meals),
+  change("cancellation", cancellation),
+  change("confirmation", confirmation),
+  change("pay_at_property", payAtProperty)
+]);
+
+// src/outputs/error-details.ts
+var count2 = z15.number().int();
+var ERROR_DETAILS = {
+  invalid_request: openObject({
+    issues: z15.array(openObject({ pointer: z15.string(), message: z15.string() })),
+    filterable: z15.array(openEnum(AMENITY_CODES)).optional(),
+    share: openObject({
+      code: openEnum(AMENITY_CODES),
+      listedShare: z15.number().min(0).max(1)
+    }).optional()
+  }),
+  cursor_invalid: openObject({
+    reason: openEnum(["expired", "mismatch", "malformed"])
+  }),
+  unauthenticated: null,
+  forbidden: null,
+  not_found: null,
+  order_removed: openObject({ orderId, reference: orderReference }),
+  offer_expired: openObject({ offerId, expiredAt: instant }),
+  offer_changed: openObject({ changes: z15.array(offerChange).min(1), offer }),
+  offer_already_ordered: openObject({ orderId }),
+  order_exists: openObject({ orderId, status: openEnum(ORDER_STATUSES) }),
+  order_in_progress: openObject({ orderId }),
+  order_attempts_exhausted: openObject({ orderId }),
+  destination_ambiguous: openObject({
+    name: z15.string(),
+    countryCode: z15.string(),
+    candidates: z15.array(
+      openObject({
+        ...place.shape,
+        hotels: openObject({
+          scope: openEnum(["area", "radius"]),
+          radiusMeters: z15.number().nullable(),
+          count: count2
+        })
+      })
+    ),
+    candidatesTotal: count2,
+    nameAsText: count2.nullable()
+  }),
+  destination_not_found: openUnion("reason", [
+    openObject({
+      reason: z15.literal("no_match"),
+      name: z15.string(),
+      countryCode: z15.string(),
+      nameAsText: count2.nullable()
+    }),
+    openObject({ reason: z15.literal("unknown_id"), placeId }),
+    openObject({
+      reason: z15.literal("not_a_locality"),
+      placeId,
+      hub: placeRef.nullable(),
+      hubTotal: count2.nullable()
+    })
+  ]),
+  search_too_broad: openObject({
+    matched: count2,
+    poolLimit: count2,
+    localities,
+    /** The searched area's center, as a search echoes it; null for text only.
+     *  Optional for clients; the server must send it (`SERVER_DETAILS`). */
+    center: center.nullable().optional()
+  }),
+  stay_unsupported: openUnion("reason", [
+    openObject({ reason: z15.literal("mixed_occupancy") }),
+    openObject({ reason: z15.literal("max_nights"), max: count2 })
+  ]),
+  stay_in_past: openObject({
+    checkIn: localDate,
+    timeZone: z15.string().nullable()
+  }),
+  offer_unavailable: openObject({
+    offerId,
+    reason: openEnum(["sold_out", "refused"])
+  }),
+  rate_limited: openObject({
+    scope: openEnum(["search", "offers", "hotel", "orders_read", "orders_create"])
+  }),
+  ordering_paused: null,
+  service_unavailable: null,
+  supplier_unavailable: openObject({
+    outcome: openEnum(["not_started", "unknown"])
+  }),
+  internal: null
+};
+var SERVER_DETAILS = {
+  search_too_broad: ERROR_DETAILS.search_too_broad.extend({ center: center.nullable() })
+};
+function envelopeSchema(detailsRequired) {
+  return openObject({
+    error: openUnion(
+      "code",
+      Object.keys(ERROR_CODES).map((code) => {
+        const details = detailsRequired ? SERVER_DETAILS[code] ?? ERROR_DETAILS[code] : ERROR_DETAILS[code];
+        return openObject({
+          code: z15.literal(code),
+          message: z15.string(),
+          param: z15.string().optional(),
+          retryable: z15.boolean(),
+          retryAfterSeconds: z15.number().int().optional(),
+          ...details ? { details: detailsRequired ? details : details.optional() } : {},
+          requestId: z15.string()
+        });
+      })
+    )
+  });
+}
+var errorEnvelope = envelopeSchema(false);
+function strictErrorEnvelope() {
+  return strictOutput(envelopeSchema(true));
+}
 
 // src/paths.ts
+var PUBLIC_ORIGINS = {
+  api: "https://api.fortrip.ai",
+  mcp: "https://mcp.fortrip.ai"
+};
 var API = {
-  me: "/api/agent/v1/me",
-  authConfig: "/api/agent/v1/auth/config",
-  search: "/api/agent/v1/hotels/search",
-  rates: "/api/agent/v1/hotels/rates",
-  bookings: "/api/agent/v1/hotels/bookings",
-  mcp: "/api/mcp",
-  hotel(id, includeRooms) {
-    return `/api/agent/v1/hotels/${id}${includeRooms ? "?include=rooms" : ""}`;
+  me: "/v1/me",
+  authConfig: "/v1/auth/config",
+  hotelSearch: "/v1/hotels/search",
+  hotelOffers: "/v1/hotels/offers",
+  orders: "/v1/orders",
+  hotel(id, opts) {
+    const query = [];
+    if (opts?.rooms) query.push("include=rooms");
+    if (opts?.locale) query.push(`locale=${opts.locale}`);
+    return `/v1/hotels/${encodeURIComponent(id)}${query.length ? `?${query.join("&")}` : ""}`;
+  },
+  order(id, opts) {
+    return `/v1/orders/${encodeURIComponent(id)}${opts?.locale ? `?locale=${opts.locale}` : ""}`;
   }
 };
-
-// src/reasons.ts
-var reasonStatuses = {
-  already_booked: [409],
-  price_or_terms_changed: [409],
-  rate_unavailable: [422],
-  refused: [422],
-  supplier_unavailable: [503, 504]
-};
-var ERROR_REASONS = reasonStatuses;
+var MCP_PATH = "/";
 
 // src/tools.ts
-import { z as z5 } from "zod";
-var MCP_MAX_ROOMS_PER_HOTEL = 5;
-var MCP_RATES_INPUT = getRatesInput.safeExtend({
-  maxRoomsPerHotel: wholeNumber("maxRoomsPerHotel", 1, LIMITS.maxRoomsPerHotel).default(MCP_MAX_ROOMS_PER_HOTEL).describe(
-    `Return the N cheapest rooms per hotel. Defaults to ${MCP_MAX_ROOMS_PER_HOTEL}.`
-  )
-});
-var BOOKING_NEXT_STEP = "Show the user amount, currency, the stay (hotel, room, dates, rooms, guests per room) and every item in terms (meals, cancellation, confirmation, pay-at-hotel fees), then end your reply by asking them to confirm. Only after they say yes, give them paymentUrl exactly as returned.";
-var MCP_BOOKING_RESULT = bookingResult.extend({
-  nextStep: z5.string()
-});
-var MEAL_CODES = "RO room only; BB breakfast; HB breakfast + dinner; FB breakfast + lunch + dinner; BL lunch; BD dinner; HBBL breakfast + lunch; HBLD lunch + dinner; AI all inclusive";
+import { z as z16 } from "zod";
+var ORDER_NEXT_STEP = "Before you give the user an order's payment.url, show them its total and currency, the stay (hotel, room, dates, rooms and guests per room) and every term (meals, cancellation, fees payable at the property), then end your reply by asking them to confirm, and wait for a clear yes. Only after they say yes, give them payment.url exactly as returned.";
+var nextStep = z16.string().optional().describe(
+  "What to show and ask before giving a payment.url. Present when the answer holds a non-null payment.url, and only then."
+);
+var MCP_OUTPUT = {
+  book_hotel: order.extend({ nextStep }),
+  get_order: order.extend({ nextStep }),
+  list_orders: orderList.extend({ nextStep })
+};
+var READ = {
+  readOnlyHint: true,
+  idempotentHint: true,
+  openWorldHint: true,
+  destructiveHint: false
+};
+var READ_OWN = { ...READ, openWorldHint: false };
 var TOOLS = [
   {
     name: "get_planning_guide",
     title: "Get hotel planning guide",
     description: `Returns Fortrip's planning guide for a request that is more than one hotel for fixed dates (flexible dates, a budget, split stays, several destinations, "find me the best"): what to ask the user, which results count as evidence, how to rank and how to present options.`,
-    annotations: {
-      readOnlyHint: true,
-      idempotentHint: true,
-      openWorldHint: false,
-      destructiveHint: false
-    },
+    annotations: READ_OWN,
     input: null,
     output: null
   },
   {
     name: "search_hotels",
     title: "Search hotels",
-    description: "Find hotels by name/brand/city text (query), catalogue cityCode or coordinates (near), with per-night prices for the dates in currency (CNY by default, or USD). Those prices come from the supplier's minimum-price feed, not live rates; get_hotel_rates returns the bookable price. facilities must match catalogue names exactly. Refused (422) when more than 30,000 hotels match: narrow the search.",
-    annotations: {
-      readOnlyHint: true,
-      idempotentHint: true,
-      openWorldHint: true,
-      destructiveHint: false
-    },
+    description: 'Find hotels by destination and/or text, with an indicative per-room-night price when a stay is given. destination is a place_name with its countryCode, a place or locality by placeId from an earlier answer, a point, or a country. A name several places bear answers destination_ambiguous with candidates: ask the user, then search the chosen placeId. text matches hotel names, brands and areas word for word. Indicative prices are estimates and not bookable: get_hotel_offers returns what the user pays. A search too broad to answer is refused with search_too_broad and its localities: pass one back as { kind: "locality", placeId }, never by name. The answer states the scope, the counts and notes; a next page is the cursor and, optionally, limit.',
+    annotations: READ,
     input: searchHotelsInput,
-    output: null
+    output: searchResult
   },
   {
     name: "get_hotel",
     title: "Get hotel details",
-    description: "Static catalogue facts for one hotel: address, contact, intro, check-in/out times, policies, facilities and photos. No prices or availability.",
-    annotations: {
-      readOnlyHint: true,
-      idempotentHint: true,
-      openWorldHint: true,
-      destructiveHint: false
-    },
+    description: `One hotel's catalogue facts: names, address, location, time zone, check-in and check-out times, the full description, every policy and the amenities, and its rooms with include: "rooms". "Not listed" is not "no". No prices or availability: get_hotel_offers has those.`,
+    annotations: READ,
     input: getHotelInput,
-    output: null
+    output: hotel
   },
   {
-    name: "get_hotel_rates",
-    title: "Get live hotel rates",
-    description: `Live rooms and rate plans for up to ${LIMITS.ratesHotels} hotels, prices in currency (CNY by default, or USD) at Stripe's exchange rate. rooms, adults and childrenAges are per room: every room has the same occupancy. Each room carries its catalogue facts (static) and the cheapest rate per meal plan \xD7 free-cancellation variant, with roomId and ratePlanCode for book_hotel. boardCode is the meal plan (${MEAL_CODES}); boardCount is how many guests per room it covers: fewer than adults per room means the meals don't cover everyone (BB with boardCount 1 for 2 adults is breakfast for 1 of 2). Takes about 15 seconds; query a few hotels at a time. Returns the ${MCP_MAX_ROOMS_PER_HOTEL} cheapest rooms per hotel unless maxRoomsPerHotel says otherwise.`,
-    annotations: {
-      readOnlyHint: true,
-      idempotentHint: true,
-      openWorldHint: true,
-      destructiveHint: false
-    },
-    input: MCP_RATES_INPUT,
-    output: null
+    name: "get_hotel_offers",
+    title: "Get live hotel offers",
+    description: `Live, bookable offers for up to ${LIMITS.offersHotels} hotels and one stay. Every room in stay.rooms must have the same party: for different parties, call once per party. Each offer has the room, the meals included, price.total in USD for the whole stay and every room (what is charged), fees payable at the property, the cancellation terms with times in UTC and the hotel's time zone, the confirmation mode, and an offerId for book_hotel that expires at expiresAt. Hotels with nothing to offer are listed under unavailable with the reason. Up to limitPerHotel offers per hotel, default ${LIMITS.offersPerHotelDefault}, cheapest first.`,
+    annotations: READ,
+    input: hotelOffersInput,
+    output: hotelOffersResult
   },
   {
     name: "book_hotel",
-    title: "Create hotel booking payment link",
-    description: `Create (or resume) a booking for one rate from get_hotel_rates, with the same rooms, adults and childrenAges (per room). Returns the amount and currency the user will be charged, the accepted terms (meal plan, cancellation, confirmation, pay-at-hotel fees), the stay as booked, and paymentUrl: a Fortrip page that recaps the booking and continues to payment. Nothing is charged until the user pays there; anyone holding paymentUrl can pay. The same user and stay always returns the same order; a stay that is already paid returns 409. This tool can't change or cancel a booking: for changes, cancellations or refunds the user emails ${SUPPORT_EMAIL} with the booking's orderUrl. Can take up to about two minutes; if the call times out, call it again with the same details \u2014 it resumes the same order.`,
+    title: "Create hotel order and payment link",
+    description: `Order one offer from get_hotel_offers. The answer is an unpaid order with a payment link: status awaiting_payment, the total, the stay and its terms, and payment.url, a Fortrip page where the user pays. Nothing is charged until the user pays there; anyone holding the link can pay. Send the contact and, for each room of the offer, at least one guest. If the price or terms changed since the offer, the answer is offer_changed with every change and a new offer: show the changes and ask the user again before ordering it. Sending the same details again returns the same order. This tool can't change or cancel an order: for changes, cancellations or refunds the user emails ${SUPPORT_EMAIL} with the order's reference.`,
     annotations: {
       readOnlyHint: false,
-      idempotentHint: true,
+      idempotentHint: false,
       openWorldHint: true,
       destructiveHint: false
     },
-    input: createBookingInput,
-    output: MCP_BOOKING_RESULT
+    input: createOrderInput,
+    output: MCP_OUTPUT.book_hotel
+  },
+  {
+    name: "get_order",
+    title: "Get order",
+    description: "One of the user's orders by orderId: its status, the payment status and, while it awaits payment, payment.url; the stay and its terms; and the hotel's confirmation number once there is one. Check it after the user pays. An order awaiting payment whose payment.url is null had its link unreadable this time: read it again.",
+    annotations: READ_OWN,
+    input: getOrderInput,
+    output: MCP_OUTPUT.get_order
+  },
+  {
+    name: "list_orders",
+    title: "List orders",
+    description: "The user's hotel orders, newest first, including those made on the Fortrip website. Pass nextCursor back as cursor for the next page.",
+    annotations: READ_OWN,
+    input: listOrdersInput,
+    output: MCP_OUTPUT.list_orders
   }
 ];
 
+// src/render/format.ts
+function num(n) {
+  return n.toLocaleString("en-US");
+}
+function km(meters) {
+  return `${(meters / 1e3).toFixed(1)} km`;
+}
+function money2(m) {
+  return `${m.currency} ${m.amount}`;
+}
+function plural(n, one, many = `${one}s`) {
+  return `${num(n)} ${n === 1 ? one : many}`;
+}
+function named(name, names2) {
+  const other = [names2.en, names2.zh].find((n) => n && n !== name);
+  return other ? `${name} (${other})` : name;
+}
+function label(words, value) {
+  return Object.hasOwn(words, value) ? words[value] : value;
+}
+function stayLine(checkIn, checkOut) {
+  const nights = countIsoDateDays(checkIn, checkOut);
+  return `${checkIn} \u2192 ${checkOut} (${plural(nights, "night")})`;
+}
+function partyOf(room) {
+  const adults = plural(room.adults, "adult");
+  const n = room.childrenAges.length;
+  if (n === 0) return adults;
+  const ages = room.childrenAges.join(", ");
+  return `${adults} and ${plural(n, "child", "children")} (${n === 1 ? "age" : "ages"} ${ages})`;
+}
+function party(rooms) {
+  const parties = rooms.map(partyOf);
+  if (parties.length === 1) return `1 room: ${parties[0]}`;
+  if (parties.every((p) => p === parties[0])) {
+    return `${parties.length} rooms, each ${parties[0]}`;
+  }
+  return `${parties.length} rooms: ${parties.map((p, i) => `room ${i + 1} ${p}`).join("; ")}`;
+}
+function when(instant2, timeZone2) {
+  const utc = `${instant2.slice(0, 10)} ${instant2.slice(11, 16)} UTC`;
+  if (!timeZone2) return utc;
+  try {
+    const parts = new Intl.DateTimeFormat("en-CA", {
+      timeZone: timeZone2,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h23"
+    }).formatToParts(new Date(instant2));
+    const part = (type) => parts.find((p) => p.type === type)?.value;
+    return `${utc} (${part("year")}-${part("month")}-${part("day")} ${part("hour")}:${part("minute")} ${timeZone2})`;
+  } catch {
+    return utc;
+  }
+}
+function raw(value) {
+  try {
+    return JSON.stringify(value) ?? "no value";
+  } catch {
+    return String(value);
+  }
+}
+var WINDOWS = {
+  yes: "window",
+  no: "no window",
+  partial: "window in some rooms"
+};
+function roomFacts2(r) {
+  const area = r.areaSqm ? r.areaSqm.min === r.areaSqm.max ? `${r.areaSqm.min} m\xB2` : `${r.areaSqm.min}\u2013${r.areaSqm.max} m\xB2` : "size not stated";
+  return [
+    r.beds ? `beds: ${r.beds.text}` : "beds not listed",
+    area,
+    r.maxOccupancy === null ? "max occupancy not listed" : `max ${plural(r.maxOccupancy, "guest")}`,
+    r.window === null ? "window not listed" : label(WINDOWS, r.window)
+  ];
+}
+
+// src/render/hotel.ts
+function times(what, t) {
+  if (t.from === null && t.until === null) return `${what}: not listed`;
+  return `${what} from ${t.from ?? "not listed"}, until ${t.until ?? "not listed"}`;
+}
+function deposit(d) {
+  if (d.required === null) return "Deposit: not stated";
+  if (!d.required) return "Deposit: not required";
+  return `Deposit: required, ${d.amount ? money2(d.amount) : "amount not stated"}`;
+}
+function roomLine(r) {
+  return [`- ${r.name.text}`, ...roomFacts2(r)].join(" \xB7 ");
+}
+function renderHotel(h) {
+  const region = h.address.region;
+  const lines = [
+    [
+      named(h.name, h.names),
+      h.stars === null ? "stars not listed" : `${h.stars}\u2605`,
+      h.hotelId,
+      h.bookable ? "" : "no longer bookable (it has left the catalogue)"
+    ].filter(Boolean).join(" \xB7 "),
+    [
+      `Address: ${h.address.line ? h.address.line.text : "not listed"}`,
+      region ? `${region.name} ${region.placeId}` : "",
+      h.address.countryCode ?? "",
+      h.location ? `${h.location.lat}, ${h.location.lng}` : "location not listed",
+      `time zone ${h.timeZone ?? "not listed"}`
+    ].filter(Boolean).join(" \xB7 "),
+    `${times("Check-in", h.checkInTimes)} \xB7 ${times("Check-out", h.checkOutTimes)} (local time)`,
+    `Breakfast served: ${h.breakfastServed === null ? "not stated" : h.breakfastServed ? "yes" : "no"}`,
+    deposit(h.deposit),
+    `Phone: ${h.contact.phone ?? "not listed"} \xB7 Website: ${h.contact.website ?? "not listed"}`
+  ];
+  if (!h.amenities.listed) {
+    lines.push('Amenities: not listed (unknown, not "none")');
+  } else if (h.amenities.items.length === 0) {
+    lines.push("Amenities: none listed");
+  } else {
+    const items = h.amenities.items.map((a) => `${a.name.text} (${a.code})`);
+    lines.push(`Amenities listed (others may exist): ${items.join(", ")}`);
+  }
+  if (!h.policies.listed) {
+    lines.push("Policies: not listed");
+  } else if (h.policies.items.length === 0) {
+    lines.push("Policies: none listed");
+  } else {
+    lines.push("Policies:", ...h.policies.items.map((p) => `- ${p.topic}: ${p.text}`));
+  }
+  if (h.rooms) {
+    if (!h.rooms.listed) lines.push("Rooms: not listed");
+    else if (h.rooms.items.length === 0) lines.push("Rooms: none listed");
+    else lines.push("Rooms:", ...h.rooms.items.map(roomLine));
+  }
+  if (h.description === null) {
+    lines.push("Description: not listed");
+  } else {
+    lines.push(`Description (${h.description.locale}):`, h.description.text);
+  }
+  return lines.join("\n");
+}
+
+// src/render/offers.ts
+var MEALS_UNKNOWN = "meals not stated by the supplier \u2014 not known to be room only, may include breakfast; ask or check at booking";
+function mealsText(m) {
+  if (!m.known) return MEALS_UNKNOWN;
+  if (m.included === null) return "meals not stated";
+  let base;
+  if (m.allInclusive) {
+    base = "all inclusive";
+  } else {
+    const extra = m.unspecifiedMainMeals;
+    const parts = [...m.included];
+    if (extra !== null && extra > 0) parts.push(`${plural(extra, "more main meal")} (not named)`);
+    if (parts.length === 0 && extra === 0) return "room only";
+    base = parts.length > 0 ? parts.join(" + ") : "no meals named";
+    if (extra === null) base += "; other main meals not stated";
+  }
+  return m.guestsCoveredPerRoom === null ? `${base}, guests covered not stated` : `${base} for ${plural(m.guestsCoveredPerRoom, "guest")} per room`;
+}
+function mealsWithLabel(m) {
+  const text2 = mealsText(m);
+  return m.label ? `${text2} (labelled "${m.label.text}")` : text2;
+}
+function cancellationText(c) {
+  if (c.status === "unknown") return "cancellation terms unknown";
+  const steps = c.penalties.map(
+    (p) => `${money2(p.amount)} from ${p.startsAt === null ? "booking" : when(p.startsAt, c.timeZone)}`
+  );
+  if (c.status === "free") {
+    const head2 = c.freeCancellationEndsAt === null ? "free cancellation until check-in" : `free cancellation until ${when(c.freeCancellationEndsAt, c.timeZone)}`;
+    return steps.length ? `${head2}, then ${steps.join("; ")}` : head2;
+  }
+  const head = label(
+    { partial_penalty: "partial penalty now", non_refundable: "non-refundable" },
+    c.status
+  );
+  return steps.length ? `${head}: ${steps.join("; ")}` : head;
+}
+var BASES = {
+  per_stay: "per stay",
+  per_night: "per night",
+  per_person: "per person",
+  per_person_per_night: "per person per night",
+  unknown: "basis unknown"
+};
+function feesText(p) {
+  const items = p.items.map(
+    (i) => [
+      `${i.label ? i.label.text : "unnamed fee"} ${i.amount ? money2(i.amount) : "amount not stated"}`,
+      label(BASES, i.basis),
+      i.mandatory ? "mandatory" : "optional",
+      i.collectedAt === "property" ? "at the property" : i.collectedAt === "unknown" ? "collection not stated (could be prepaid or at the property)" : `collected: ${i.collectedAt}`
+    ].filter(Boolean).join(", ")
+  );
+  const listed = `fees not in the total: ${items.join("; ")}`;
+  if (p.disclosure === "complete") {
+    return items.length ? listed : "nothing to pay at the property";
+  }
+  const caveat = p.disclosure === "incomplete" ? "fees not fully disclosed (amounts or how they are collected may be missing)" : `fees not in the total: disclosure ${p.disclosure}`;
+  return items.length ? `${listed}; ${caveat}` : caveat;
+}
+function confirmationText(c) {
+  if (c.mode === "instant") return "instant confirmation";
+  if (c.mode === "on_request") {
+    return c.withinMinutes === null ? "confirmation on request" : `confirmation on request, within ${c.withinMinutes} min`;
+  }
+  if (c.mode === "unknown") return "confirmation mode unknown";
+  return `confirmation ${c.mode}`;
+}
+function roomText(r) {
+  return [r.name ? r.name.text : "room name not listed", ...roomFacts2(r)].join(", ");
+}
+function offerLine(o) {
+  const p = o.price;
+  let price = `${money2(p.total)} total (${money2(p.perNightAllRooms)} per night, all rooms)`;
+  if (p.approx) {
+    price += ` \u2248 ${money2(p.approx.total)} (${money2(p.approx.perNightAllRooms)} per night), exchange rate of ${p.approx.rateDate}`;
+  }
+  return [
+    `${o.offerId}${o.type === "hotel" ? "" : ` (${o.type})`}`,
+    `${plural(o.hotel.roomCount, "room")}: ${roomText(o.hotel.room)}`,
+    price,
+    mealsWithLabel(o.hotel.meals),
+    cancellationText(o.cancellation),
+    confirmationText(o.confirmation),
+    feesText(p.payAtProperty),
+    `offer expires ${when(o.expiresAt, null)}`
+  ].join(" \xB7 ");
+}
+var OMITTED = {
+  byNationality: "restricted by nationality",
+  byFilters: "removed by the filters",
+  dominated: "beaten by another offer for the same room",
+  unreadable: "unreadable"
+};
+function limitText(o) {
+  const n = o.byLimit;
+  return typeof n === "number" && n > 0 ? `${plural(n, "more offer")} not shown (limitPerHotel); a filtered request (requireBreakfast / requireFreeCancellation) or a higher limitPerHotel may show them \u2014 don't conclude they don't exist` : "";
+}
+function omittedText(o) {
+  return Object.entries(OMITTED).filter(([key]) => typeof o[key] === "number" && o[key] > 0).map(([key, words]) => `${o[key]} ${words}`).join(", ");
+}
+var UNAVAILABLE = {
+  sold_out: "sold out",
+  no_matching_offers: "no offer matches the filters",
+  nationality_restricted: "restricted by nationality",
+  offers_unreadable: "offers unreadable",
+  not_found: "hotel not found",
+  supplier_unavailable: "offers could not be fetched this time",
+  stay_in_past: "check-in is already past"
+};
+function renderOffers(r) {
+  const lines = [
+    `Live offers \xB7 ${stayLine(r.stay.checkIn, r.stay.checkOut)} \xB7 ${party(r.stay.rooms)}`,
+    "total = the whole stay and every room, the amount charged. Fees not in the total are in the property's currency, not converted. Times are UTC, then the hotel's time zone."
+  ];
+  if (r.hotels.length === 0) lines.push("", "No hotel has offers for this stay.");
+  for (const h of r.hotels) {
+    lines.push("", `${named(h.hotel.name, h.hotel.names)} \xB7 ${h.hotel.hotelId} \xB7 ${plural(h.offers.length, "offer")}`);
+    h.offers.forEach((o, i) => lines.push(`${i + 1}. ${offerLine(o)}`));
+    const omitted2 = omittedText(h.omitted);
+    if (omitted2) lines.push(`Not shown: ${omitted2}.`);
+    const limited = limitText(h.omitted);
+    if (limited) lines.push(`${limited}.`);
+  }
+  if (r.unavailable.length > 0) {
+    lines.push("", "Unavailable:");
+    for (const u of r.unavailable) {
+      const omitted2 = u.omitted ? [omittedText(u.omitted), limitText(u.omitted)].filter(Boolean).join("; ") : "";
+      lines.push(`- ${u.hotelId}: ${label(UNAVAILABLE, u.reason)}${omitted2 ? ` (${omitted2})` : ""}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/render/order.ts
+var ORDER_STATUS_WORDS = {
+  awaiting_payment: "awaiting payment",
+  expired: "expired (not paid in time)",
+  confirming: "confirming with the hotel",
+  confirmed: "confirmed",
+  failed: "failed",
+  cancelling: "cancelling",
+  cancelled: "cancelled",
+  needs_attention: "needs attention from Fortrip"
+};
+var PAYMENT_WORDS = {
+  unpaid: "unpaid",
+  authorized: "authorized (held, not yet charged)",
+  paid: "paid",
+  released: "released (the hold was let go)",
+  refund_pending: "refund pending",
+  refunded: "refunded"
+};
+function itemLines(item) {
+  if (item.type !== "hotel") {
+    return [`Item of type ${item.type}: not shown in this text. ${raw(item)}`];
+  }
+  const h = item.hotel;
+  return [
+    [
+      `Hotel: ${named(h.name, h.names)}`,
+      h.hotelId ?? "not in the hotel catalogue",
+      stayLine(h.checkIn, h.checkOut),
+      party(h.rooms),
+      `time zone ${h.timeZone ?? "not listed"}`
+    ].join(" \xB7 "),
+    `Room: ${h.room.name ? h.room.name.text : "room name not listed"} \xB7 ${h.room.beds ? `beds: ${h.room.beds.text}` : "beds not listed"}`,
+    `Terms: ${mealsWithLabel(h.meals)} \xB7 ${cancellationText(h.cancellation)} \xB7 ${feesText(h.payAtProperty)}`,
+    `Hotel confirmation number: ${h.confirmationNumber ?? "none yet"}`
+  ];
+}
+function paymentLines(o) {
+  const p = o.payment;
+  const lines = [
+    [
+      `Total: ${money2(o.price.total)}`,
+      `payment ${label(PAYMENT_WORDS, p.status)}`,
+      `charged in ${p.chargeCurrency}${p.localCurrencyAtCheckout ? " (the user's card may pay in its local currency at checkout)" : ""}`,
+      p.localCharge ? `card charged ${money2(p.localCharge)}` : ""
+    ].filter(Boolean).join(" \xB7 ")
+  ];
+  if (p.url !== null) {
+    const about = [
+      p.expiresAt === null ? "" : `expires ${when(p.expiresAt, null)}`,
+      p.requiresSignIn ? "the user signs in to Fortrip to pay" : "no sign-in needed"
+    ].filter(Boolean);
+    lines.push(`Payment link (${about.join("; ")}): ${p.url}`);
+  } else if (o.status === "awaiting_payment") {
+    lines.push("Payment link: could not be read this time; read this order again for it.");
+  }
+  lines.push(`Manage: ${o.manageUrl}`);
+  return lines;
+}
+function orderLines(o) {
+  return [
+    `Order ${o.orderId} \xB7 reference ${o.reference} \xB7 ${label(ORDER_STATUS_WORDS, o.status)} \xB7 created ${when(o.createdAt, null)} \xB7 updated ${when(o.updatedAt, null)}`,
+    ...o.items.flatMap(itemLines),
+    ...paymentLines(o)
+  ];
+}
+function renderOrder(o) {
+  return orderLines(o).join("\n");
+}
+function renderOrderList(list) {
+  const lines = [
+    list.data.length === 0 ? "No orders on this page." : `Orders, newest first: ${list.data.length} on this page.`
+  ];
+  for (const o of list.data) lines.push("", ...orderLines(o));
+  lines.push(
+    "",
+    list.nextCursor === null ? "Last page." : `Next page: call again with { cursor: "${list.nextCursor}" }.`
+  );
+  return lines.join("\n");
+}
+
+// src/render/search.ts
+var SORTS = {
+  distance: "nearest first",
+  relevance: "best text match first",
+  stars_desc: "most stars first",
+  price_asc: "cheapest first",
+  price_desc: "dearest first"
+};
+var CENTER_BASES2 = {
+  seat: "the seat",
+  capital: "the capital",
+  busiest_settlement: "the settlement with the most hotels",
+  hub: "the locality's hub",
+  point: "its location"
+};
+function radiusWords(meters, source) {
+  return `within ${km(meters)}${source === "default" ? ", the default radius" : ""}`;
+}
+function placeHeader(d, matched) {
+  const p = d.place;
+  const scope = d.scope === "locality" ? "locality" : d.scope === "area" ? d.radiusMeters === null ? p.kind : `${p.kind}, within ${km(d.radiusMeters)} of its center` : d.scope === "radius" ? d.radiusMeters === null ? `${p.kind}, radius not stated` : `${p.kind}, ${radiusWords(d.radiusMeters, d.radiusSource)}` : `${p.kind}, scope ${d.scope}`;
+  const where = [p.region && `${p.region.name} ${p.region.placeId}`, p.countryCode].filter(Boolean).join(", ");
+  const other = [p.names.en, p.names.zh].find((n) => n && n !== p.name);
+  return [
+    `${p.name} (${scope})`,
+    plural(matched, "hotel"),
+    p.placeId,
+    where,
+    other ? `also named ${other}` : ""
+  ].filter(Boolean).join(" \xB7 ");
+}
+function header(r) {
+  const d = r.destination;
+  const matched = r.coverage.matched;
+  let head;
+  if (d === null) {
+    head = `${r.text ? `Text "${r.text.value}"` : "All hotels"} \xB7 ${plural(matched, "hotel")}`;
+  } else if (d.kind === "place") {
+    head = placeHeader(d, matched);
+  } else if (d.kind === "point") {
+    const p = d;
+    const { lat, lng } = p.center.location;
+    head = `Point ${lat}, ${lng} (${radiusWords(p.radiusMeters, p.radiusSource)}) \xB7 ${plural(matched, "hotel")}`;
+  } else {
+    head = `Destination of kind ${d.kind} \xB7 ${plural(matched, "hotel")}`;
+  }
+  if (d !== null && r.text) head += ` \xB7 text "${r.text.value}" (exact words)`;
+  return head;
+}
+function centerLine(d) {
+  if (d === null || d.kind !== "place" && d.kind !== "point") return null;
+  const c = d.center;
+  const from = c.place ? `${c.place.name} ${c.place.placeId}` : `${c.location.lat}, ${c.location.lng}`;
+  return `Distances from ${from} (${label(CENTER_BASES2, c.basis)}).`;
+}
+function pricingWords(r) {
+  const { mode, scope, status } = r.pricing;
+  if (mode === "none") return "no prices (no stay given)";
+  if (mode === "indicative" && status === "unavailable") {
+    return "indicative prices unavailable this time";
+  }
+  if (mode === "indicative") {
+    return "indicative prices per room-night: estimates, not bookable (only offers are)";
+  }
+  return `prices ${[mode, scope, status].filter(Boolean).join(", ")}`;
+}
+function countsLine(r) {
+  const c = r.coverage;
+  const country = r.destination?.kind === "place" ? r.destination.place.countryCode : "the country";
+  const parts = [`${num(c.matched)} matched`];
+  if (c.priced !== null) parts.push(`${num(c.priced)} priced`);
+  if (c.withPrice !== null) parts.push(`${num(c.withPrice)} with a price`);
+  else if (r.pricing.mode === "indicative") parts.push("with a price: unknown");
+  if (c.excludedNoPrice !== null) {
+    parts.push(`${num(c.excludedNoPrice)} left out for having no indicative price`);
+  }
+  if (c.excludedNoFacilityData !== null) {
+    parts.push(`${num(c.excludedNoFacilityData)} left out for listing no facilities`);
+  }
+  if (c.withinMaxRadius !== null) parts.push(`${num(c.withinMaxRadius)} within 80 km`);
+  if (c.textAnywhere !== null) {
+    parts.push(`${num(c.textAnywhere)} match the text anywhere in ${country}`);
+  }
+  if (c.nameAsText !== null) parts.push(`${num(c.nameAsText)} have the name as text`);
+  return `Counts: ${parts.join(", ")}.`;
+}
+function localitiesLines(loc, areaName) {
+  const lines = [
+    'Localities: pass one back as destination { kind: "locality", placeId }, never the name. The number is its matching hotels; "incl." lists places inside it, with all their hotels regardless of filters ("hotels overall").'
+  ];
+  for (const item of loc.items) {
+    let line = `- ${item.place.name} ${item.place.placeId} ${num(item.count)}`;
+    if (item.total !== item.count) line += ` here, ${num(item.total)} as a locality`;
+    const sameName = areaName !== null && [item.place.name, item.place.names.en, item.place.names.zh].some(
+      (n) => n?.toLowerCase() === areaName.toLowerCase()
+    );
+    if (sameName) line += ` \u2014 the locality, not the whole of ${areaName}`;
+    if (item.includes.length > 0) {
+      const inc = item.includes.map(
+        (i) => `${i.place.name} ${i.place.placeId}, ${num(i.members)} hotels overall`
+      );
+      line += ` (incl. ${inc.join("; ")})`;
+    }
+    lines.push(line);
+  }
+  if (loc.unassigned > 0) {
+    lines.push(`${plural(loc.unassigned, "hotel")} in this search belong to no locality.`);
+  }
+  if (loc.more > 0) {
+    lines.push(`${num(loc.more)} more localities; name one with place_name.`);
+  }
+  return lines;
+}
+function priceWords(h, status) {
+  const p = h.price;
+  if (p === null) {
+    return status === "ok" ? "no indicative price" : "price unavailable this time";
+  }
+  let text2 = `from ${money2(p.fromPerRoomNight)}/room-night (${money2(p.fromPerRoomStay)} per room for the stay)`;
+  if (p.approx) {
+    text2 += ` \u2248 ${money2(p.approx.fromPerRoomNight)}/room-night (${money2(p.approx.fromPerRoomStay)}), exchange rate of ${p.approx.rateDate}`;
+  }
+  if (p.kind !== "indicative" || p.basis !== "lowest_unit") {
+    text2 += ` [${p.kind}, ${p.basis}]`;
+  }
+  return text2;
+}
+function hotelLine(h, i, r) {
+  const where = [h.address.region?.name, h.address.countryCode].filter(Boolean).join(", ");
+  return [
+    `${i + 1}. ${named(h.name, h.names)}`,
+    h.stars === null ? "stars not listed" : `${h.stars}\u2605`,
+    r.destination === null ? "" : h.distanceMeters === null ? "distance unknown" : km(h.distanceMeters),
+    r.pricing.mode === "none" ? "" : priceWords(h, r.pricing.status),
+    h.address.line ? h.address.line.text : "address not listed",
+    where,
+    h.hotelId
+  ].filter(Boolean).join(" \xB7 ");
+}
+function renderSearch(r) {
+  const lines = [header(r)];
+  lines.push(
+    [
+      r.stay ? `Stay ${stayLine(r.stay.checkIn, r.stay.checkOut)}, ${party(r.stay.rooms)}` : "No stay",
+      pricingWords(r),
+      `sort: ${label(SORTS, r.sort)}`
+    ].join(" \xB7 ")
+  );
+  const center2 = centerLine(r.destination);
+  if (center2) lines.push(center2);
+  lines.push(countsLine(r));
+  const pool = r.coverage.poolRadiusMeters;
+  if (pool !== null) {
+    const d = r.destination;
+    const known = d !== null && (d.kind === "place" || d.kind === "point") ? d : null;
+    const around = known?.center.place?.name ?? (known?.kind === "place" ? known.place.name : "the center");
+    const priced = r.coverage.priced === null ? "" : ` ${num(r.coverage.priced)}`;
+    lines.push(
+      `Only the nearest${priced} matches were priced: "cheapest" here means cheapest within ${km(pool)} of ${around}.`
+    );
+  }
+  if (r.coverage.localities) {
+    const areaName = r.destination?.kind === "place" ? r.destination.place.name : null;
+    lines.push("", ...localitiesLines(r.coverage.localities, areaName));
+  }
+  lines.push("");
+  if (r.data.length === 0) lines.push("No hotels on this page.");
+  r.data.forEach((h, i) => lines.push(hotelLine(h, i, r)));
+  if (r.notes.length > 0) {
+    lines.push("", "Notes:", ...r.notes.map((n) => `- ${n.code}: ${n.message}`));
+  }
+  lines.push(
+    "",
+    r.nextCursor === null ? "Last page." : `Next page: call again with only the cursor and, optionally, limit: { cursor: "${r.nextCursor}" }.`
+  );
+  return lines.join("\n");
+}
+
+// src/render/errors.ts
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function changeLine(c) {
+  const worse = c.worse === true ? " (worse)" : c.worse === false ? " (not worse)" : "";
+  const pair = (show) => `${show(c.previous)} \u2192 ${show(c.current)}`;
+  switch (c.field) {
+    case "price":
+      return `- price: ${pair(money2)}${worse}`;
+    case "meals":
+      return `- meals: ${pair(mealsText)}${worse}`;
+    case "cancellation":
+      return `- cancellation: ${pair(cancellationText)}${worse}`;
+    case "confirmation":
+      return `- confirmation: ${pair(confirmationText)}${worse}`;
+    case "pay_at_property":
+      return `- fees not in the total: ${pair(feesText)}${worse}`;
+    default:
+      return `- ${c.field}: ${raw(c.previous)} \u2192 ${raw(c.current)}${worse}`;
+  }
+}
+function tooBroad(d) {
+  const lines = [
+    'Next: show the user these localities and ask which they prefer, unless their request already names one of them; then search again with destination { kind: "locality", placeId: "<id>" } and the same text, filters, stay and sort.',
+    ...localitiesLines(d.localities, null)
+  ];
+  const top = d.localities.items[0];
+  if (top && top.total > d.poolLimit && d.center?.place?.placeId === top.place.placeId) {
+    lines.push(
+      `Or: ${top.place.name}, the area's center, alone has ${num(top.total)} matching hotels: the same destination with radiusMeters (up to ${LIMITS.radiusMetersMax}) prices nearly the same hotels (the nearest ${num(d.poolLimit)} around ${top.place.name}).`
+    );
+  }
+  return lines;
+}
+function ambiguous(d) {
+  const shown = d.candidatesTotal > d.candidates.length ? `${d.candidates.length} of ${d.candidatesTotal} shown` : `${d.candidatesTotal}`;
+  const lines = [
+    `Places named "${d.name}" in ${d.countryCode} (${shown}). Ask the user which one, then search with destination { kind: "place", placeId: "<id>" }:`
+  ];
+  for (const c of d.candidates) {
+    const other = [c.names.en, c.names.zh].find((n) => n && n !== c.name);
+    const where = [c.region && `${c.region.name} ${c.region.placeId}`, c.countryCode].filter(Boolean).join(", ");
+    const hotels = c.hotels.scope === "area" ? `${plural(c.hotels.count, "hotel")} in the area` : c.hotels.radiusMeters === null ? plural(c.hotels.count, "hotel") : `${plural(c.hotels.count, "hotel")} within ${km(c.hotels.radiusMeters)}`;
+    lines.push(
+      [
+        `- ${c.name}${other ? ` (${other})` : ""} ${c.placeId}`,
+        `${c.kind} in ${where}`,
+        c.population === null ? "population not recorded" : `population ${num(c.population)}`,
+        hotels
+      ].join(" \xB7 ")
+    );
+  }
+  if (d.nameAsText !== null) {
+    lines.push(`${plural(d.nameAsText, "hotel")} have "${d.name}" in their name or address: it can also be searched as text.`);
+  }
+  return lines;
+}
+function notFound(d) {
+  switch (d.reason) {
+    case "no_match": {
+      const m = d;
+      const text2 = m.nameAsText === null ? "" : ` ${plural(m.nameAsText, "hotel")} have "${m.name}" in their name or address: it can be searched as text.`;
+      return [`No place named "${m.name}" in ${m.countryCode}.${text2}`];
+    }
+    case "unknown_id":
+      return [`Unknown placeId ${d.placeId}.`];
+    case "not_a_locality": {
+      const n = d;
+      const town = `{ kind: "place", placeId: "${n.placeId}" }`;
+      if (n.hub === null) {
+        return [`${n.placeId} belongs to no locality: search ${town} for an 8 km circle around it.`];
+      }
+      const total = n.hubTotal === null ? "" : ` (${plural(n.hubTotal, "matching hotel")})`;
+      return [
+        `${n.placeId} is not a locality. Its hotels belong to the locality ${n.hub.name} ${n.hub.placeId}${total}.`,
+        `Search { kind: "locality", placeId: "${n.hub.placeId}" } for those, or ${town} for an 8 km circle around the town itself.`
+      ];
+    }
+    default:
+      return [`Details: ${raw(d)}`];
+  }
+}
+function detailLines(e) {
+  if (!("details" in e) || e.details === void 0) return [];
+  switch (e.code) {
+    case "invalid_request": {
+      const d = e.details;
+      const lines = d.issues.map((i) => `- ${i.pointer}: ${i.message}`);
+      if (d.filterable) lines.push(`Filterable amenities: ${d.filterable.join(", ")}.`);
+      if (d.share) {
+        lines.push(
+          `${d.share.code} is listed by ${(d.share.listedShare * 100).toFixed(1)} % of hotels that list any facility.`
+        );
+      }
+      return lines;
+    }
+    case "cursor_invalid":
+      return [`The cursor is ${e.details.reason}: search again without a cursor.`];
+    case "order_removed":
+      return [`Order ${e.details.orderId}, reference ${e.details.reference}.`];
+    case "offer_expired":
+      return [`Offer ${e.details.offerId} expired at ${when(e.details.expiredAt, null)}: get fresh offers.`];
+    case "offer_changed":
+      return [
+        "Changes:",
+        ...e.details.changes.map(changeLine),
+        "New offer, held for ordering:",
+        offerLine(e.details.offer),
+        "Show the user these changes and ask again before ordering the new offer."
+      ];
+    case "offer_already_ordered":
+    case "order_in_progress":
+    case "order_attempts_exhausted":
+      return [`Order ${e.details.orderId}.`];
+    case "order_exists":
+      return [`Order ${e.details.orderId}, ${label(ORDER_STATUS_WORDS, e.details.status)}.`];
+    case "destination_ambiguous":
+      return ambiguous(e.details);
+    case "destination_not_found":
+      return notFound(e.details);
+    case "search_too_broad":
+      return tooBroad(e.details);
+    case "stay_unsupported":
+      return e.details.reason === "mixed_occupancy" ? ["Every room must have the same party: ask once per party."] : e.details.reason === "max_nights" ? [`At most ${plural(e.details.max, "night")} per stay.`] : [`Details: ${raw(e.details)}`];
+    case "stay_in_past":
+      return [`Check-in ${e.details.checkIn} is already past${e.details.timeZone ? ` in ${e.details.timeZone}` : ""}.`];
+    case "offer_unavailable":
+      return [
+        `Offer ${e.details.offerId}: ${label({ sold_out: "sold out", refused: "can no longer be booked" }, e.details.reason)}. Get fresh offers.`
+      ];
+    case "rate_limited":
+      return [`Limit reached for: ${e.details.scope}.`];
+    case "supplier_unavailable":
+      return [
+        label(
+          {
+            not_started: "Nothing was sent to the hotel's supplier.",
+            unknown: "The request was sent and timed out: its outcome is unknown."
+          },
+          e.details.outcome
+        )
+      ];
+    default:
+      return [`Details: ${raw(e.details)}`];
+  }
+}
+function retryLine(retryable, after) {
+  if (retryable === true) {
+    return typeof after === "number" ? `Retryable: retry after ${after} s.` : "Retryable.";
+  }
+  return retryable === false ? "Not retryable." : "Retryable: unknown.";
+}
+function renderError(envelope, status) {
+  const http = status === void 0 ? "" : ` (HTTP ${status})`;
+  let known = null;
+  let body = null;
+  try {
+    const parsed = parseOpen(errorEnvelope, envelope).error;
+    body = parsed;
+    if (Object.hasOwn(ERROR_CODES, parsed.code)) known = parsed;
+  } catch {
+    if (isObject(envelope) && isObject(envelope.error)) body = envelope.error;
+  }
+  if (body === null) {
+    return `Error${http}: the answer carried no readable error.
+Retryable: unknown.`;
+  }
+  const code = typeof body.code === "string" ? body.code : "unknown";
+  const lines = [
+    `Error ${code}${http}${typeof body.message === "string" ? `: ${body.message}` : ""}`,
+    retryLine(body.retryable, body.retryAfterSeconds)
+  ];
+  if (typeof body.param === "string") lines.push(`Field: ${body.param}`);
+  if (known) lines.push(...detailLines(known));
+  else if (body.details !== void 0) lines.push(`Details: ${raw(body.details)}`);
+  if (typeof body.requestId === "string") lines.push(`Request id: ${body.requestId}`);
+  return lines.join("\n");
+}
+
+// src/render/index.ts
+function renderToolResult(tool, data) {
+  const schema = TOOLS.find((t) => t.name === tool)?.output;
+  let parsed;
+  try {
+    if (!schema) throw new Error(`no output schema for ${tool}`);
+    parsed = parseOpen(schema, data);
+  } catch {
+    const text2 = `This ${tool} result is not in the expected shape; as JSON:
+${raw(data)}`;
+    return ORDER_TOOLS.has(tool) && holdsPaymentUrl(data) ? `${text2}
+
+${ORDER_NEXT_STEP}` : text2;
+  }
+  switch (tool) {
+    case "search_hotels":
+      return renderSearch(parsed);
+    case "get_hotel":
+      return renderHotel(parsed);
+    case "get_hotel_offers":
+      return renderOffers(parsed);
+    case "book_hotel":
+    case "get_order": {
+      const order2 = parsed;
+      return withConsent(renderOrder(order2), [order2]);
+    }
+    case "list_orders": {
+      const list = parsed;
+      return withConsent(renderOrderList(list), list.data);
+    }
+  }
+}
+var ORDER_TOOLS = /* @__PURE__ */ new Set(["book_hotel", "get_order", "list_orders"]);
+function holdsPaymentUrl(value, seen = /* @__PURE__ */ new Set()) {
+  if (typeof value !== "object" || value === null || seen.has(value)) return false;
+  seen.add(value);
+  const payment = value.payment;
+  if (typeof payment === "object" && payment !== null && typeof payment.url === "string" && payment.url !== "") {
+    return true;
+  }
+  return Object.values(value).some((v) => holdsPaymentUrl(v, seen));
+}
+function withConsent(text2, orders) {
+  return orders.some((o) => o.payment.url !== null) ? `${text2}
+
+${ORDER_NEXT_STEP}` : text2;
+}
+
+// src/conventions/unknown-is-not-no.ts
+var RESULT_LIST = "A result list: the API built it, so an empty list means none, not unknown";
+var REQUEST_ECHO = "An echo of the request: it says what the caller sent";
+var API_DECIDES = "A flag the API itself decides, so it is never unknown";
+var THE_FLAG = "The flag that says whether the source stated its siblings";
+var UNKNOWN_IS_NOT_NO_EXEMPTIONS = {
+  data: `${RESULT_LIST} (a page of hotels or orders).`,
+  notes: `${RESULT_LIST} (the notes the search added).`,
+  offers: `${RESULT_LIST} (the offers left after selection).`,
+  items: `${RESULT_LIST} (an order's items, a listed set's entries).`,
+  issues: `${RESULT_LIST} (what was wrong with the request).`,
+  changes: `${RESULT_LIST} (every change between the offer and the verify).`,
+  hotels: `${RESULT_LIST} (the hotels that have offers).`,
+  unavailable: `${RESULT_LIST} (the hotels without offers, each with a reason).`,
+  candidates: `${RESULT_LIST} (the places a name could mean).`,
+  "localities.items": `${RESULT_LIST} (the top locality hubs of the scope).`,
+  "localities.items.includes": `${RESULT_LIST} (other places among a hub's members).`,
+  filterable: `${RESULT_LIST} (the amenity codes a search can filter by).`,
+  rooms: `${REQUEST_ECHO} (the rooms of the stay).`,
+  childrenAges: `${REQUEST_ECHO} (each child's age; empty means no children).`,
+  retryable: `${API_DECIDES} (whether retrying can help).`,
+  mandatory: `${API_DECIDES} (whether a fee is charged whatever the guest chooses).`,
+  worse: `${API_DECIDES} (whether a change is worse for the guest).`,
+  requiresSignIn: `${API_DECIDES} (whether the payment link needs a website sign-in).`,
+  localCurrencyAtCheckout: `${API_DECIDES} (whether checkout may charge in the card's currency).`,
+  bookable: `${API_DECIDES} (whether the hotel is still in the index).`,
+  cityLike: `${API_DECIDES} (frozen per gazetteer release; null where not computed).`,
+  known: `${THE_FLAG} (meals).`,
+  listed: `${THE_FLAG} (policies, amenities, rooms).`
+};
+
 // package.json
 var package_default = {
   name: "@fortrip/agent-contract",
-  version: "2.0.0",
+  version: "3.0.0",
   license: "Apache-2.0",
-  description: "The contract of Fortrip's agent API (/api/agent/v1): limits, paths, input schemas and field rules.",
+  description: "The contract of Fortrip's agent API (https://api.fortrip.ai/v1) and its MCP server: limits, paths, request and response schemas, error codes and field rules.",
   type: "module",
   repository: {
     type: "git",
@@ -1038,47 +2721,104 @@ var package_default = {
 // src/version.ts
 var CONTRACT_VERSION = package_default.version;
 export {
+  AMENITY_CODES,
   API,
-  BOARD_CODES,
-  BOOKING_NEXT_STEP,
   CARD_NUMBER_MESSAGE,
+  CENTER_BASES,
   COMMANDS,
   COMMAND_GROUPS,
   CONTRACT_VERSION,
-  CURRENCIES,
-  ERROR_REASONS,
+  DISPLAY_CURRENCIES,
+  ERROR_CODES,
+  ERROR_DETAILS,
+  FILTERABLE_AMENITIES,
   GLOBAL_FLAGS,
   GUEST_NAME_MESSAGE,
   GUEST_NAME_PATTERN,
   GUEST_NAME_TITLE,
   LIMITS,
-  MCP_BOOKING_RESULT,
-  MCP_RATES_INPUT,
+  MCP_OUTPUT,
+  MCP_PATH,
+  ORDER_NEXT_STEP,
+  ORDER_STATUSES,
+  PAYMENT_STATUSES,
+  PLACE_KINDS,
+  POLICY_TOPICS,
+  PUBLIC_ORIGINS,
+  SEARCH_NOTE_CODES,
   SEARCH_SORTS,
   SUPPORT_EMAIL,
   TOOLS,
+  UNAVAILABLE_REASONS,
+  UNKNOWN_IS_NOT_NO_EXEMPTIONS,
   addIsoDateDays,
   authConfig,
-  bookingResult,
-  childrenAges,
+  cancellation,
+  center,
   commandInvocation,
+  confirmation,
   containsCardNumber,
   countIsoDateDays,
-  createBookingInput,
+  createOrderInput,
+  createSearchHotelsInput,
+  destination,
+  errorEnvelope,
   flag,
+  formatMoney,
   getHotelInput,
-  getRatesInput,
+  getOrderInput,
   guestNameRe,
+  hotel,
+  hotelId,
+  hotelOffersInput,
+  hotelOffersResult,
+  hotelSummary,
+  indicativePrice,
+  instant,
   isIsoDate,
-  isoDate,
+  knownLocaleText,
+  latLng,
+  listOrdersInput,
+  localDate,
+  localTime,
+  localities,
+  localizedText,
   meResult,
+  meals,
+  money,
+  names,
   nonEmpty,
   normalizeGuestName,
+  offer,
+  offerChange,
+  offerId,
+  omitted,
   oneOf,
-  positiveId,
+  openEnum,
+  openObject,
+  openUnion,
+  order,
+  orderId,
+  orderList,
+  orderReference,
+  parseOpen,
+  payAtProperty,
+  place,
+  placeId,
+  placeRef,
+  renderError,
   renderGuide,
+  renderToolResult,
+  roomFacts,
   searchHotelsInput,
+  searchResult,
+  stay,
+  stayEcho,
+  strictErrorEnvelope,
   strictInput,
+  strictOutput,
   text,
+  timeZone,
+  usdMoney,
   wholeNumber
 };