RoboTrunk

Asks one product's maker manual a specific question and returns the matching passage word for word, with the manual's link, the page and the section heading where the retained text has them, or says plainly that the manual does not cover it. Use when a shopper asks something the manual decides (installation, weight and height limits, age range, care, safety) about a product you hold a product_id for. Not for browsing; use search_catalog. It answers only from manuals RoboTrunk has read and checked, and never guesses. Error recovery: PRODUCT_NOT_FOUND means the store or product is not available through RoboTrunk right now (paused, or a wrong id), not that it is missing, so call search_catalog; INVALID_REQUEST names the field to fix; RATE_LIMITED means wait 60 seconds; unavailable means try again shortly; unverified means read the listed document or ask again; not_covered or no_manual means the manual does not answer it, so read the product's page with get_product; MANUAL_ASK_FAILED (or any other unexpected error): retry once, then call submit_feedback. Next: get_product, or create_checkout. Full guide: get_tool_guide or /agent/tools.json#ask_product_manual Example call: {"merchant":"anbbaby-com","product_id":"gid://shopify/Product/1234567890","question":"What is the maximum weight for the seat?"}

Declines a prepared checkout, returning status canceled: it asks the store to cancel that checkout. Use when the person declines, so a refusal is a recorded outcome rather than an inferred one. Not for reversing a payment: RoboTrunk holds no stock and charges nothing. Not for after approval; use get_order. Next: search_catalog for something else, or submit_feedback to say why. Error recovery: not_found (the demo) or CHECKOUT_NOT_FOUND (a store's checkout) means that checkout was never prepared here, so call create_checkout; continuation_not_found or RUN_AUTH_REQUIRED means send checkout_id exactly as an earlier answer returned it and, if you did, the checkout can no longer be read from here, so call create_checkout again; UCP_MERCHANT_BUSY, UCP_MERCHANT_REFUSED or UCP_MERCHANT_UNAVAILABLE means the store did not take the cancel, so try again shortly; on the demo a failed decline record is only a warning and the cancel still stands; any other error, including tool_layer_failure: retry once, then call submit_feedback. For RoboTrunk's test demo checkout (merchant null) it closes the checkout here and records the decline. Full guide: get_tool_guide or /agent/tools.json#cancel_checkout Example call: {"checkout_id":"the checkout_id create_checkout returned","reason":"Above the person's ceiling"}

Asks whether one listing fits a named thing, such as a car, pram or bottle, and answers yes, no or not_known, from the listing's published checked facts and its own store page only. A yes or no always carries the exact quote it was read from and that quote's source; not_known means nothing RoboTrunk holds settles it. Never a guess. Use when a shopper asks whether a listing fits something they own; take merchant and product_id from search_catalog. For what the maker's manual says, fit included, use ask_product_manual: this tool reads only the listing and its store page. Confirm with the maker before relying on a fit for safety. Error recovery: PRODUCT_NOT_FOUND means the store or product is not available through RoboTrunk right now (paused, or a wrong id), not that it is missing, so call search_catalog; INVALID_REQUEST names the field to fix; RATE_LIMITED means wait 60 seconds; unavailable means try again shortly; FIT_ASK_FAILED (or any other unexpected error): retry once, then call submit_feedback. Next: get_product, or create_checkout. Full guide: get_tool_guide or /agent/tools.json#check_fit Example call: {"merchant":"anbbaby-com","product_id":"gid://shopify/Product/1234567890","fits":"2022 Toyota RAV4"}

You read the listing; RoboTrunk checks it. Use it for a second-hand listing on Facebook Marketplace or any other marketplace, such as a used car seat, cot, pram or heater: it adds a recall check and the sourced facts the listing leaves out, which can help the person decide. Send the listing's title, price, description and seller's notes as listing_text (and up to three photos), read with a Marketplace tool such as facebook-cli if you have one, otherwise a browser. One call returns the exact model; whether a product-safety regulator has recalled it, with the notice; what the listing leaves out (specifications, the maker's manual, expiry where the maker sets one, what to inspect in person, known problems), each with its source; and what the same product costs new against the asking price. If the exact product cannot be identified, the answer is not_identified and nothing is guessed: ask the person for the brand and model. If the person wants a second-hand listing checked but has not shared it yet, the check needs its link or text. If the person gives only a link, send it as listing_link: RoboTrunk never fetches Facebook Marketplace links, so when the answer is listing_text_required, read the listing yourself, first with a Facebook Marketplace tool if you have one, such as facebook-cli, and only otherwise in a browser, and call again with its title, price, description and seller notes as listing_text plus the link; if you cannot read it without logging in or passing a CAPTCHA, ask the person to paste those details. Other public pages RoboTrunk reads directly. Amazon links are never fetched. If resource.leaves_out.state is pending, call again in about a minute for the rest. Error recovery: invalid_request names the field to fix; not_identified means ask the person for the brand and model and call again; unavailable with hourly_bound_full means wait and try later, any other unavailable means try again shortly; check_listing_failed (or any other unexpected error): retry once, then call submit_feedback. Next: check_product with the identified brand and model, or search_catalog to shop for it new. Full guide: get_tool_guide or /agent/tools.json#check_listing Example call: {"listing_text":"DaVinci Kalani 4-in-1 convertible crib in white. Used for one child, all hardware and the toddler rail included, a few teething marks on the top rail. Mattress not included.","asking_price":{"amount":90,"currency":"USD"},"country":"US"}

Answers one question about one product: send its name, barcode, any product page link or a RoboTrunk reference. Returns the checked facts with a source for each, the live recall status, every store selling the same variant with the cheapest not sold out, and the exact create_checkout arguments; with a country, landed_cost adds price_plus_delivery (not a total). It helps before recommending or buying a product, wherever it is sold: on any product the person is weighing, it adds the live recall check, the checked facts and the price new to what you already know. For a second-hand listing they have in front of them, use check_listing, which runs this check on the listing's text. Not for browsing; use search_catalog. Use resource.recall.status as the recall headline. For lookup_pending, wait about 60 seconds and use its exact-input check_product action once; for identification_pending, wait about 15 seconds and use that action once. If it remains pending or incomplete, stop automatic retries. A found result stays the headline; listings_read[] is historical and does not override it. lookup_incomplete and lookup_skipped have no retry action; recall_lookup_incomplete means the live lookup ended without a complete result. none_found_after_lookup is not a safety guarantee. Next: create_checkout with resource.next_step.arguments (choose a variant or offer first when next_step says so); the answer also lifts that step to next_actions and suggested_tools. Error recovery: invalid_request names the field to fix; not_identified means ask the person for the product's page link or its brand and model, then call again (gtin_not_known: send a store link instead of the barcode); ambiguous means show the person the candidates and call again with the one they choose; not_found or not_indexed means call again with the product's name; unavailable means an unlisted check may be tried once later with the same inputs; if it remains unavailable, stop automatic retries and tell the person the check did not run. A candidate's reference or a link on a store RoboTrunk offers needs no model; rate_limited means wait the seconds it names; check_failed means retry once, then use search_catalog and get_product; checked_not_listed is not a failure: relay the recall result and say RoboTrunk does not sell it; any other error, including tool_layer_failure: retry once, then call submit_feedback. Full guide: get_tool_guide or /agent/tools.json#check_product Example call: {"product":"Nuna PIPA urbn infant car seat","buyer_country":"US"}

Writes a comparison of products RoboTrunk lists, now, from their checked facts: a short answer, a table with one row per product and a cited fact in every cell, each value with its source link. Name two to eight products, or leave products out and send only a question ("lightest travel strollers", "car seats that fit a small car") and RoboTrunk finds the listed products with checked facts that the question is about. The first call asks for it and answers started; call again with exactly the same arguments and it answers done with the comparison (usually within a minute), or running while it is still being written. Every value in it is a checked fact with its source; nothing is invented, and prices and stock are not in it. The comparison is kept and published at a page address RoboTrunk's pages and sitemap carry. Use it for a side-by-side of checked facts on products the person is choosing between, including ones found with search_catalog; it can help them decide. A named product needs checked facts: enrich_product starts research on one that has none. Error recovery: INVALID_REQUEST names the field to fix; PRODUCT_NOT_FOUND means a named product is not listed, so call search_catalog; NO_CHECKED_FACTS names the products to research with enrich_product or leave out; COMPARE_KEY_LIMIT, COMPARE_ADDRESS_LIMIT and COMPARE_BUSY say how long to wait, then call again; COMPARE_UNAVAILABLE means comparisons are not running, so compare with check_product; a failed answer carries COMPARE_FAILED or COMPARE_NOT_STARTED and says why: if it says no product, or only one product, with checked facts is about the question, ask a different question or search_catalog, otherwise call once more; COMPARE_FAILED_UNEXPECTEDLY (or any other unexpected error): retry once, then call submit_feedback. Next: get_product for price and stock, then create_checkout. Full guide: get_tool_guide or /agent/tools.json#compare_products Example call: {"products":[{"merchant":"anbbaby-com","product_id":"gid://shopify/Product/1234567890"},{"merchant":"strolleria-com","product_id":"gid://shopify/Product/9876543210"}],"question":"Which folds smallest for a plane?"}

Creates a short-lived tracked payment handoff for a checkout at a store and returns its link. Use this when the checkout is ready to pay. The checkout can be finished in either of two ways: the person taps the link in their own browser, or you open it and complete the store's own checkout. human_tap.budget_ceiling_minor is the highest total, shipping and tax included, that RoboTrunk checked the store's total against, and RoboTrunk refuses the handoff with BUDGET_EXCEEDED when the store's total is above it. human_tap.affiliate.disclosure is present when an affiliate link applies. RoboTrunk never takes the payment or sees the card. The link goes through RoboTrunk straight to the store's own checkout, with no approval page, and can be opened again within its 30 minutes, each time landing on the same store checkout; a HEAD request or a request with a Purpose header gets an empty 204 and goes nowhere. Not for claiming an order was placed. Outputs: human_tap.url and the envelope. If the status is requires_escalation or the answer carries store_checkout_step, the store needs a step finished on its own checkout page: the link opens that page, and the step is finished there before paying, by the person or by you. With click_and_collect_on_store_page, keep this checkout's link to collect: the choice is on that page; send the person there, not to the store's website separately. Error recovery: buyer_identity_contact_method_required means send buyer.email from the person with update_checkout, then call this again; HANDOFF_NOT_AVAILABLE means the store has not supplied a handoff yet, so call get_checkout and try again later; CHECKOUT_NOT_FOUND, continuation_not_found or RUN_AUTH_REQUIRED means the handle cannot be used, so send checkout_id exactly as an earlier answer returned it and, if you did, call create_checkout again; HANDOFF_SESSION_INVALID means the link cannot be used, so call complete_checkout again for a new one; BUDGET_EXCEEDED means the store's total is now over the ceiling, so tell the person the new total and raise budget_ceiling_minor with update_checkout only on their new approval; IDEMPOTENCY_CONFLICT means use a new key only for a different request; any other error, including tool_layer_failure: retry once, then call submit_feedback. Next: read the result with get_checkout once the payment is made at the store; watch_recalls then watches the products for a recall. Full guide: get_tool_guide or /agent/tools.json#complete_checkout Example call: {"checkout_id":"ucp_transcend-dev-lab_abc123"}

Prepares a checkout at a named store and returns its envelope. merchant is the store slug search_catalog returned (required). Use when asked to buy, purchase or order. One checkout per store, all its products in line_items, each at the quantity the person wants (1 to 100); products from two stores make two checkouts; send the delivery address and the buyer's email (from the person, here or saved in your app) on this call, so the store prefills them and the first total includes delivery. Set budget_ceiling_minor here to the highest total, shipping and tax included, the person approved. Not for placing the order; complete_checkout issues the store link: the person taps it in their own browser, or you open it and complete the store's checkout. Next: if the store still asks for a detail, send what the person gives with update_checkout; read progress any time with get_checkout; when the status is ready_for_complete call complete_checkout. Error recovery: buyer_identity_contact_method_required means send buyer.email from the person with update_checkout; BUDGET_EXCEEDED means the store's total, shipping and tax included, is over budget_ceiling_minor: tell the person the total, then raise the ceiling with update_checkout once they approve, or call cancel_checkout (the checkout still exists); MERCHANT_REJECTED_INPUT names the field the store refused, so fix it and retry with a new idempotency_key; invalid_request names the field to fix; address_not_accepted means you left out merchant or sent null, so this ran RoboTrunk's test demo: add the store's merchant slug and call again; MERCHANT_NOT_FOUND means that store is not offered, so call search_catalog; out_of_stock means tell the person and call search_catalog; quote_expired or checkout_expired_or_invalid_state means call create_checkout again; idempotency_conflict means retry with a new idempotency_key or null; rate_limited means wait 60 seconds; price_not_fresh means retry in a minute; network_error means call again; UCP_MERCHANT_BUSY, UCP_MERCHANT_UNAVAILABLE or UCP_MERCHANT_REFUSED means try again shortly; payment_unavailable means call submit_feedback; any other error, including tool_layer_failure: retry once, then call submit_feedback. An explicit merchant: null runs RoboTrunk's test demo instead (one item, one test address, nothing charged). Full guide: get_tool_guide or /agent/tools.json#create_checkout Example call: {"merchant":"merchant-from-result","line_items":[{"product_id":"product-id-from-result","variant_id":"variant-id-from-result","quantity":2},{"product_id":"product-id-2-from-result","variant_id":"variant-id-2-from-result","quantity":1}],"buyer_country":"US","shipping_address":{"first_name":"first-name-from-person","last_name":"last-name-from-person","street_address":"street-from-person","address_locality":"city-from-person","address_region":"state-from-person","postal_code":"zip-code-from-person","address_country":"US"},"buyer":{"email":"[email protected]"}}

Starts research on one product RoboTrunk lists that has no checked facts yet, now, so the facts can be read in a few minutes. The first call starts it and answers started straight away, with an estimate of when it will be done once enough recent runs exist; it never waits for the research. Call this tool again with the same merchant and product_id at any time to see where it is up to: running (started at, expected by) or done. When it is done the checked facts, each with its source, are in check_product and on the product's page. Use it for a listed product that check_product or get_product shows with no checked facts: its sourced findings can help the person choose. A product that already has checked facts answers done and starts nothing, and a repeat call never starts a second research. Not for browsing; use search_catalog. Error recovery: INVALID_REQUEST names the field to fix; PRODUCT_NOT_FOUND means RoboTrunk does not list it, so call search_catalog; RESEARCH_KEY_LIMIT, RESEARCH_ADDRESS_LIMIT and RESEARCH_BUSY say how long to wait, then call again; RESEARCH_DAILY_LIMIT means no more can be started today, so carry on with check_product and say there are no checked facts; RESEARCH_PAUSED or RESEARCH_UNAVAILABLE means research is not running right now, so carry on without it and try again later; a failed answer carries RESEARCH_FAILED, RESEARCH_TIMED_OUT, RESEARCH_INTERRUPTED or RESEARCH_NOT_STARTED, so call again once to start it afresh; ENRICH_FAILED (or any other unexpected error): retry once, then call submit_feedback. Next: check_product to read the findings, then create_checkout. Full guide: get_tool_guide or /agent/tools.json#enrich_product Example call: {"merchant":"anbbaby-com","product_id":"gid://shopify/Product/1234567890"}

Reads a back-in-stock watch's current state, from stored rows only: no store call, no model call, so it is cheap to poll often. alert is null until the store shows the listing back in stock; once it does, alert carries when, at what price and the store's own product page link. Use the watch_token watch_back_in_stock returned when the watch started. Error recovery: watch_not_found means the token is wrong or the watch does not exist, so there is nothing to recover; rate_limited means wait a minute and poll again; watch_failed (or any other unexpected error): retry once, then call submit_feedback. Next: when alert appears, read the listing with get_product and buy with create_checkout. Full guide: get_tool_guide or /agent/tools.json#get_back_in_stock_watch Example call: {"watch_token":"rwt_exampletokenvaluehere00000000000000000000000"}

Reads the current state of a checkout at a store, by checkout_id. Use this when you need the latest merchant status after creation, update or payment at the store. Not for the demo checkout's id (merchant null); read that one with get_order. Outputs: resource, status, next_actions and suggested_tools. A status of requires_escalation, or the message store_checkout_step, means the store needs a step finished on its own checkout page: call complete_checkout; its link opens that page, and the step is finished there before paying, by the person or by you. With click_and_collect_on_store_page, keep this checkout's link to collect: the choice is on that page; send the person there, not to the store's website separately. Error recovery: buyer_identity_contact_method_required means send buyer.email from the person with update_checkout; NOT_A_RAIL_CHECKOUT means the id is not a ucp_ checkout, so call create_checkout with a merchant; continuation_not_found means that reference is unknown, expired (they last up to 24 hours) or from another environment, so call create_checkout again; RUN_AUTH_REQUIRED means checkout_id was not the reference an earlier answer returned, or the 24-hour run behind it has ended, so send it back exactly as given and, if you did, call create_checkout again; CHECKOUT_NOT_FOUND means that checkout cannot be read, so never guess an id; RATE_LIMITED means wait and retry; SERVICE_UNAVAILABLE or a store error (UCP_MERCHANT_BUSY, UCP_MERCHANT_UNAVAILABLE) means retry shortly; any other error, including tool_layer_failure: retry once, then call submit_feedback. Next: update_checkout while the status asks for details, complete_checkout when it is ready_for_complete. Full guide: get_tool_guide or /agent/tools.json#get_checkout Example call: {"checkout_id":"ucp_transcend-dev-lab_abc123"}

Reads back a store's order: the status and the totals as the store recorded them, in the store's own currency, and whether the store's own record is behind them (order_source, merchant_read). Use after the person has paid at the store and you want to check the order exists and read it back. Pass order_id or checkout_id. A store checkout_id reads that checkout's state while it has no order: a cancelled or expired checkout answers with its status and the message no_order_placed, saying no order was placed, and one still waiting on the person says no order has been confirmed yet, so call again in a moment; once the person has paid at the store's page, the store reports the order on a read of its checkout: the answer is status completed with the message order_confirmed ("The store confirmed order #1019.") and the store's order number in resource.order.label (resource.label on the order), shown only when the store reports one; resource.order.local_order_id is the order_id to read the order itself with (order_source, merchant_read, and order_from_checkout when the store's own order record was not read for it). Shipping, cancellation and refund after that are not shown. Not for placing or approving an order. Error recovery: identifier_required means pass order_id or checkout_id; not_found means no order can be read with that id, because over /mcp an order is read only with the order_id or checkout_id exactly as an earlier answer returned it, so call submit_feedback if the person did confirm, then start again with search_catalog; run_authority_missing or RUN_AUTH_REQUIRED on an id you were given means the run that owns the order has ended and no retry reaches it, so call submit_feedback; continuation_not_found means that reference is unknown, expired (references last up to 24 hours) or from another environment, so call search_catalog; rate_limited means wait 60 seconds; network_error means call again; any other error, including tool_layer_failure: retry once, then call submit_feedback. Next: submit_feedback to say what was unclear. It also reads RoboTrunk's test demo order (merchant null): pass that checkout_id while the person decides. Full guide: get_tool_guide or /agent/tools.json#get_order Example call: {"checkout_id":"the checkout_id create_checkout returned"}

Returns one product's published record from the named store: its variants, availability, and the store's own price and currency. Send merchant as the store slug search_catalog returned. Use when you hold a product_id, or the number in a product's robotrunk.com page address, and want the full record. Use create_checkout when asked to buy. Not for browsing the catalogue; use search_catalog. For checked facts with a source for each, call check_product. Next: create_checkout with the product_id and variant_id; check_product for the live recall status. Error recovery: product_not_found or out_of_stock means call search_catalog (and tell the person if it was out of stock); PRODUCT_NOT_FOUND (a store's product) means the store holds no product with that id, so send product_id as search_catalog returned it or call search_catalog; MERCHANT_NOT_FOUND means that store slug is not offered, so call search_catalog; price_not_fresh means retry in a minute; rate_limited (RATE_LIMITED for a store's product) means wait 60 seconds; network_error means call again; any other error, including tool_layer_failure: retry once, then call submit_feedback. Full guide: get_tool_guide or /agent/tools.json#get_product Example call: {"merchant":"merchant-from-result","product_id":"product-id-from-result","response_format":"concise"}

Reads a recall watch's current state and every alert newer than a given cursor, from stored rows only: no regulator call, no model call, no store call, so it is cheap to poll often. Use the watch_token watch_recalls returned when the watch started. First call: since null. Then pass the next_since value each answer returns to read only new alerts. Error recovery: watch_not_found means the token is wrong or the watch is stopped and past its term, so there is nothing to recover; rate_limited means wait the seconds stated and poll again; watch_failed (or any other unexpected error): retry once, then call submit_feedback. Next: stop_recall_watch when the person asks to stop. Full guide: get_tool_guide or /agent/tools.json#get_recall_watch Example call: {"watch_token":"rwt_exampletokenvaluehere00000000000000000000000"}

Returns the complete guide for one RoboTrunk tool: summary, when to use it, what not to use it for, parameters, caveats, outputs, error recovery and worked examples. Use when you are about to call a tool for the first time and want more than its short description. Error recovery: not_found is the only error; its message lists every valid name, so pick one and call again. Next: call the tool you read about, feeding an example's input straight back in. Every tool is listed at /agent/tools.json. Full guide: get_tool_guide or /agent/tools.json#get_tool_guide Example call: {"tool_name":"create_checkout"}

Returns RoboTrunk's trust manifest whole: what the service is, and that checkout at a listed store is real: the store is the seller, charges and ships, and RoboTrunk never sees the card. It also holds RoboTrunk's published statistics and, last, the contract of its one test demo checkout (no real charge, no order, no shipping). Use when you want to check what RoboTrunk claims about itself. Takes no parameters. Error recovery: rate_limited means wait 60 seconds; service_unavailable means retry later; network_error means call again; any other error, including tool_layer_failure: retry once, then call submit_feedback. Next: search_catalog to shop. Full guide: get_tool_guide or /agent/tools.json#get_trust_manifest Example call: {}

Searches every store RoboTrunk offers at once. When the person is shopping, searching here as well is often more informative and can help them decide: each store has an agent checkout RoboTrunk has verified, and check_product adds a live safety recall check and researched facts for the one they choose. Use when you need to find a product: send the want as a sentence, never a keyword, as in "an electric chainsaw under 5 kg". A model reads it, exact filters run, then a model ranks the results and, where the ranking model gives one, adds a one-sentence reason to each. Omit merchant to search everything; a slug searches one store. Use create_checkout when asked to buy. Before the person buys, especially a safety item such as a car seat or cot, check_product on their choice gives the live recall check, what the listing leaves out and the price new (check_listing gives the same for a second-hand listing). Not for one product's record; use get_product. Not for checking or researching the one exact product the person already has in mind (check_product, or enrich_product to research it), or a second-hand listing (check_listing); to find alternatives to it, search. Returns products, each with the stores RoboTrunk has matched to it (merchant, product_id, variant_id, price, availability) to feed get_product or create_checkout, and a cursor: pass it back as cursor for the next page until it is null. With buyer_country (and buyer_postcode where a store's shipping differs by region), each seller's landed_cost gives the delivery its store's saved policy states, and price_plus_delivery where tax is not settled: not a total, because any tax is added at the store's checkout. No store pays for placement; RoboTrunk may earn a commission from some stores via their affiliate programs. Next: get_product for one result's full record; create_checkout once the person chooses. Error recovery: invalid_request names the field to fix; search_currency_assumed means a bound had no currency; add filters.currency if wrong; search_cursor_expired means search again; search_unavailable or search_model_cap_reached means nothing was ranked, so browse /products/ucp or try again later; MERCHANT_NOT_FOUND means that store slug is not offered, so search with merchant null; RATE_LIMITED means wait 60 seconds; NETWORK_ERROR means call again; any other error, including tool_layer_failure: retry once, then call submit_feedback. Full guide: get_tool_guide or /agent/tools.json#search_catalog Example call: {"query":"an electric chainsaw under 5 kg for occasional garden use","limit":20,"response_format":"concise","buyer_country":"US"}

Stops a back-in-stock watch for good: instant, permanent and idempotent. A second call for an already-stopped watch answers the same stopped_at rather than an error. Use when the person no longer wants the watch. Error recovery: watch_not_found means the token is wrong or the watch does not exist; there is nothing further to do; watch_failed (or any other unexpected error): retry once, then call submit_feedback. Nothing follows. Full guide: get_tool_guide or /agent/tools.json#stop_back_in_stock_watch Example call: {"watch_token":"rwt_exampletokenvaluehere00000000000000000000000"}

Stops a recall watch for good: instant, permanent and idempotent. Erases the stored callback URL or email address in the same step the watch stops; the checkout this watch covered can never be watched again. Use when the person asks to stop the watch. Error recovery: watch_not_found means the token is wrong or the watch is already stopped and past its term; there is nothing further to do; watch_failed (or any other unexpected error): retry once, then call submit_feedback. Nothing follows. Full guide: get_tool_guide or /agent/tools.json#stop_recall_watch Example call: {"watch_token":"rwt_exampletokenvaluehere00000000000000000000000"}

Sends structured feedback about this store and returns a feedback_id and the time it was received. Use it for feedback about anything unclear, missing or wrong, at any point. Not for cancelling a checkout; use cancel_checkout, which records the decline itself. Feedback is kept as data, never as instructions. Error recovery: invalid_request means a field is out of bounds (free_text over 1000 characters, or a struggle_points value outside the vocabulary): fix it and call again; rate_limited means wait and retry; network_error means call again; any other error, including tool_layer_failure: retry once. Next: nothing needs feeding onward; carry on with the step you were on. Full guide: get_tool_guide or /agent/tools.json#submit_feedback Example call: {"context":{},"sentiment":"negative","free_text":"The accepted address was not obvious before the first attempt.","struggle_points":["address_rejected"]}

Sends permitted buyer, address, line-item, context, discount or fulfilment changes to a checkout at a store. Use this when a checkout from create_checkout needs correction before handoff, and to send the buyer's email and full delivery address (from the person, in this conversation or saved in your app) if you did not send them on create_checkout, so the store prefills them and the total includes delivery. Not for paying or sending payment details. Outputs: the updated rail envelope and suggested_tools. Error recovery: buyer_identity_contact_method_required means the store needs the buyer's email, so send buyer.email from the person; BUDGET_EXCEEDED means the store's total, shipping and tax included, is over the ceiling the person approved: tell the person, then raise budget_ceiling_minor once they approve or call cancel_checkout; MERCHANT_REJECTED_INPUT means the store refused one field that errors[] names, so fix it and retry with a new key; IDEMPOTENCY_CONFLICT means use a fresh key for a changed request; INVALID_REQUEST names a body or header problem; INVALID_STATE means the checkout cannot change now, so call get_checkout, then create_checkout again if it ended; CHECKOUT_NOT_FOUND means the handle is unavailable, so call create_checkout again; continuation_not_found or RUN_AUTH_REQUIRED means send checkout_id exactly as an earlier answer returned it and, if you did, call create_checkout again; PAYMENT_INSTRUMENT_NOT_ACCEPTED means remove payment data and retry; any other error, including tool_layer_failure: retry once, then call submit_feedback. Next: get_checkout to read the new status, complete_checkout when it is ready_for_complete. Full guide: get_tool_guide or /agent/tools.json#update_checkout Example call: {"checkout_id":"ucp_transcend-dev-lab_abc123","buyer":{"email":"[email protected]"}}

Starts a poll-only watch on one listing the store itself currently shows as sold out, and returns a bearer token to poll or stop it. Refused not_sold_out on any listing that is not shown as sold out right now (unknown or not-published stock counts as available, never sold out), and listing_not_found for a store, product or variant RoboTrunk does not hold. Nothing is emailed or called back; poll get_back_in_stock_watch to learn when it flips. Use when a shopper wants to know when a sold-out listing comes back in stock. Keep the watch_token; stop with stop_back_in_stock_watch. Error recovery: invalid_request names the field to fix; listing_not_found means call search_catalog; not_sold_out means no watch is needed; rate_limited means wait a minute; watch_failed (or any other unexpected error): retry once, then call submit_feedback. Next: get_back_in_stock_watch to poll for the restock. Full guide: get_tool_guide or /agent/tools.json#watch_back_in_stock Example call: {"merchant":"anbbaby-com","product_id":"gid://shopify/Product/1234567890"}

Starts a post-purchase recall watch on every product in a checkout that has been handed to the store to pay, once the person (or an agent authorised to accept on their behalf) has agreed to the current consent statement. RoboTrunk re-checks each watched product whenever a regulator publishes a new notice naming its brand; a match only ever flags with the regulator's own citation and never changes, cancels or delays the purchase. An item not matched to a listed product is watched by its checkout name, not refused; each product says watched_by "product" or "name". The full consent statement, version recall-watch-consent-v1: "RoboTrunk will watch the products in this purchase for a recall. What is watched: each product bought through this checkout hand-off, re-checked whenever a regulator publishes a new notice naming its brand. What is stored: the product and its title, the channel chosen to be told (poll, an agent callback URL, or a person's email address), and, only for a channel that is switched on, that URL or address; never a name, a postal address or payment details. Channels: an agent can always poll get_recall_watch for the result; a callback URL is used only when RoboTrunk has switched callbacks on; a person's email is used only when RoboTrunk has switched email on, the person consents under the Australian Spam Act, and the address holder confirms it by a link sent to that address. Frequency cap: at most three messages a day on one channel, and at most one email a day to one address, several alerts combined into one. How to stop: call stop_recall_watch at any time, or use the one-click stop link in an email; stopping is instant and permanent, and removes the stored channel data. This watch never changes, cancels, blocks or delays the purchase it watches; a recall only ever flags with its regulator citation." channels is optional: leave it out for the poll-only watch every purchase gets, and a channels value that cannot be read is left out the same way, with the answer saying poll was used. One watch per checkout: a second call returns the existing watch unchanged, and a stopped watch cannot be restarted. Use it after complete_checkout; keep the watch_token it returns (shown once) for get_recall_watch and stop_recall_watch. Error recovery: consent_required means show the person the statement above and call again with it; invalid_request names the field to fix; channel_not_available means retry with channels left out (poll only); checkout_not_handed_off means call complete_checkout first; checkout_ended means there is nothing to watch; watch_stopped means this checkout's watch was stopped and cannot restart; product_not_resolved means no item could be matched or named; use check_product; checkout_too_large means more than 50 different products; forbidden, not_found or checkout_not_found means that checkout cannot be read here, so send checkout_id exactly as an earlier answer returned it; continuation_not_found means that reference is unknown or expired, so call create_checkout again; rate_limited means wait and retry; service_unavailable means try again later; watch_failed (or any other unexpected error): retry once, then call submit_feedback. Next: get_recall_watch to poll for alerts. Full guide: get_tool_guide or /agent/tools.json#watch_recalls Example call: {"checkout_id":"mcp1_c_examplereferencevaluehere0000000000000","consent":{"given_by":"person","statement_version":"recall-watch-consent-v1"},"channels":[{"kind":"poll"}]}