imprint-mcp 0.5.0 → 0.6.0

package/examples/google-flights/get_flight_booking_options/parser.ts

@@ -0,0 +1,209 @@
+import { extractWrbRecords, parseNestedPayload } from '../_shared/google_batchexecute_parser.ts';
+import type { BookingOption, FlightLeg } from '../_shared/google_flights_types.ts';
+
+type JsonArray = unknown[];
+
+type Output = {
+  selectedItinerary: {
+    legs: FlightLeg[];
+    carriers: string[];
+  };
+  bookingOptions: BookingOption[];
+  warnings?: string[];
+};
+
+function isArray(value: unknown): value is JsonArray {
+  return Array.isArray(value);
+}
+
+function asString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value : undefined;
+}
+
+function asNumber(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+function formatDate(value: unknown): string | undefined {
+  if (!isArray(value) || value.length < 3) return undefined;
+  const [year, month, day] = value.map(Number);
+  if (!year || !month || !day) return undefined;
+  return `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+}
+
+function formatTime(value: unknown): string | undefined {
+  if (!isArray(value) || value.length === 0) return undefined;
+  const hour = Number(value[0]);
+  const minute = Number(value[1] ?? 0);
+  if (!Number.isFinite(hour) || !Number.isFinite(minute)) return undefined;
+  return `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
+}
+
+function walk(value: unknown, visit: (node: JsonArray) => void): void {
+  if (!isArray(value)) return;
+  visit(value);
+  for (const child of value) walk(child, visit);
+}
+
+function looksLikeCarrierGroup(node: JsonArray): boolean {
+  return typeof node[0] === 'string' && isArray(node[1]) && isArray(node[2]) && node[2].some((segment) => isArray(segment) && typeof segment[3] === 'string' && typeof segment[6] === 'string');
+}
+
+function legFromSegment(segment: JsonArray, fallbackAirline?: string): FlightLeg | null {
+  const origin = asString(segment[3]);
+  const destination = asString(segment[6]);
+  if (!origin || !destination) return null;
+  const marketing = isArray(segment[22]) ? segment[22] : [];
+  const operating = isArray(segment[15]) && isArray(segment[15][0]) ? segment[15][0] as JsonArray : [];
+  return {
+    origin,
+    destination,
+    departureDate: formatDate(segment[20]),
+    departureTime: formatTime(segment[8]),
+    arrivalDate: formatDate(segment[21]),
+    arrivalTime: formatTime(segment[10]),
+    airline: asString(marketing[3]) ?? fallbackAirline,
+    carrierCode: asString(marketing[0]) ?? asString(operating[0]),
+    flightNumber: asString(marketing[1]) ?? asString(operating[1]),
+    durationMinutes: asNumber(segment[11]),
+  };
+}
+
+function collectLegs(payloads: unknown[]): FlightLeg[] {
+  const seen = new Set<string>();
+  const legs: FlightLeg[] = [];
+  for (const payload of payloads) {
+    walk(payload, (node) => {
+      if (!looksLikeCarrierGroup(node)) return;
+      const airline = isArray(node[1]) ? asString(node[1][0]) : undefined;
+      for (const segment of node[2] as JsonArray[]) {
+        if (!isArray(segment)) continue;
+        const leg = legFromSegment(segment, airline);
+        if (!leg) continue;
+        const key = [leg.origin, leg.destination, leg.departureDate, leg.carrierCode, leg.flightNumber].join('|');
+        if (seen.has(key)) continue;
+        seen.add(key);
+        legs.push(leg);
+      }
+    });
+  }
+  return legs;
+}
+
+function providerFromOption(option: JsonArray): string | undefined {
+  const providerGroup = isArray(option[1]) && isArray(option[1][0]) ? option[1][0] as JsonArray : undefined;
+  if (!providerGroup) return undefined;
+  return asString(providerGroup[1]) ?? asString(providerGroup[0]);
+}
+
+function codeFromProvider(option: JsonArray): string | undefined {
+  const providerGroup = isArray(option[1]) && isArray(option[1][0]) ? option[1][0] as JsonArray : undefined;
+  return providerGroup ? asString(providerGroup[0]) : undefined;
+}
+
+function priceFromOption(option: JsonArray): number | undefined {
+  const explicit = isArray(option[7]) && isArray(option[7][0]) ? asNumber((option[7][0] as JsonArray)[1]) : undefined;
+  if (explicit !== undefined) return explicit;
+  let best: number | undefined;
+  walk(option, (node) => {
+    if (node.length === 2 && node[0] === null && typeof node[1] === 'number' && node[1] > 0 && node[1] < 10000) {
+      best = best === undefined ? node[1] as number : Math.min(best, node[1] as number);
+    }
+  });
+  return best;
+}
+
+function bookingUrlFromOption(option: JsonArray): string | undefined {
+  let found: string | undefined;
+  walk(option, (node) => {
+    if (found) return;
+    if (node[0] === 'https://www.google.com/travel/clk/f') found = node[0];
+    for (const value of node) {
+      if (typeof value === 'string' && /^https?:\/\//.test(value) && !value.includes('accessible-services')) {
+        found = value;
+        return;
+      }
+    }
+  });
+  return found;
+}
+
+function collectStrings(value: unknown): string[] {
+  const strings = new Set<string>();
+  walk(value, (node) => {
+    for (const item of node) {
+      if (typeof item !== 'string') continue;
+      const text = item.trim();
+      if (!text) continue;
+      if (text.length > 80) continue;
+      if (/^https?:\/\//.test(text) || text.includes('/travel/flights')) continue;
+      if (/^[A-Za-z0-9_-]{24,}$/.test(text)) continue;
+      strings.add(text);
+    }
+  });
+  return [...strings];
+}
+
+function looksLikeBookingOption(node: JsonArray): boolean {
+  if (node[0] !== 0) return false;
+  if (!providerFromOption(node)) return false;
+  if (!isArray(node[3]) || !node[3].some((flight) => isArray(flight) && typeof flight[0] === 'string' && String(flight[1] ?? '').length > 0)) return false;
+  return isArray(node[5]) || priceFromOption(node) !== undefined;
+}
+
+function collectBookingOptions(payloads: unknown[], legs: FlightLeg[]): BookingOption[] {
+  const options: BookingOption[] = [];
+  const seen = new Set<string>();
+  for (const payload of payloads) {
+    walk(payload, (node) => {
+      if (!looksLikeBookingOption(node)) return;
+      const provider = providerFromOption(node);
+      const price = priceFromOption(node);
+      const bookingUrl = bookingUrlFromOption(node);
+      const code = codeFromProvider(node);
+      const strings = collectStrings(node);
+      const fareNotes = strings.filter((text) => {
+        if (text === provider || text === code) return false;
+        if (/^[A-Z0-9]{2,6}$/.test(text)) return false;
+        if (/^www\./.test(text)) return false;
+        return ['Basic', 'Choice', 'Choice Preferred', 'Choice Extra', 'Saver', 'Main', 'First'].includes(text) || /bag|seat|basic|main|first|choice|saver/i.test(text);
+      });
+      const optionLegs = legs.length ? legs : [];
+      if (!provider && price === undefined && !bookingUrl) return;
+      const key = `${provider ?? ''}|${price ?? ''}|${bookingUrl ?? ''}|${fareNotes.join(',')}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      options.push({
+        provider,
+        price,
+        currency: price !== undefined ? 'USD' : undefined,
+        bookingUrl,
+        fareNotes,
+        restrictions: strings.filter((text) => /restriction|refund|change|carry|bag/i.test(text) && !fareNotes.includes(text)),
+        legs: optionLegs,
+      });
+    });
+  }
+  return options;
+}
+
+function parsePayloads(rawResponse: unknown): unknown[] {
+  if (typeof rawResponse !== 'string') return [rawResponse];
+  const records = extractWrbRecords(rawResponse);
+  return records.map((record) => parseNestedPayload(record.payload)).filter(Boolean);
+}
+
+export function extract(rawResponse: unknown): Output {
+  const payloads = parsePayloads(rawResponse);
+  const legs = collectLegs(payloads);
+  const bookingOptions = collectBookingOptions(payloads, legs);
+  const carriers = [...new Set(legs.map((leg) => leg.airline ?? leg.carrierCode).filter((value): value is string => Boolean(value)))];
+  return {
+    selectedItinerary: {
+      legs,
+      carriers,
+    },
+    bookingOptions,
+    warnings: bookingOptions.length === 0 ? ['No booking options were returned for this selected itinerary.'] : undefined,
+  };
+}

package/examples/google-flights/get_flight_booking_options/playbook.yaml

@@ -0,0 +1,46 @@
+toolName: get_flight_booking_options
+summary: Get booking and fare details for a selected Google Flights itinerary.
+parameters:
+  - name: selection_token
+    type: string
+    description: Encoded flight selection token returned by search results for the chosen itinerary or leg.
+  - name: trip_type
+    type: string
+    description: Ticket type for the selected itinerary, such as one_way, round_trip, or multi_city.
+  - name: selected_flights
+    type: string
+    description: Comma-separated selected leg identifiers such as carrier, flight number, date, origin, and destination when required.
+steps:
+  - action: navigate
+    url: "https://www.google.com/travel/flights"
+    wait_for: networkidle
+  - action: click
+    locators:
+      - by: role
+        value: button
+        name: "${trip_type}"
+      - by: aria_label
+        value_pattern: "${trip_type}"
+      - by: text
+        value_pattern: "${trip_type}"
+      - by: css
+        value: "div.TQYpgc.gInvKb"
+    wait_for:
+      sleep_ms: 300
+  - action: click
+    locators:
+      - by: text
+        value_pattern: "${selected_flights}"
+      - by: aria_label
+        value_pattern: "${selected_flights}"
+      - by: css
+        value: "div.mxvQLc.ceis6c div.zxVSec.YMlIz"
+    wait_for:
+      xhr: "GetBookingResults"
+      method: POST
+result:
+  source: xhr
+  url_pattern: "FlightsFrontendService/GetBookingResults"
+  extract: "[]"
+  return_as: booking_options
+notes: "Run after a Google Flights search has rendered matching results. For round_trip or multi_city selections, selected_flights should identify the complete visible itinerary or the next required leg option; Google may issue GetShoppingResults for intermediate leg selection before the final GetBookingResults response."

package/examples/google-flights/get_flight_booking_options/request-transform.ts

@@ -0,0 +1,210 @@
+import { transform as sharedTransform } from '../_shared/google_flights_transport.ts';
+import { extract as extractSearchResults } from '../search_flights/parser.ts';
+
+type SegmentTuple = [string, string, string, null, string, string];
+type SegmentGroup = SegmentTuple[];
+
+const BOOKING_ENDPOINT = 'https://www.google.com/_/FlightsFrontendUi/data/travel.frontend.flights.FlightsFrontendService/GetBookingResults';
+const SHOPPING_ENDPOINT = 'https://www.google.com/_/FlightsFrontendUi/data/travel.frontend.flights.FlightsFrontendService/GetShoppingResults';
+const ROUND_TRIP_TYPE = 1;
+const ONE_WAY_TRIP_TYPE = 2;
+const MULTI_CITY_TRIP_TYPE = 3;
+
+function normalizeSegment(value: unknown): SegmentTuple | null {
+  if (Array.isArray(value)) {
+    const [origin, date, destination, ignored, carrier, flightNumber] = value;
+    if (typeof origin === 'string' && typeof date === 'string' && typeof destination === 'string' && typeof carrier === 'string' && String(flightNumber)) {
+      return [origin, date, destination, ignored === null ? null : null, carrier, String(flightNumber)];
+    }
+  }
+  if (value && typeof value === 'object') {
+    const obj = value as Record<string, unknown>;
+    const origin = obj.origin;
+    const date = obj.date ?? obj.departureDate;
+    const destination = obj.destination;
+    const carrier = obj.carrier ?? obj.carrierCode;
+    const flightNumber = obj.flightNumber ?? obj.flight_number;
+    if (typeof origin === 'string' && typeof date === 'string' && typeof destination === 'string' && typeof carrier === 'string' && flightNumber != null) {
+      return [origin, date, destination, null, carrier, String(flightNumber)];
+    }
+  }
+  return null;
+}
+
+function parseSelectedFlights(raw: unknown): SegmentTuple[] {
+  if (Array.isArray(raw)) return raw.map(normalizeSegment).filter((item): item is SegmentTuple => Boolean(item));
+  if (typeof raw !== 'string') return [];
+  const trimmed = raw.trim();
+  if (!trimmed) return [];
+  try {
+    return parseSelectedFlights(JSON.parse(trimmed));
+  } catch {
+    const parts = trimmed.split(',').map((part) => part.trim()).filter(Boolean);
+    if (parts.length % 5 !== 0) return [];
+    const out: SegmentTuple[] = [];
+    for (let i = 0; i < parts.length; i += 5) {
+      const carrier = parts[i];
+      const flightNumber = parts[i + 1];
+      const date = parts[i + 2];
+      const origin = parts[i + 3];
+      const destination = parts[i + 4];
+      if (!carrier || !flightNumber || !date || !origin || !destination) continue;
+      out.push([origin, date, destination, null, carrier, flightNumber]);
+    }
+    return out;
+  }
+}
+
+function sameCode(left: string, right: string): boolean {
+  return left.trim().toUpperCase() === right.trim().toUpperCase();
+}
+
+function dateDeltaDays(left: string, right: string): number | null {
+  const leftTime = Date.parse(`${left}T00:00:00Z`);
+  const rightTime = Date.parse(`${right}T00:00:00Z`);
+  if (!Number.isFinite(leftTime) || !Number.isFinite(rightTime)) return null;
+  return Math.round((rightTime - leftTime) / 86_400_000);
+}
+
+function groupSelectedSegments(segments: SegmentTuple[]): SegmentGroup[] {
+  const groups: SegmentGroup[] = [];
+  for (const segment of segments) {
+    const current = groups[groups.length - 1];
+    const previous = current?.[current.length - 1];
+    const startsReturnToGroupOrigin = current ? sameCode(segment[2], current[0]![0]) : false;
+    const dateDelta = previous ? dateDeltaDays(previous[1], segment[1]) : null;
+    const continuesConnection = previous
+      && sameCode(segment[0], previous[2])
+      && (dateDelta === null || (dateDelta >= 0 && dateDelta <= 1))
+      && !startsReturnToGroupOrigin;
+    if (current && continuesConnection) {
+      current.push(segment);
+    } else {
+      groups.push([segment]);
+    }
+  }
+  return groups;
+}
+
+function airportRef(code: string) {
+  const type = code.startsWith('/m/') ? 5 : 0;
+  return [[[code, type]]];
+}
+
+function routeLegEndpoints(group: SegmentGroup): { origin: string; date: string; destination: string } {
+  const first = group[0]!;
+  const last = group[group.length - 1]!;
+  return { origin: first[0], date: first[1], destination: last[2] };
+}
+
+function searchLeg(group: SegmentGroup, selected = false) {
+  const { origin, date, destination } = routeLegEndpoints(group);
+  return [airportRef(origin), airportRef(destination), null, 0, null, null, date, null, selected ? group : null, null, null, null, null, null, 1];
+}
+
+function tripTypeForGroups(groups: SegmentGroup[]): number {
+  if (groups.length <= 1) return ONE_WAY_TRIP_TYPE;
+  const first = routeLegEndpoints(groups[0]!);
+  const second = routeLegEndpoints(groups[1]!);
+  if (
+    groups.length === 2
+    && sameCode(first.origin, second.destination)
+    && sameCode(first.destination, second.origin)
+  ) {
+    return ROUND_TRIP_TYPE;
+  }
+  return MULTI_CITY_TRIP_TYPE;
+}
+
+function legCriteria(group: SegmentGroup, index: number, tripType: number) {
+  const { origin, date, destination } = routeLegEndpoints(group);
+  const legKind = tripType === ONE_WAY_TRIP_TYPE || (tripType === ROUND_TRIP_TYPE && index === 0) ? 3 : 1;
+  return [airportRef(origin), airportRef(destination), null, 0, null, null, date, null, group, null, null, null, null, null, legKind];
+}
+
+function tokenFromSearchResponse(rawResponse: unknown, params: Record<string, unknown>, targetIndex: number): string {
+  const requestedGroups = groupSelectedSegments(parseSelectedFlights(params.selected_flights));
+  if (requestedGroups.length === 0) throw new Error('selected_flights must be a JSON array of selected flight segment tuples');
+  const target = requestedGroups[Math.min(Math.max(targetIndex, 0), requestedGroups.length - 1)]!;
+
+  const searchData = extractSearchResults(rawResponse, { params: {}, responses: [] }) as {
+    itineraries?: Array<{ selected_flights?: unknown; selection_token?: unknown }>;
+  };
+  const itineraries = Array.isArray(searchData?.itineraries) ? searchData.itineraries : [];
+
+  for (const itinerary of itineraries) {
+    const candidateGroups = groupSelectedSegments(parseSelectedFlights(itinerary.selected_flights));
+    const candidate = candidateGroups.length === 1 ? candidateGroups[0]! : [];
+    if (
+      sameSelectedFlights(target, candidate)
+      && typeof itinerary.selection_token === 'string'
+      && itinerary.selection_token
+    ) {
+      return itinerary.selection_token;
+    }
+  }
+
+  if (requestedGroups.length === 1) {
+    const fallback = itineraries.find((itinerary) => typeof itinerary.selection_token === 'string' && itinerary.selection_token)?.selection_token;
+    if (typeof fallback === 'string' && fallback) return fallback;
+  }
+  throw new Error(`Unable to mint a fresh booking selection token for selected_flights segment ${targetIndex + 1}`);
+}
+
+function buildShoppingInner(params: Record<string, unknown>, responses: unknown[]) {
+  const groups = groupSelectedSegments(parseSelectedFlights(params.selected_flights));
+  if (groups.length === 0) throw new Error('selected_flights must be a JSON array of selected flight segment tuples');
+  const tripType = tripTypeForGroups(groups);
+  const selectedPrefixCount = Math.min(responses.length, Math.max(0, groups.length - 1));
+  const searchLegs = groups.map((group, index) => searchLeg(group, index < selectedPrefixCount));
+  if (tripType === ONE_WAY_TRIP_TYPE) {
+    searchLegs[0]![14] = 3;
+  }
+  const filters = [null, null, tripType, null, [], 1, [1, 0, 0, 0], null, null, null, null, null, null, searchLegs, null, null, null, 1];
+  if (selectedPrefixCount === 0) return [[], filters, 0, 0, 0, 1];
+  const selectionToken = tokenFromSearchResponse(responses[responses.length - 1], params, selectedPrefixCount - 1);
+  return [[null, selectionToken], filters, 0, 0, 0, 1];
+}
+
+function sameSegment(left: SegmentTuple, right: SegmentTuple): boolean {
+  return left[0] === right[0] && left[1] === right[1] && left[2] === right[2] && left[4] === right[4] && left[5] === right[5];
+}
+
+function sameSelectedFlights(requested: SegmentTuple[], candidate: SegmentTuple[], allowPrefix = false): boolean {
+  if (requested.length === 0 || candidate.length === 0) return false;
+  if (allowPrefix) {
+    if (candidate.length > requested.length) return false;
+    return candidate.every((segment, index) => sameSegment(segment, requested[index]!));
+  }
+  if (requested.length !== candidate.length) return false;
+  return requested.every((segment, index) => sameSegment(segment, candidate[index]!));
+}
+
+function buildBookingInner(params: Record<string, unknown>, responses: unknown[]) {
+  const groups = groupSelectedSegments(parseSelectedFlights(params.selected_flights));
+  if (groups.length === 0) throw new Error('selected_flights must be a JSON array of selected flight segment tuples');
+  const tokenSource = responses[responses.length - 1];
+  const selectionToken = tokenFromSearchResponse(tokenSource, params, groups.length - 1);
+  const tripType = tripTypeForGroups(groups);
+  const criteria = [null, null, tripType, null, [], 1, [1, 0, 0, 0], null, null, null, null, null, null, groups.map((group, index) => legCriteria(group, index, tripType)), null, null, null, 1];
+  const selectedOptionIndex = Number(params.selected_option_index ?? 0);
+  return [[null, selectionToken], criteria, null, Number.isFinite(selectedOptionIndex) ? selectedOptionIndex : 0];
+}
+
+export function transform(method: string, url: string, responses: unknown[], params?: Record<string, unknown>): { url: string; body: string; headers: Record<string, string> } {
+  const requestParams = params ?? {};
+  const isShoppingRequest = (url || '').includes('/GetShoppingResults');
+  const inner = isShoppingRequest ? buildShoppingInner(requestParams, responses) : buildBookingInner(requestParams, responses);
+  const endpoint = isShoppingRequest ? SHOPPING_ENDPOINT : BOOKING_ENDPOINT;
+  return sharedTransform(method, url || endpoint, responses, {
+    fReq: [null, JSON.stringify(inner)],
+    rpcid: isShoppingRequest ? 'GetShoppingResults' : 'GetBookingResults',
+    sourcePath: isShoppingRequest ? '/travel/flights' : '/_/FlightsFrontendUi/data/travel.frontend.flights.FlightsFrontendService/GetBookingResults',
+    referer: isShoppingRequest ? 'https://www.google.com/travel/flights/search' : 'https://www.google.com/travel/flights/booking',
+    headers: {
+      'sec-ch-ua-full-version': '"148.0.7778.96"',
+      'x-goog-ext-259736195-jspb': '["en-US","US","USD",2,null,[420],null,null,7,[]]',
+    },
+    params: requestParams,
+  });
+}

package/examples/google-flights/get_flight_booking_options/workflow.json

@@ -0,0 +1,85 @@
+{
+  "toolName": "get_flight_booking_options",
+  "intent": {
+    "description": "Get booking and fare details for a selected Google Flights itinerary.",
+    "userSaid": "clicked one of the one-way fares to find more details and booking details; saw the options for another flight; chose round trip fares; kept exploring round trip fare details; clicked the option for the first leg; clicked the option for the second leg and came to the booking options page"
+  },
+  "site": "google-flights",
+  "parameters": [
+    {
+      "name": "selected_flights",
+      "type": "string",
+      "description": "JSON array of selected segment tuples [origin, departureDate, destination, null, carrierCode, flightNumber]. For round-trip and multi-city booking, pass the complete ordered array of selected legs; a single first-leg value is treated as a one-way booking.",
+      "verified": true,
+      "sourcedFrom": {
+        "tool": "search_flights",
+        "field": "selected_flights"
+      }
+    }
+  ],
+  "bootstrap": {
+    "url": "https://www.google.com/travel/flights/search?tfs=CBwQAhoeEgoyMDI2LTA2LTA4agcIARIDU0pDcgcIARIDU0FOGh4SCjIwMjYtMDYtMTFqBwgBEgNTQU5yBwgBEgNTSkNAAUgBcAGCAQsI____________AZgBAQ",
+    "waitUntil": "domcontentloaded",
+    "waitMs": 500,
+    "timeoutMs": 30000,
+    "captures": [
+      {
+        "source": "html_regex",
+        "name": "f_sid",
+        "pattern": "(?:FdrFJe|f\\.sid)[^0-9-]{0,80}(-?[0-9]{10,})",
+        "group": 1,
+        "required": true,
+        "capability": "browser_bootstrap"
+      },
+      {
+        "source": "html_regex",
+        "name": "bl",
+        "pattern": "\"cfb2h\":\"([^\"]+)\"",
+        "group": 1,
+        "required": true,
+        "capability": "browser_bootstrap"
+      }
+    ]
+  },
+  "requests": [
+    {
+      "method": "POST",
+      "url": "https://www.google.com/_/FlightsFrontendUi/data/travel.frontend.flights.FlightsFrontendService/GetShoppingResults?f.sid=${state.f_sid}&bl=${state.bl}&hl=en-US&soc-app=162&soc-platform=1&soc-device=1&_reqid=${generated.epoch_ms}&rt=c",
+      "headers": {
+        "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+        "X-Same-Domain": "1",
+        "sec-ch-ua-full-version": "\"148.0.7778.96\"",
+        "x-goog-ext-259736195-jspb": "[\"en-US\",\"US\",\"USD\",2,null,[420],null,null,7,[]]"
+      },
+      "body": "{\"selected_flights\":\"${param.selected_flights}\"}",
+      "effect": "safe"
+    },
+    {
+      "method": "POST",
+      "url": "https://www.google.com/_/FlightsFrontendUi/data/travel.frontend.flights.FlightsFrontendService/GetShoppingResults?f.sid=${state.f_sid}&bl=${state.bl}&hl=en-US&soc-app=162&soc-platform=1&soc-device=1&_reqid=${generated.epoch_ms}&rt=c",
+      "headers": {
+        "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+        "X-Same-Domain": "1",
+        "sec-ch-ua-full-version": "\"148.0.7778.96\"",
+        "x-goog-ext-259736195-jspb": "[\"en-US\",\"US\",\"USD\",2,null,[420],null,null,7,[]]"
+      },
+      "body": "{\"selected_flights\":\"${param.selected_flights}\"}",
+      "effect": "safe"
+    },
+    {
+      "method": "POST",
+      "url": "https://www.google.com/_/FlightsFrontendUi/data/travel.frontend.flights.FlightsFrontendService/GetBookingResults?f.sid=${state.f_sid}&bl=${state.bl}&hl=en-US&soc-app=162&soc-platform=1&soc-device=1&_reqid=${generated.epoch_ms}&rt=c",
+      "headers": {
+        "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+        "X-Same-Domain": "1",
+        "sec-ch-ua-full-version": "\"148.0.7778.96\"",
+        "x-goog-ext-259736195-jspb": "[\"en-US\",\"US\",\"USD\",2,null,[420],null,null,7,[]]"
+      },
+      "body": "{\"selected_flights\":\"${param.selected_flights}\"}",
+      "effect": "safe"
+    }
+  ],
+  "requestTransformModule": "./request-transform.ts",
+  "parserModule": "./parser.ts",
+  "liveVerified": true
+}

package/examples/google-flights/get_flight_calendar_prices/backends.json

@@ -0,0 +1,27 @@
+{
+  "probedAt": "2026-07-01T01:13:54.138Z",
+  "imprintVersion": "0.5.0",
+  "schemaVersion": 2,
+  "workflowHash": "48de2030ea75e30e2c8f30826bda3cad0cec686621316268a5b8898a08752006",
+  "capabilityHash": "5fc16811cd65aff7afee349ddca05c806a65c9c2c96948192ea1bafba9284c38",
+  "preferredOrder": [
+    "cdp-replay"
+  ],
+  "results": {
+    "fetch": {
+      "outcome": "failed",
+      "durationMs": 17,
+      "error": "STATE_MISSING",
+      "detail": "STATE_MISSING: Workflow placeholder ${state.bl} but state \"bl\" has not been captured yet"
+    },
+    "fetch-bootstrap": {
+      "outcome": "forbidden",
+      "durationMs": 29952,
+      "detail": "FORBIDDEN: fetch-bootstrap: cdp-minted jar did not validate; cdp-replay (in-page) required."
+    },
+    "cdp-replay": {
+      "outcome": "ok",
+      "durationMs": 550
+    }
+  }
+}