Save a restaurant or menu item as a favorite.

Args:
    kind: 'restaurants' or 'items'
    name: Name of the restaurant or item
    uuid: Restaurant UUID (for restaurants)
    url: Restaurant URL (for restaurants)
    restaurant: Which restaurant this item is from (for items)

Add a line via addItemsToDraftOrderV2 + getMenuItemV1 (same stack for restaurants and grocery).

Best: pass store_uuid + menu_item_uuid (required). The server loads getStoreV1 and resolves the
real section_uuid / subsection_uuid from the menu—so wrong search data (e.g. section_uuid =
store_uuid) is fixed automatically when the SKU exists in the menu.

Optional: section_uuid, subsection_uuid, item_name from uber_eats_search items[] or restaurant_menu.

Fallback: restaurant_url + item_name (fuzzy match on full menu; more error-prone).

If the item has required customizations, call uber_eats_get_item_options first.

Args:
    item_name: Display / fuzzy name (optional if UUID path fills title from getMenuItemV1)
    quantity: How many to add (default 1)
    restaurant_url: Store URL or slug (legacy path)
    store_uuid: Merchant UUID (from search or menu payload)
    section_uuid: Catalog section UUID (never the same as store_uuid; optional if resolvable from menu)
    subsection_uuid: Submenu UUID (often empty; server retries with menu_item_uuid if needed)
    menu_item_uuid: SKU / catalog item UUID

Apply a promo code (e.g. from email or offers). May succeed or return an error
if the code is invalid or expired.

Args:
    code: Promotion code string

Preview the order with full price breakdown. Always call this before
place_order and show the summary to the user for confirmation.
Does NOT place the order.

After showing the preview, you MUST:
1. Show a clear summary to the user (items, fees, total, address, payment)
2. Ask which payment method to use
3. Ask how much tip to add
4. Show the final total WITH tip
5. Ask for EXPLICIT confirmation before proceeding

Do NOT call place_order until the user explicitly confirms.

Current delivery address from saved session/config (no login browser).
Prefer this (with get_preferences) before uber_eats_login when starting a chat.

Get customization options for a menu item (sizes, extras, required choices).
Each group includes required, min_permitted, max_permitted, pick_one (when API provides them).
Call this before add_to_cart if the item has options/modifiers.

Args:
    item_name: Name of the menu item to inspect
    restaurant_url: Optional restaurant URL if not already on the page

Local preferences file (default address label, favorites, etc.). No browser.
Call first each session; then get_address—avoid opening login until an API
tool proves the Uber session is missing or expired.

List eligible payment methods for the current cart (checkout API).
Requires items in the cart. Use after add_to_cart or when checkout fails
to show card / wallet options.

List Uber account profiles (Personal, Business, Family, etc.) and which is selected.
Use uber_eats_switch_profile to change the active profile before ordering.

Open a visible browser window so the user can sign in to Uber Eats.
By default, if ~/.ubereats-session.json already works for Uber’s API, returns success
without opening a window (avoids wiping/restoring session by mistake).

Args:
    force: If true, always run the full login flow (clears saved session first). Use to
        switch accounts or recover from a bad cookie file.

Load one menu item with customization options (API). UUIDs come from uber_eats_restaurant_menu
item entries (section_uuid, subsection_uuid, uuid).

Args:
    store_uuid: Restaurant store UUID
    section_uuid: Section UUID from the menu item
    subsection_uuid: Subsection UUID from the menu item
    menu_item_uuid: Item UUID (catalog item)

List nearby/popular restaurants from the Uber Eats home feed.
Good for browsing when the user doesn't have a specific craving.
Returns open/closed status for each restaurant.

Args:
    limit: Max restaurants to return (default 15)

Place the order (tries API checkoutOrdersByDraftOrdersV1 first, then browser click).
NEVER call this without explicit user confirmation.

REQUIRED before calling — ALL of these must be true:
1. checkout_preview was called and summary was shown to the user
2. User chose a payment method
3. User specified tip amount (or explicitly said no tip)
4. User saw the final total (including tip)
5. User explicitly said 'yes', 'confirm', 'place it', or similar

If ANY of these are missing, do NOT call this tool.
If the user said 'cancel', 'no', 'wait', or is uncertain, do NOT call this tool.

Get personalized food recommendations based on mood and social context.

If mood is empty, returns the available mood options for the user to pick from.

Mood options: tired, healthy, celebrating, stressed, adventurous, quick, craving
Social context options: alone, couple, family, friends (or custom contexts from preferences)

