Chop it

View saved version →

---
name: chop-it-meal-planner
description: Plan dinners, build shopping lists, keep a pantry, and grow a personal recipe library with Chop It. Use when the user wants dinner ideas, a weekly meal plan, a shopping list sent to an online grocery shop, wants to track what's in their kitchen, OR wants to save a recipe - from a photo of a cookbook page, a TikTok/Instagram/website link, or an idea of their own developed into a proper recipe. Also covers generating Chop It-styled food photos in chat.
---

# Chop It meal planner & recipe library

Chop It plans real, cookable weeks of dinners from a quality-gated UK recipe
catalogue, turns them into one shopping list grouped by aisle, keeps the
household's pantry, and saves the user's own recipes (photographed, linked or
invented) into their Chop It library. Web, iPhone and ChatGPT are entrances to
the same account: the same recipes, food rules, plan and shopping state.

## How the tools fit together

The signature request is "plan my dinners and turn them into a shopping list".
The data flows like this:

1. **Choosing a mix.** `prepare_weekly_menu` answers a broad request ("plan my
   week", "5 dinners") with the mix chooser in the widget: the user picks a
   protein mix and people per dinner, and the widget builds the week itself.
   A request that already states a counted mix ("2 chicken, 1 fish"),
   `slotRequirements`, a `mixPreset` or "surprise me" is built directly, the
   same as `create_weekly_menu`. For a signed-in account, its diet shapes the
   mixes on offer. The chooser's result text says that the chooser is on
   screen and that nothing is built until the user picks.
2. **Building the week.** `create_weekly_menu` returns a `menuDraftId` and a
   `dinners` array; each dinner has up to five equal `candidates` (title,
   time, `reason`) and nothing selected. `needs_selections` with 0 chosen is
   the normal starting state. `slotIssues` lists any slot with fewer than
   five matches and why: fewer cards means fewer recipes met that slot's
   rules, not a shortage in the catalogue.
3. **Choosing dinners.** The widget is the chooser; its cards call
   `revise_weekly_menu` (`slotId` + `replacementRecipeId`). A choice made in
   chat goes through the same tool; a choice described only in chat leaves
   the draft as it was. `reroll: true` with a `slotId` gives five new choices
   for that slot; `refillShortSlots: true` tops up every slot in `slotIssues`
   in one call. Each revision returns a new `menuDraftId`, which is the one
   to save or shop. `get_menu_draft` reads the current state whenever the
   latest id is uncertain. Choosing works before sign-in on a draft no
   account owns.
4. **Saving.** `save_week` stores a completed draft as a reusable Saved Week
   and returns `savedWeekId` with the `menuDraftId`; it leaves This Week
   unchanged and is safe to retry. `set_this_week` makes a Saved Week the
   week being cooked; `save_menu` does both at once. `get_my_week` reads
   This Week. `list_saved_weeks`, `open_saved_week`, `share_week`,
   `preview_shared_week` and `import_shared_week` move weeks around.
5. **Shopping.** `create_shopping_list` takes the exact `menuDraftId` (or
   `recipeIds`) and returns `shoppingListId`, aisle `sections` and counts
   (buy, covered, check stock). The widget calls it from the completed week
   and shows the list card. `get_shopping_list` and `update_shopping_list`
   hold ticks ("I already have rice") and partly covered quantities;
   `open_shop_handoff` makes a time-limited Chop it review page where the
   user ticks the list and follows per-item supermarket search links. No
   purchase happens in chat.

Widget-made calls (building from the chooser, Choose, Save week, Shop) show
their result in the widget and can appear in the conversation without a text
result. A missing text result says nothing about the outcome either way: the
returned status, the widget state or a `get_menu_draft` read-back establishes
whether a selection, save or shopping action completed.

## Recipes

- `search_recipes` returns cards from the catalogue (title, photo, time,
  tags, protein, and per-serving nutrition when the catalogue can vouch for
  it). Structured filters are hard constraints: "quick chicken dinners" is
  `filters.protein ['chicken']` with `filters.maxTimeMins 30`. Dinner-intent
  searches leave out sides, dips and starters.
- `get_recipe` returns one complete recipe: ingredients with quantities, the
  method, and `nutrition` (per serving) when it can be vouched for, else
  `nutritionNote` with the reason. The weekly widget opens recipes inside
  the card with the same data; the recipe card also offers step-by-step
  cooking.
- `save_discovered_recipe` copies a catalogue recipe into the user's library.
- `list_saved_recipes`, `update_recipe` and `delete_recipe` act only on the
  user's own recipes. `update_recipe` replaces `ingredientSections` and
  `steps` whole, so a change is sent as the complete corrected list, keeping
  `optional: true` on garnishes so they stay off the shopping list.

## Food rules

`get_food_preferences` and `update_food_preferences` hold the account's diet
(none, vegetarian, vegan, pescatarian), its foods to avoid (fourteen common
foods such as milk, eggs, peanuts or gluten) and its dislikes, in plain
words; the same record the app's Food preferences settings show. Every
planning, search and recipe call applies them: recipes that use those foods,
or whose ingredients are unclear, are left out. A whole-week rule stated in
chat goes in `dietary`; a single vegetarian dinner is a slot, not a
whole-week rule. Chop It leaves out the foods a person chooses but is not
built for managing allergies, so no recipe, plan or list is described as
allergen-free or safe for an allergy; checking labels and ingredients is the
advice when health needs come up.

## The pantry

`get_pantry` and `update_pantry` track what is in the user's kitchen (name,
storage location, quantity, how full, expiry): the same pantry the app shows
for a connected account. Planning uses the pantry only when the user asks
(`pantryMode: use`, or `focus` with named ingredients to use up), for that
request only; general dinner ideas don't read it. "I bought…" adds (topping
up what is already there); "we finished the…" removes. Staples such as salt,
pepper and oil are skipped.

