EatStreet

The days and times one restaurant will take an order ahead for, and whether it takes an order now. Call it whenever a customer names a time, such as "by 6pm" or "tomorrow lunch". Every time here is the restaurant's local time, in the `time_zone` inside `now_at_restaurant`, not the customer's: 6pm for a customer in another zone means 6pm where the food arrives. The slots are arrival times, not order times. A 6:00 PM slot means the food arrives at 6:00 PM, and an order placed now with arrive_time "6:00 PM" is held by the kitchen. Each slot is at least 15 minutes plus the restaurant's own delivery or pickup time from now, or from when it opens. `now_at_restaurant` is the local weekday, date and time there, the date a customer means by "tonight". It matches each entry's `date` in `days`; when today has no entry, today has no slots left to order ahead, and the next day's entry is not today. An empty `days` list means the restaurant takes orders for as soon as possible only, which is an answer, not a failure. `days` holds only times to order ahead; `as_soon_as_possible` says whether the restaurant takes an order placed now and in about how many minutes it arrives. Scheduling is decided restaurant by restaurant, and the answer is here: one restaurant that cannot schedule says nothing about EatStreet as a whole. A chosen `arrive_date` and `arrive_time` go to validate_cart, price_cart and create_checkout_link exactly as they appear here, and ride through to the customer's checkout.

when_can_it_arrive

Checks a cart against the live menu and EatStreet's checkout before it is priced, once the customer has chosen each dish and made its required choices, and again after each change. `note` is the customer's own words, passed to the restaurant and printed on their ticket. Say only what the customer said. It is not a guarantee and it is not free: EatStreet prints "customer comments subject to additional charge" beside it, so a note is not a way to obtain something without paying for it. A note never substitutes for an option the dish already has; if the menu offers a choice, make the choice. Some restaurants refuse notes altogether, and this refuses the cart rather than dropping them quietly. A per-dish instruction goes on the item as `"note"` and an order-wide one here. `items` is a list of {"product_id": int, "quantity": int, "choices": reference}, where `choices` is the reference ending a message from EatStreet's card, as written; or, without the card, {"answers": {question key: answer}, "declined": [question key]}, with each dish's answers in the keys get_product_options gave it. `declined` lists questions the customer was asked about and answered with a choice marked `none`, which is only honest after they have actually been asked. A required question left unanswered is named in the answer, with every other one still open. `options` with option and value ids is still read. The answer's `cart` is the cart as EatStreet read it. A dish or choice in it that the customer did not ask for needs correcting before the cart is priced.

validate_cart

Turns a validated cart into a link the customer opens to pay on EatStreet, with the cart already loaded. Call it only after the customer has made every required choice themselves and said yes to this cart at this price. Never make a required choice for them, even one you recommended; if a choice is still open, ask and wait for the answer. The link works for an hour, and only in the first browser that opens it. Give the customer the URL and nothing else: no token, no ids. Pass the same `note` and the same item notes as the validated cart. The link carries the cart it is given, so a note left out here is a note the restaurant never sees, whatever the customer was told. The first browser can open the link again and keeps the cart until the order is placed. In a different browser or on a second device, after the hour, or after the order is placed, it opens with an empty cart and a message that the link has expired, was opened in a different browser, or its order has already been placed. Tell the customer to open it on the device they will pay on. If they say the cart is empty or the link has expired, make a new link.

create_checkout_link

For EatStreet's card only: one dish's questions, as get_product_options gives them, with the dish's name, price and photo and its restaurant's name, for the card to show every choice when the customer taps the dish.

options_for_card

For EatStreet's card only: the recommended dishes at one restaurant, as recommend_dishes chooses them, for the card to draw under the restaurant the customer tapped. `section` is what the customer searched for.

dishes_for_card

Lists EatStreet restaurants serving the customer's location, open now or at `when`; any opening shortly follow, marked `opens_at`. Call it before asking where the customer is, and again when the customer narrows the search, such as free delivery or somewhere close: each search draws a new card. Only restaurants it returns can take an EatStreet order. The customer chooses the restaurant; `next_step` says how. EatStreet does not deliver alcohol. Delivery range, not distance, answers "do they deliver to me". With `location` empty, `searched_near` names the approximate area searched. `market` names the city and state searched. A city name several states share needs the customer to confirm the state, passed as `Madison, AL`. For a dish, such as breakfast sandwiches, `cuisine` takes the kind of food it belongs to, and recommend_dishes' `section` finds the dish. Convenience stores are included, and early in the morning they may be the only places open. Restaurants whose delivery zone cannot reach the address are left out, counted in `nearby_but_cannot_deliver_to_that_address`. `miles_away` is a straight-line distance, not a travel time. `when_searched` names the day searched, and `now_in_market` the local weekday, date and time. `hours_known: false` means its hours are unknown. `matching_but_shut_right_now` counts matches shut now: above zero, a search with `when` finds them later; at zero, EatStreet has none here. `cashback_percent` is EatStreet Cash, credited 24 to 48 hours after an order paid online while signed in to an EatStreet account and spendable on a later order; a guest checkout or a cash order earns none. Every restaurant pays at least 1%, so a higher rate is a promotion running now. Absent means cash back is off. `rating` is EatStreet's own score out of five from `rating_count` ratings; there are no written reviews, and no rating means nobody has rated it. `schedules_on_eatstreet` says whether the restaurant takes scheduled orders; most do not.

