fortrip 0.3.1 → 2.0.0

package/dist/mcp-bridge-LPQBHWLD.js

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+import {
+  API,
+  CONTRACT_VERSION,
+  CliError,
+  EXIT,
+  TOOLS,
+  loadSession,
+  refreshSession,
+  renderGuide,
+  requireToken
+} from "./chunk-53656LB2.js";
+
+// src/mcp-bridge.ts
+import {
+  isJSONRPCErrorResponse,
+  isJSONRPCRequest,
+  isJSONRPCResultResponse,
+  SdkHttpError,
+  StreamableHTTPClientTransport
+} from "@modelcontextprotocol/client";
+import {
+  InMemoryTransport,
+  McpServer
+} from "@modelcontextprotocol/server";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+var SIGN_IN_REQUIRED = -32001;
+var INTERNAL_ERROR = -32603;
+var LOGIN_COMMAND = "npx -y fortrip login";
+var SignInRequired = class extends Error {
+  constructor(message, data = {}) {
+    super(message);
+    this.data = data;
+  }
+  data;
+};
+var signInAdvice = (link = "") => `Run \`${LOGIN_COMMAND}\` in a terminal${link}, then try again.`;
+async function signedIn(run) {
+  try {
+    return await run();
+  } catch (error) {
+    if (error instanceof CliError && error.exitCode === EXIT.unauthenticated) {
+      if (error.details.tokenSource === "FORTRIP_TOKEN") throw new SignInRequired(error.message);
+      const { loginUrl, userCode, expiresInSeconds } = error.details;
+      throw new SignInRequired(
+        `Not signed in to Fortrip, or the saved sign-in no longer works. ${signInAdvice(
+          loginUrl ? `, or open ${loginUrl} and approve` : ""
+        )}`,
+        { loginUrl, userCode, expiresInSeconds }
+      );
+    }
+    throw error;
+  }
+}
+function authorizedFetch(apiUrl) {
+  const attempt = async (url, init) => {
+    try {
+      return await fetch(url, init);
+    } catch (error) {
+      if (error?.name === "AbortError") throw error;
+      const cause = error?.cause ?? error;
+      throw new Error(`Could not reach ${apiUrl}: ${cause?.message ?? String(error)}`);
+    }
+  };
+  let turn = Promise.resolve();
+  return async (url, init) => {
+    const withToken = (token2) => {
+      const headers = new Headers(init?.headers);
+      headers.set("authorization", `Bearer ${token2}`);
+      return attempt(url, { ...init, headers });
+    };
+    const started = turn.then(async () => {
+      const { token: token2, source: source2 } = await signedIn(() => requireToken(apiUrl));
+      return { token: token2, source: source2, response: withToken(token2) };
+    });
+    turn = started.catch(() => {
+    });
+    const { token, source, response } = await started;
+    const first = await response;
+    if (first.status !== 401) return first;
+    await first.body?.cancel().catch(() => {
+    });
+    if (source === "env") {
+      throw new SignInRequired(
+        `Fortrip didn't accept FORTRIP_TOKEN. Replace it, or unset it and run \`${LOGIN_COMMAND}\`, then try again.`
+      );
+    }
+    const second = await withToken(await signedIn(() => refreshSession(apiUrl, token)));
+    if (second.status !== 401) return second;
+    await second.body?.cancel().catch(() => {
+    });
+    throw new SignInRequired(`Fortrip didn't accept the refreshed sign-in. ${signInAdvice()}`);
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rpcErrorOf(error) {
+  if (error instanceof SignInRequired) {
+    return { code: SIGN_IN_REQUIRED, message: error.message, data: error.data };
+  }
+  if (error instanceof SdkHttpError) {
+    const { status } = error;
+    const text = typeof error.data.text === "string" ? error.data.text : "";
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+    }
+    if (isRecord(body) && isRecord(body.error)) {
+      const { code, message } = body.error;
+      if (typeof code === "number" && typeof message === "string") return body.error;
+    }
+    const said = isRecord(body) ? body.error ?? body.message : text.slice(0, 200);
+    return {
+      code: INTERNAL_ERROR,
+      message: `Fortrip answered HTTP ${status}${typeof said === "string" && said ? `: ${said}` : ""}`,
+      data: { status, ...status >= 500 || status === 429 ? { retryable: true } : {} }
+    };
+  }
+  return {
+    code: INTERNAL_ERROR,
+    message: error instanceof Error ? error.message : String(error),
+    ...error instanceof CliError && error.details.retryable ? { data: { retryable: true } } : {}
+  };
+}
+var CONNECTION_LOST = {
+  code: INTERNAL_ERROR,
+  message: "The connection to Fortrip ended before it answered.",
+  data: { retryable: true }
+};
+var SWITCH_TIMEOUT_MS = 6e4;
+async function hasSignIn(apiUrl) {
+  if (process.env.FORTRIP_TOKEN?.trim()) return true;
+  return await loadSession(apiUrl).catch(() => null) !== null;
+}
+function localServer() {
+  const server = new McpServer(
+    { name: "fortrip", version: CONTRACT_VERSION },
+    { instructions: renderGuide("mcp", "main") }
+  );
+  const handler = () => {
+    throw new Error("Fortrip's tools run on the hosted server.");
+  };
+  for (const spec of TOOLS) {
+    const config = {
+      title: spec.title,
+      description: spec.description,
+      annotations: spec.annotations,
+      outputSchema: spec.output ?? void 0
+    };
+    if (spec.input === null) {
+      server.registerTool(spec.name, config, handler);
+    } else {
+      server.registerTool(
+        spec.name,
+        { ...config, inputSchema: spec.input },
+        handler
+      );
+    }
+  }
+  return server;
+}
+async function runMcpBridge(apiUrl, io = {
+  stdin: process.stdin,
+  stdout: process.stdout
+}, { switchTimeoutMs = SWITCH_TIMEOUT_MS } = {}) {
+  const stderr = io.stderr ?? process.stderr;
+  const stdio = new StdioServerTransport(io.stdin, io.stdout);
+  const http = new StreamableHTTPClientTransport(new URL(API.mcp, apiUrl), {
+    fetch: authorizedFetch(apiUrl)
+  });
+  const server = localServer();
+  const [local, localServerEnd] = InMemoryTransport.createLinkedPair();
+  const signInSaved = await hasSignIn(apiUrl);
+  let closed = false;
+  let remote = false;
+  let clientInitialize;
+  let listChanged = false;
+  let received = 0;
+  let abandonedThrough = 0;
+  const pending = /* @__PURE__ */ new Set();
+  let initializeId;
+  const asked = /* @__PURE__ */ new Map();
+  const log = (message) => {
+    if (!closed) stderr.write(`fortrip mcp: ${message}
+`);
+  };
+  const toClient = (message) => {
+    stdio.send(message).catch((cause) => log(cause.message));
+  };
+  const fail = (id, error) => {
+    if (closed || !pending.delete(id)) return;
+    toClient({ jsonrpc: "2.0", id, error });
+  };
+  const adopt = ({ result }) => {
+    if (typeof result.protocolVersion === "string") http.setProtocolVersion(result.protocolVersion);
+  };
+  const forward = async (message) => {
+    if (!isJSONRPCRequest(message)) {
+      await http.send(message).catch(() => {
+      });
+      return;
+    }
+    pending.add(message.id);
+    if (message.method === "initialize") initializeId = message.id;
+    try {
+      await http.send(message, { onRequestStreamEnd: () => fail(message.id, CONNECTION_LOST) });
+    } catch (error) {
+      fail(message.id, rpcErrorOf(error));
+    }
+  };
+  const ask = (request, signal) => {
+    let waiter;
+    return new Promise((resolve, reject) => {
+      waiter = resolve;
+      asked.set(request.id, resolve);
+      http.send(request, {
+        requestSignal: signal,
+        onRequestStreamEnd: () => resolve({ jsonrpc: "2.0", id: request.id, error: CONNECTION_LOST })
+      }).catch(reject);
+    }).finally(() => {
+      if (asked.get(request.id) === waiter) asked.delete(request.id);
+    });
+  };
+  const initialize = async (request) => {
+    clientInitialize = request;
+    if (signInSaved) {
+      try {
+        const answer = await ask(request);
+        if (isJSONRPCResultResponse(answer)) {
+          adopt(answer);
+          remote = true;
+        }
+        return toClient(answer);
+      } catch (error) {
+        if (!(error instanceof SignInRequired)) {
+          return toClient({ jsonrpc: "2.0", id: request.id, error: rpcErrorOf(error) });
+        }
+      }
+    }
+    await local.send(request);
+  };
+  const handshake = async (initialize2) => {
+    const deadline = new AbortController();
+    const timer = setTimeout(() => deadline.abort(), switchTimeoutMs);
+    const late = new Promise(
+      (resolve) => deadline.signal.addEventListener("abort", () => resolve(void 0))
+    );
+    try {
+      let answer;
+      try {
+        answer = await Promise.race([ask(initialize2, deadline.signal), late]);
+      } catch (error) {
+        return rpcErrorOf(error);
+      }
+      if (answer && !isJSONRPCResultResponse(answer)) return answer.error;
+      if (answer) {
+        adopt(answer);
+        await http.send(
+          { jsonrpc: "2.0", method: "notifications/initialized" },
+          { requestSignal: deadline.signal }
+        ).catch(() => {
+        });
+      }
+      if (!deadline.signal.aborted) return void 0;
+      abandonedThrough = received;
+      return CONNECTION_LOST;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  const callTool = async (call) => {
+    if (clientInitialize) {
+      const error = await handshake(clientInitialize);
+      if (error) return toClient({ jsonrpc: "2.0", id: call.id, error });
+    }
+    remote = true;
+    void forward(call);
+    if (listChanged) toClient({ jsonrpc: "2.0", method: "notifications/tools/list_changed" });
+  };
+  const handle = async (message, seq) => {
+    if (closed) return;
+    if (remote) return void forward(message);
+    if (isJSONRPCRequest(message) && message.method === "initialize") return initialize(message);
+    if (isJSONRPCRequest(message) && message.method === "tools/call") {
+      if (seq <= abandonedThrough) {
+        return toClient({ jsonrpc: "2.0", id: message.id, error: CONNECTION_LOST });
+      }
+      return callTool(message);
+    }
+    await local.send(message);
+  };
+  let inbox = Promise.resolve();
+  stdio.onmessage = (message) => {
+    const seq = ++received;
+    inbox = inbox.then(() => handle(message, seq)).catch((error) => log(error.message));
+  };
+  local.onmessage = (message) => {
+    if (isJSONRPCResultResponse(message) && message.id === clientInitialize?.id) {
+      const { capabilities } = message.result;
+      listChanged = capabilities?.tools?.listChanged === true;
+    }
+    toClient(message);
+  };
+  http.onmessage = (message) => {
+    if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+      const waiting = message.id === void 0 ? void 0 : asked.get(message.id);
+      if (waiting) return waiting(message);
+      if (message.id !== void 0) pending.delete(message.id);
+      if (isJSONRPCResultResponse(message) && message.id === initializeId) adopt(message);
+    }
+    toClient(message);
+  };
+  http.onerror = (error) => log(error.message);
+  stdio.onerror = (error) => log(error.message);
+  let stopped;
+  const done = new Promise((resolve) => {
+    stopped = resolve;
+  });
+  const shutdown = async () => {
+    if (closed) return;
+    closed = true;
+    process.off("SIGINT", shutdown);
+    process.off("SIGTERM", shutdown);
+    await Promise.allSettled([http.close(), stdio.close(), server.close()]);
+    stopped();
+  };
+  stdio.onclose = shutdown;
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await http.start();
+  await server.connect(localServerEnd);
+  await stdio.start();
+  return done;
+}
+export {
+  runMcpBridge
+};

package/package.json

@@ -1,37 +1,43 @@
 {
   "name": "fortrip",
-  "version": "0.3.1",
-  "license": "MIT",
+  "version": "2.0.0",
+  "license": "Apache-2.0",
   "description": "Search, price and book Fortrip hotels from the terminal or an AI agent.",
+  "mcpName": "io.github.FortripEngineering/fortrip",
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/FortripEngineering/fortrip-cli.git"
+    "url": "git+https://github.com/FortripEngineering/fortrip.git",
+    "directory": "packages/cli"
   },
   "bin": {
     "fortrip": "dist/cli.js"
   },
   "files": [
     "dist",
-    "guides",
-    "AGENT_GUIDE.md",
-    "README.md"
+    "README.md",
+    "NOTICE",
+    "THIRD-PARTY-NOTICES"
   ],
   "engines": {
     "node": ">=22"
   },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsx src/cli.ts",
-    "typecheck": "tsc --noEmit",
-    "test": "node --import tsx --test test/*.test.ts",
-    "prepublishOnly": "pnpm typecheck && pnpm test && pnpm build"
+  "dependencies": {
+    "@modelcontextprotocol/client": "2.3.1",
+    "@modelcontextprotocol/server": "2.3.1"
   },
   "devDependencies": {
     "@types/node": "^22.15.0",
     "tsup": "^8.5.1",
     "tsx": "^4.20.0",
-    "typescript": "^5.9.0"
+    "typescript": "^5.9.0",
+    "zod": "4.4.3",
+    "@fortrip/agent-contract": "2.0.0"
   },
-  "packageManager": "pnpm@11.21.0"
-}
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx --test test/*.test.ts"
+  }
+}

package/AGENT_GUIDE.md

@@ -1,200 +0,0 @@
-# Fortrip
-
-Fortrip sells hotel rooms at supplier net prices. The
-`fortrip` CLI (npm package `fortrip`) calls the Fortrip API as the
-signed-in user and prints JSON.
-
-## When to use
-
-- The user wants hotels in a city, near a point, or by name, for given dates.
-- The user wants live rooms, meal plans, cancellation terms or prices for
-  specific hotels.
-- The user has picked a rate and wants to book it (you return a payment link;
-  the user pays in their browser).
-
-Not for flights, activities, or changing/cancelling an existing booking.
-For changes, cancellations, refunds or any other problem with a booking, the
-user emails info@fortrip.ai with the booking's `orderUrl` (never
-`paymentUrl` or `statusUrl`).
-
-For flexible dates, a budget, split stays, several destinations or "find me
-the best", also run `npx -y fortrip@latest skill planning` before searching.
-
-## Setup
-
-Run every command as `npx -y fortrip@latest <command>`, the same version that
-printed this guide. The examples below shorten that to `fortrip`;
-`fortrip <command> --help` lists a command's flags.
-
-When the user first asks about hotels, run `fortrip whoami` before asking
-follow-up questions, so a login can happen while they answer.
-
-If 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 BCDF-GHJK) and tell me when you're done." When they confirm, rerun the
-same command; it finishes the login itself. Don't run `fortrip 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.
-
-When Fortrip doesn't accept the saved sign-in (it was revoked or has
-expired, or Fortrip had a passing problem), 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, so after a passing problem the next command
-works without signing in again. Exit 3 with `tokenSource: "FORTRIP_TOKEN"` means Fortrip
-didn't accept the token the user set in `FORTRIP_TOKEN`: retry once a
-little later, and if it keeps happening, tell the user to replace or unset
-it.
-
-Sign-in happens only in the browser. In CI, the user can set `FORTRIP_TOKEN`
-instead. Never ask the user to paste a token into the chat.
-
-## Exit codes
-
-| Code | Meaning | What to do |
-|---|---|---|
-| 0 | Success; JSON on stdout | Continue |
-| 1 | Other error (supplier error, rate no longer bookable, network error or timeout) | Read `error` on stderr; if `retryable` is true (supplier unreachable or timed out, Fortrip briefly unavailable, or no response from Fortrip), wait `retryAfterSeconds` (or a few seconds) and retry once; re-run `rates` if a rate went stale. `book` errors carry a `reason` (below) |
-| 2 | Invalid arguments | Fix the flags; stderr `issues` lists each bad field with a message |
-| 3 | Not logged in | Show `loginUrl` to the user, then rerun (above) |
-| 4 | Rate limited | Wait `retryAfterSeconds`, then retry once |
-
-Output on stdout or stderr can carry `warning` (with `recoveryFile` when a
-sign-in couldn't be saved): pass it on to the user.
-
-## Recommended order
-
-1. **Search** — find candidates and indicative prices:
-
-   ```bash
-   fortrip search --query "Bangkok" --check-in 2026-11-10 --check-out 2026-11-12 \
-     --star-min 4 --sort price-asc --page-size 10
-   ```
-
-   Use `--near lat,lng,radiusKm` for "near X", `--city-code` when known.
-   Pass `--currency` (`CNY`, the default, or `USD`) to suit the user, inferred
-   from their language or location, on both `search` and `rates`;
-   `--price-min` / `--price-max` are in that currency.
-   `--facility` names must match the catalogue exactly (e.g. `Swimming pool`,
-   `Parking`), otherwise nothing matches. Prices here (`price.nightlyFrom`,
-   `totalFrom`) are **indicative floors**, not quotes — say so. A search
-   that matches too many hotels fails with `matched` and `maxMatches`: narrow
-   it (a city, an area, stars or a price range).
-
-2. **Hotel detail** (optional) — description, policies, facilities, photos:
-
-   ```bash
-   fortrip hotel 266000 [--with-rooms]
-   ```
-
-3. **Rates** — live rooms and prices for up to 15 hotels:
-
-   ```bash
-   fortrip rates --hotel 266000 --hotel 266001 --check-in 2026-11-10 \
-     --check-out 2026-11-12 --rooms 1 --adults 2 [--child-age 6] \
-     [--nationality CN] [--board BB] [--free-cancellation] [--currency USD]
-   ```
-
-   `--adults` and `--child-age` are **per room**, and every room has the same
-   occupancy: 2 rooms for 4 adults is `--rooms 2 --adults 2`. If the party
-   doesn't divide evenly (3 adults in 2 rooms), ask the user whether to price
-   every room for the larger number or book the rooms separately. Limits:
-   1–8 rooms, 1–8 adults and 0–8 children (aged 0–17) per room, 1–15
-   nights, up to 15 hotels per call.
-
-   This call takes about 15 seconds. Prices are in the response's `currency`,
-   converted at Stripe's exchange rate (refreshed hourly), or a fixed fallback
-   rate when Stripe is unavailable; `fx` says which, and is `null` when
-   nothing needed converting. Present each option with:
-
-   - 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) together 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), so say who is
-     covered;
-   - `freeCancelUntil` / `refundable`, `isInstantConfirm`, and any `fees`
-     (taxes paid at the hotel, in their own currency).
-
-   `--nationality` isn't sent with the booking: a rate restricted to that
-   nationality may change or be refused when booked.
-
-4. **Book** — only after the user picks one rate and gives guest details:
-
-   ```bash
-   fortrip book --hotel 266000 --room-id 9191658 --rate-plan "<ratePlanCode>" \
-     --check-in 2026-11-10 --check-out 2026-11-12 --rooms 1 --adults 2 \
-     --guest "John Smith" --contact-name "John Smith" \
-     --contact-phone "+8613800000000" [--contact-email john@example.com]
-   ```
-
-   `--hotel`, `--room-id`, `--rate-plan`, dates, `--rooms`, `--adults` and
-   `--child-age` must be exactly the values used in `rates`; `book` requires
-   `--rooms` and `--adults`. Guest names must be in Latin letters as on the
-   passport ("First Last"; last word is the last name; `"First Last:2"` puts
-   the guest in room 2; 1–60 characters each). Each room needs at least one
-   guest. The contact name takes up to 120 characters, the phone 3–40.
-   `--special-requests` must be in English and isn't guaranteed. `book`
-   accepts only these fields: a `--body` with any other field (such as
-   `nationality`) is rejected with exit 2.
-
-   One booking covers at most 15 nights; book a longer stay as separate
-   bookings. `book` checks the rate with the supplier again and can take up
-   to about 2 minutes: allow the command at least 3 minutes, and if it times
-   out, run it again with identical flags. That is always safe: it returns
-   the same order, with the same or a refreshed payment link.
-
-## Before giving the payment link
-
-`book` returns `paymentUrl`, `amount`, `currency`, `terms`, `stay`,
-`statusUrl` and `orderUrl`. Before you hand over `paymentUrl`:
-
-1. **Show what will be booked and ask the user to confirm.** From `stay`:
-   hotel (`hotelName`), room (`roomName`), dates, nights, rooms and guests per
-   room (`adultsPerRoom`, `childrenAgesPerRoom`); if `stay` is missing, use
-   the values you passed. From `terms`: meal plan (`boardCode` with
-   `boardCount`), cancellation (`refundable`, `freeCancelUntil`, the
-   `cancellation` ladder), confirmation (`isInstantConfirm`, `confirmByMins`)
-   and `payAtHotelFees`. Then the `amount` and `currency`, and end your reply
-   by asking them to confirm. If `amount` or `terms` is `null`, say it
-   couldn't be read rather than guess; the payment page shows the amount.
-2. **Explain the amount.** `rates` showed a converted figure, but the charge
-   is `amount` in `currency` (usually USD), and the Stripe page may display
-   the user's local currency at Stripe's rate. The `rates` figure used a
-   Stripe rate too, so it is usually close, but the amount on the payment page
-   is what will be charged; the `rates` figure was a reference.
-3. **Only after they confirm, 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.
-4. The link is for **this user only**: whoever has it can pay. Don't post it
-   in shared channels, logs or tickets. It expires after about 3 hours 45
-   minutes; call `book` again with the same details for a fresh one.
-
-Never ask for, accept or pass on payment card details; payment happens only
-on the payment page. A card number in a guest name, the contact name or the
-special requests is rejected with exit 2.
-
-After paying, the user lands on `statusUrl`, which shows confirmation progress
-without signing in. `orderUrl` is the signed-in order page.
-
-## Errors from `book`
-
-Act on `reason` in stderr:
-
-- `already_booked` (409, with `agentOrderId`): this exact stay is already paid
-  or completed — show `orderUrl`, don't book again.
-- `price_or_terms_changed` (409, with `changes`): show what changed, re-run
-  `rates` and confirm again with the user.
-- `rate_unavailable` (422): the rate can no longer be booked — re-run `rates`
-  and offer what is left.
-- `supplier_unavailable` (503 or 504, `retryable: true`): wait
-  `retryAfterSeconds` and retry once with identical flags. A 503 with
-  `retryable: true` and no `reason` (a passing outage) is handled the same
-  way.
-- `refused` (any other 422): the booking was refused (guest names, too many
-  attempts, bookings paused, or a preview deployment). Read `error`.
-
-Older servers send no `reason`: there a 409 with `agentOrderId` is
-`already_booked`, a 409 with `changes` is `price_or_terms_changed`, any other
-409 is `rate_unavailable`, and a 422 is `refused`.

package/guides/planning.md

@@ -1,57 +0,0 @@
-# Planning a hotel stay
-
-Read 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".
-Commands, login and the booking checklist are in `fortrip skill`; this covers
-what to ask, how to compare and how to present. As there, `fortrip` is short
-for `npx -y fortrip@latest`.
-
-## What to collect
-
-Keep 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). `--adults` and `--child-age` are per room and every
-room has the same occupancy, so 4 adults in 2 rooms is `--rooms 2 --adults 2`.
-
-Ask only for what changes which hotels qualify or how they rank. If children
-come along, ask each child's age; `rates` and `book` need it. Don't ask for
-trip type or style: infer it from the conversation or leave it general.
-
-## Evidence
-
-- A `search` price is a floor. Never call a search result available or
-  bookable.
-- Use `hotel` only when a stated preference needs evidence (a pool, a
-  policy, room size).
-- A hotel is available only once `rates` returned a live option for it.
-- Anything the CLI didn't return, such as reviews, style, price trends or
-  exchange rates, is unknown. Say so instead of filling it in.
-
-## Ranking
-
-1. Drop options that break a hard constraint (dates, guests, budget cap,
-   required facility).
-2. Keep only options with a live rate.
-3. Order by the user's stated main goal. Goals they didn't state don't count.
-4. Use other preferences only to break ties.
-
-Use 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.
-
-For a split stay or several destinations, price each leg with its own
-`rates` call and add up the legs. Each leg is a separate `book` call and a
-separate payment link.
-
-## Stop and say so
-
-- `rates` covers up to 15 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.
-- Urgency is not consent: run `book` only for the rate the user picked, and
-  give the payment link only after the user confirms the terms that `book`
-  returned.