## Building the user's recipe library

Recipes enter the library through `import_recipe_from_url` (TikTok,
Instagram, any recipe website, or pasted caption text), `import_recipe_from_image`
(a fetchable image URL of a cookbook page, screenshot or handwritten card) or
`start_recipe` then `save_recipe` (a recipe written in chat). A connected
account is required for all three, and every save lands in the user's
permanent library with an `appUrl`.

- An import that returns `needs_review` carries a preview and the issues
  found; the corrected recipe is saved with `save_recipe` (keeping the
  original `sourceUrl`). Imports that need paid processing require
  `confirmPaidImport` after the user agrees; they are limited per
  conversation, while `save_recipe` is not.
- A recipe written in chat meets Chop It's standard when it uses UK
  vocabulary and metric quantities (coriander, courgette, aubergine, mince;
  grams, ml, tbsp, tsp), groups ingredients into sections, gives a complete
  method with sensory cues ("until golden and bubbling") and timings, and
  has a plain title with no marketing words. `start_recipe` returns that
  brief with a `recipeDraftToken`; `save_recipe` checks the recipe against
  it and answers `needs_revision` with `fixes` when something is missing.
- When the user wants to invent a dish, a short conversation gets there:
  the hook and title; a balanced plate (protein, plants, carb, one upgrade
  such as acid, crunch or a herb finish); timings that finish together; a
  method with cues; and one vivid sentence for `finishingTouch`. One or two
  rounds of questions is plenty.

## Food photos in chat

A picture of a dish comes from the user's own ChatGPT image tool, not from
Chop It. The house style: square, a three-quarters elevated angle with the
dish dominating the frame, warm directional daylight with soft shadows and
true colour, handmade ceramics or enamelware on linen or wood with believable
imperfections, editorial home-cooking realism, and only the ingredients that
would be visible in the finished dish. Such an image is not attached to a
saved recipe; the app can generate a hero image for it.

## Facts worth keeping straight

- `menuDraftId` and `shoppingListId` name drafts that expire after about 24
  hours whether or not the week is saved; an unrecognised id means the draft
  expired. The durable reference is the `savedWeekId` from `save_week`, and
  `open_saved_week` makes a fresh draft from it.
- A week is saved when `save_week` has returned `saved` or `already_saved`.
  Saving leaves This Week unchanged.
- `open_shop_handoff` returns a Chop it review page; a `null` `handoffUrl`
  comes with a `message` saying why.
- Every dinner offered comes from a tool result; a recipe the user writes
  with the funnel is authored and then saved.
- Some recipes have no `oneLiner` or image; title and time are enough.