Args:
    mood: How the user is feeling (e.g. 'tired', 'celebrating', 'adventurous')
    social_context: Who they're eating with (e.g. 'alone', 'family', 'friends')
    craving: Free-text craving if mood is 'craving' (e.g. 'sushi', 'burgers')

Remove an item from the cart by name.

Args:
    item_name: Name of the item to remove

Look up a past order by UUID and return store UUID + previous line items so the user
can open the menu and add items again. Cart mutations still use the browser until
add-to-cart API is captured.

Args:
    order_uuid: Past order UUID from uber_eats_track_orders

Full menu for one store. OK for small restaurants; for supermarkets/groceries
the payload can be enormous (100k+ chars) and exceed the client's tool limit—
prefer uber_eats_search with the product name first, then item-level tools.

Args:
    restaurant_url: Full URL (https://www.ubereats.com/store/...) or restaurant slug

List all saved delivery addresses. Shows labeled addresses (home, work, etc.)
that the user has saved in their Uber Eats account.
Use uber_eats_switch_address to switch between them.

Global Uber Eats search (same flow as the web search bar: getSearchFeedV1, merged
with getFeedV1 for extra catalog rows). Response JSON has:
- stores: list of merchants (name, uuid, url, eta, …)
- items: catalog hits (menu_item_uuid, section_uuid, subsection_uuid, store_uuid)
  for product-style queries like energy drinks or grocery SKUs
- feed_item_types: raw feed module types (debugging)

Use items[] for quick add via menu_item_detail / add_to_cart; use stores[] for browsing.

Args:
    query: Search text (cuisine, store, or product, e.g. 'sushi', 'red bull')

Change the delivery address. Always confirm with the user before calling this.
Opens a headed browser to set the new address via the address picker.

Args:
    address: New delivery address (street address or landmark)

Select payment method for checkout (API). Use payment UUIDs from
uber_eats_list_payment_methods. Optionally set use_credits to 'true' or 'false'.
Set set_as_default to 'true' to also PATCH the account default card (payments profilePatch).

Args:
    draft_order_uuid: Draft order UUID from checkout preview
    payment_profile_uuid: Payment profile UUID to charge
    use_credits: If 'true' or 'false', toggles Uber Cash/credits; empty leaves unchanged
    set_as_default: If 'true', persist as default payment on the selected Uber profile

Set the delivery tip on the current draft order (API). Use tip values that match
Uber's buttons: typically 0, 5, 10, 15, or 20. Call uber_eats_checkout_preview
first and pass draft_order_uuid from the response.

Args:
    draft_order_uuid: Draft order UUID from checkout preview
    tip_percent: Tip percentage (e.g. 10 for 10%)

Update a user preference by dotted key path.

Examples:
  key="default_address", value="home"
  key="default_tip_percent", value="15"
  key="dietary.restrictions", value='["no peanuts", "lactose intolerant"]'
  key="budget.default_per_person", value="15000"
  key="budget.currency", value="CLP"
  key="language", value="es"

Args:
    key: Dotted path to the preference (e.g. 'dietary.avoid')
    value: The value to set (JSON string for lists/objects, plain string for scalars)

Suggest what to order from a specific restaurant based on group size
and preferences. Analyzes the menu and recommends mains, sides, and drinks.

Args:
    restaurant_url: Restaurant URL or slug
    social_context: Who you're eating with (alone, couple, family, friends)

Switch to a saved delivery address by its label (e.g. 'home', 'work').
Call uber_eats_saved_addresses first to see available addresses.

Args:
    label: The label or name of the saved address to switch to

Switch the active Uber profile by UUID from uber_eats_list_profiles.

Args:
    profile_uuid: Profile UUID to select

In-progress / active orders only (delivery, preparing, etc.). Lighter than track_orders.

Change the quantity of a line already in the cart (same API the site uses for line updates).

Best: pass shopping_cart_item_uuid from uber_eats_view_cart items[].shopping_cart_item_uuid.
Otherwise match by item_name (partial match ok).

For large markets / grocery carts, set grocery_store=true if quantity updates fail without it.

Args:
    quantity: New quantity (1 or more)
    item_name: Line title to match if UUID not provided
    shopping_cart_item_uuid: From view_cart items[] (preferred)
    grocery_store: Hint for grocery / convenience store drafts

View the current cart: line titles, quantities, shopping_cart_item_uuid per line (for updates),
and draft_order_uuid. Call before checkout so the user can review; use UUIDs when changing qty.

Get current user profile info and login status from saved session (no login browser).
Use with get_preferences/get_address before deciding whether uber_eats_login is needed.