find_restaurants

A dish's choices, as questions in menu order, each with a `key` and its choices' keys. Call it before adding a dish that has choices. Never promise the customer a choice before reading the dish's questions. Where the menu cannot do what the customer asked, tell them, and ask before adding anything. Each required choice is the customer's to make: ask, and wait for their reply. Never make it for them, even with the choice you would recommend; you may say which one you suggest, and the customer still decides. A question with `required` true needs an answer, and `limit` says how many its choices allow. `say` puts each question in words that can be shown or spoken as they stand. A choice is shown as selected only where it is a question's `default`; every other choice, and every choice in a required question, starts unselected, and a default the customer keeps is sent. The cart takes the customer's answers as the item's `answers`, keyed by question `key`: a choice's `key` for `one` and `size`, a list of keys for `some` and `addons`, a whole number for `count`, and for `halves` each topping's key mapped to "first", "second" or "whole". Keys, never names. A choice marked `none` in a required question is sent only when the customer chose it, with that question's key also in the item's `declined`. A reference from a message of EatStreet's card goes in the item's `choices` instead, as written. `unavailable` means the dish cannot be ordered now. A dish whose name says "Create Your Own" or "Build Your Own" comes with no toppings unless the customer names some, so the order needs their answer to "Do you want to add toppings?" before it is added. Once the choices are made, validate_cart checks that restaurant's cart. A dish from a different restaurant than the cart in progress starts a second, separate order, which the customer needs to know.

get_product_options

What a restaurant sells, for the assistant to read; it shows the customer nothing. It is not for recommending dishes: recommend_dishes gives EatStreet's own. Call it to find a dish the customer named, to answer a question about the menu, or, with show_dishes, to meet a request recommend_dishes cannot, such as "3 of us are vegetarian" or "I have $10". The menu holds no allergen, dietary or nutrition information. Never answer such a question from a dish's name or description; say plainly that EatStreet does not have it and the restaurant does. EatStreet does not deliver alcohol, so no menu offers it for delivery. show_dishes puts the dishes chosen from here on a card the customer can tap; a list in text cannot be tapped. With neither `contains` nor `category`, it returns the menu's sections and their item counts and no dishes, which is the answer, not a failure; a menu of 25 dishes or fewer comes whole. `contains` finds a dish by name across the whole menu. When the customer named one dish, such as by a tap on EatStreet's card, and two dishes match it, ask the customer which one they mean. `category` returns one section's dishes, named as the section list gives it. When the customer asked for several kinds of food, such as pizza and salads, this shows whether the chosen restaurant has each, which the customer needs to know before the cart is built. `limit` is capped; `contains` or `category` narrows instead. A dish can be ordered at most 25 times in one order, or `max_per_order` times where that is shown. `out_of_stock: true` means it cannot be ordered today. Some sections are served only at set times, such as a brunch; `served` says when, and `served_now: false` on a section or a dish means checkout will not take it now, even for a later time. `price_is_from: true` means `price` is the least the dish can cost.

get_menu

The hours, delivery and pickup times, delivery fee, minimum, closing time and distance EatStreet will accept and charge for at one restaurant; hours and fees published elsewhere can differ. Call it before building a cart, with the delivery address as `address` for delivery, even after a delivery search, which may have checked no zone. `delivers_to_that_address` answers "do they deliver to me" only when `delivery_range_checked` is true. False means nothing was checked and the null beside it is not a yes. With the range checked, true means the address is inside the delivery zone; false means it is outside, so this restaurant cannot deliver the order; null means EatStreet does not hold this restaurant's zones, so delivery is not confirmed. On a pickup order those two fields say nothing. `delivery_range_checked` is false when no address was given or the one given could not be placed near this restaurant. For a pickup customer who asks how far the restaurant is, `address` is their starting point. `straight_line_miles_from_that_address` is a straight line from `address` and the only distance this server has. It is not a driving distance and not a journey time, and no departure time follows from it: the customer's own journey time is not here. Never give a distance or a direction this tool did not return. The pickup time is how long after the order is placed the food is ready. `schedules_on_eatstreet` is always returned; `false`, the common case, means the restaurant takes no scheduled orders. `loyalty_tiers` is the restaurant's own coupon ladder, present only where it runs one. `dollars_spent` is the customer's cumulative spend at that restaurant that earns each reward, not the size of one order, and what the customer has spent so far is not here. It is separate from `cashback_percent`.

get_restaurant

For EatStreet's card only: keeps the customer's choices for one dish, checked against its questions, under a short reference for the card's message.

hold_choices_for_card