Browse, price, configure and order custom-made blinds for South African windows. Instant ZAR pricing, cart, checkout and payment via Yoco or Ozow EFT. No authentication required.
Scored across 26 tools
Core cart, checkout, order, product, and pricing tools are mostly distinct, but search_catalog, lookup_catalog, and legacy search_products overlap heavily. Legacy create_order and submit_enquiry also duplicate parts of the open UCP cart/checkout flow. The descriptions label preferred versus legacy paths, so an agent can recover, but selection is not fully clean.
Tool names are consistently snake_case and mostly follow a verb_noun pattern such as create_cart, get_order, update_checkout, and request_price_match. Minor deviations like lookup_catalog and noun-heavy get_ar_visualizer_url/get_whatsapp_handoff are still readable and predictable.
At 26 tools, the surface is above the well-scoped range for a single custom-blinds shop, especially because legacy catalog and order tools duplicate newer paths. The specialized support tools are useful, but several do not earn a distinct place in the core purchase flow.
The set covers catalog discovery, product details, colour stock, pricing, configuration, cart management, checkout, payment links, order status, delivery estimates, payment methods, recommendations, visualizer, WhatsApp handoff, price match, and swatches. Minor gaps remain around order cancellation/refunds/returns and listing or updating confirmed orders, but agents can reasonably route those through human support.
Permanently delete a cart by cart_id. Use when the customer abandons the session or wants to start over. Has no effect on any checkout or paid order already created from this cart. Irreversible, create a new cart to restart.
| Name | Required | Description | Default |
|---|---|---|---|
| cart_id | Yes |
| Name | Required | Description |
|---|---|---|
| cart_id | Yes | |
| cancelled | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true, and the description builds on that by specifying what is NOT destroyed (existing checkouts and paid orders), that the action is irreversible, and the recovery path (create a new cart). That is exactly the extra context annotations cannot carry.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Four short sentences, front-loaded with the action, then trigger, then side-effect boundary, then irreversibility. Nothing is redundant with the annotations or schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-param mutation with an output schema present, the description covers what is destroyed, what is spared, irreversibility, and the restart path. No further information is needed to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% for the single param, and the description only names cart_id without adding format, source, or validity guidance (e.g. whether it accepts an abandoned or already-cancelled cart id). Minimum viable given one obvious identifier.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Permanently delete a cart by cart_id') plus the key scope constraint that it does not touch checkouts or paid orders, which separates it from cancel_checkout and update_cart. An agent can choose between this and its siblings without opening a schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an explicit trigger condition: customer abandons the session or wants to start over. It does not name the alternative tool for the non-destructive case (update_cart for edits, or indeed create_cart for restart), so the routing is clear but not fully enumerated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Abort an unpaid checkout and release its checkout_id. Use if the customer changes their mind after create_checkout but before completing payment. Has no effect on orders already confirmed by webhook. To restart, create a new cart and checkout from scratch.
| Name | Required | Description | Default |
|---|---|---|---|
| checkout_id | Yes |
| Name | Required | Description |
|---|---|---|
| status | Yes | |
| checkout_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true and readOnlyHint=false, and the description adds real context beyond them: the tool only bites on unpaid checkouts, confirmed orders are untouched, and the checkout_id is invalidated. It stops short of saying what an error looks like if the checkout is already completed or expired, or whether repeated calls are safe.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Four short sentences, action first, then the valid window, then the exclusions, then the recovery path. Every sentence carries distinct information an agent needs.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need no explanation, and annotations cover the destructiveness profile. The lifecycle framing is complete; only edge-case failure behavior (already completed, already cancelled, unknown id) is left unstated.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter has 0% schema description coverage, so the description must carry the load. 'Release its checkout_id' tells the agent the argument is the identifier returned by create_checkout and that it is consumed by the call, but adds no format or sourcing detail beyond that.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource ('Abort an unpaid checkout') and the effect ('release its checkout_id'), which is far more informative than a restated name. It never explicitly distinguishes itself from the closely-related sibling cancel_cart, leaving the agent to infer cart-vs-checkout scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an explicit trigger ('customer changes their mind after create_checkout but before completing payment'), an explicit non-trigger ('has no effect on orders already confirmed by webhook'), and the recovery path ('create a new cart and checkout from scratch'). The lifecycle window in which the tool is valid is unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Verify whether a specific colour is available before configure_product. Returns in_stock boolean, expected_restock_date if out of stock, and up to 5 alternative in-stock colours ordered by similarity. Call this when a customer requests a named colour or when you want to prevent a configure_product failure due to an out-of-stock selection.
| Name | Required | Description | Default |
|---|---|---|---|
| product_id | Yes | ||
| colour_name | Yes |
| Name | Required | Description |
|---|---|---|
| found | No | |
| colour | No | |
| message | No | |
| in_stock | Yes | |
| product_id | No | |
| expected_restock | No | |
| matching_colours | No | |
| available_colours | No | |
| exact_colour_match | No | |
| requires_exact_colour_selection | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already establishes that this is a safe read operation. The description adds useful behavioral context by explaining the stock check outcome, restock date, and alternatives, though it does not discuss permissions or limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded, efficient, and every sentence supports selection or invocation. It is appropriately sized for a simple two-parameter lookup tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has an output schema and readOnly annotation, and the description supplies clear usage context and return behavior. The main gap is that the two required input parameters remain semantically thin in both the schema and description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must carry parameter meaning. It mentions colour availability, but does not explain product_id or give any format or interpretation guidance for colour_name beyond the general idea of a named colour.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: verify whether a specific colour is available. It also explicitly names configure_product as the related sibling, making the tool's role easy to distinguish.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives clear when-to-use guidance: call it when a customer requests a named colour or to prevent a configure_product failure from an out-of-stock selection. This directly ties usage to an alternative workflow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a Yoco card or Ozow instant-EFT payment link; this does NOT complete payment. Rejects cancelled checkouts and rechecks stock and totals first. An atomic claim prevents competing gateway calls. Returns payment_url or null plus status and message; cloud callers may be held. Retain a successful URL: repeat calls return payment_pending with no URL. Gateway failures raise an error, send no payment-link email and require team review rather than an automatic retry. Poll get_order with customer_email for payment status.
| Name | Required | Description | Default |
|---|---|---|---|
| checkout_id | Yes | ||
| payment_method | No | Overrides any value set in create_checkout/update_checkout |
| Name | Required | Description |
|---|---|---|
| ap2 | No | |
| items | No | |
| status | Yes | |
| message | Yes | |
| currency | No | |
| customer | No | |
| next_step | No | |
| total_zar | No | |
| item_count | No | |
| checkout_id | Yes | |
| payment_url | Yes | |
| payment_method | No | |
| provider_reference | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Goes well beyond the annotations by disclosing the atomic claim that blocks competing gateway calls, the non-obvious idempotency behavior ('repeat calls return payment_pending with no URL'), the requirement to retain a successful URL, and the failure path (error raised, no payment-link email, manual team review instead of retry). These are exactly the traits an agent cannot infer from readOnlyHint/destructiveHint.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Dense but disciplined: purpose is front-loaded, then constraints, then failure behavior, then the follow-up pointer. Every sentence carries distinct information, though the six-sentence block is heavy enough that structure (e.g., grouping into when-to-use vs. behavior) would aid scanning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Complete for a mutation tool with two parameters: it covers preconditions (stock/totals recheck, cancelled checkout rejection), concurrency safety, return expectations, failure handling, and the correct next step. With an output schema present, it does not need to detail return shapes.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is only 50%: payment_method is documented and the description adds meaning by naming the two gateways (Yoco card, Ozow instant-EFT), but the required checkout_id is described nowhere in either the schema or the description. Partial compensation, not full.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Generate a Yoco card or Ozow instant-EFT payment link') and immediately disambiguates with 'this does NOT complete payment'. An agent can tell this apart from get_payment_methods or get_checkout without opening a schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives clear operational context: rejects cancelled checkouts, rechecks stock/totals first, and directs the agent to 'Poll get_order with customer_email for payment status' as the follow-up path. It also warns against automatic retry after gateway failure. It stops short of explicitly contrasting with create_checkout/update_checkout beyond the schema note on payment_method.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Lock in a full blind specification: product, dimensions, colour, and mount type (inside recess or outside face-fix). Validates that the colour exists and is in stock, then prices the blind. Returns a configuration summary to pass directly into create_cart. Call check_colour_stock first if availability is uncertain.
| Name | Required | Description | Default |
|---|---|---|---|
| colour | Yes | Colour name (must match available colours) | |
| finish | No | Optional finish for aluminium venetians | |
| no_drill | No | Optional. true for the no-drill option (tension brackets, inside the frame, max 2000mm wide; 1500mm on 25mm venetians). Adds the R65 no-drill kit per blind. Offered on indoor roller blinds, including value rollers, and 25mm aluminium or aluwood venetians. Dedicated no-drill products already include the kit. | |
| province | No | Optional. Customer's South African province or city. Garden Route locations get Duncan's direct contact; other locations get the online shop contact. | |
| quantity | No | Number of blinds (default 1) | |
| width_mm | Yes | Width in millimetres | |
| height_mm | Yes | Height/drop in millimetres | |
| mount_type | Yes | Use inside (recess) or outside (face-fix); handler requires a nonempty value | |
| product_id | Yes | product_id from search_catalog or lookup_catalog |
| Name | Required | Description |
|---|---|---|
| colour | Yes | |
| finish | No | |
| limits | No | |
| contact | No | |
| summary | No | |
| currency | Yes | |
| delivery | No | |
| in_stock | No | |
| quantity | Yes | |
| width_mm | Yes | |
| height_mm | Yes | |
| lead_time | No | |
| next_step | No | |
| price_zar | No | |
| mount_type | Yes | |
| product_id | Yes | |
| product_name | No | |
| vat_included | No | |
| unit_price_zar | Yes | |
| total_price_zar | Yes | |
| effective_width_mm | No | |
| effective_height_mm | No | |
| minimum_charge_applied | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the core behavior beyond the readOnlyHint annotation: it validates colour existence and stock, prices the blind, and returns a summary rather than creating a cart. It also clarifies sequencing with check_colour_stock and create_cart.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The definition is four tight sentences with the purpose and key constraint front-loaded. Every sentence adds useful routing, validation, or handoff information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given full schema coverage, an output schema, and readOnlyHint annotations, the description supplies the missing operational context: validation scope, pricing behavior, stock pre-check, and downstream create_cart handoff. Nothing essential for correct invocation is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters including mount_type, colour, dimensions, and optional no-drill details. The description reinforces the main required fields but does not add substantial parameter semantics beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb with a clear resource: it assembles and prices a full blind specification. It distinguishes the tool from sibling cart and catalogue tools by naming the exact inputs, validation step, and output handoff.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly says what to do with the result: pass the configuration summary into create_cart. It also gives a concrete prerequisite path by directing the agent to check_colour_stock first when availability is uncertain.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Start the open UCP purchase flow, no auth needed. Creates a cart session and returns a cart_id (24-hour TTL). Optionally seed with pre-configured blind items and customer details. Next step: update_cart to add items, then create_checkout → complete_checkout to mint the payment link.
| Name | Required | Description | Default |
|---|---|---|---|
| items | No | Optional configured items; all submitted prices are ignored | |
| customer | No |
| Name | Required | Description |
|---|---|---|
| items | Yes | |
| cart_id | Yes | |
| currency | Yes | |
| customer | Yes | |
| total_zar | Yes | |
| created_at | Yes | |
| expires_at | Yes | |
| item_count | Yes | |
| updated_at | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=false / destructiveHint=false, so the write-safety profile is covered structurally. The description adds genuinely new behaviour: no authentication required, the returned cart_id has a 24-hour TTL, and customer details are validated later at checkout. It does not cover idempotency, what happens to a pre-existing open cart, or rate limits, which keeps it below a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight sentences: what it is and its auth posture first, then the returned handle and TTL, then the optional seeding, then the downstream workflow. Nothing is repeated from the schema and every clause carries information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
A create/mutation tool with annotations plus an output schema, so return-value shape needn't be explained — yet the description still flags the cart_id and its TTL. Auth posture and the downstream flow are covered; remaining gaps (reusing an existing cart, whether blind items are validated or rejected) are minor.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With only 50% schema description coverage the description must compensate, and it only says 'Optionally seed with pre-configured blind items and customer details' — it names both top-level parameters but adds no detail on required per-item fields (product_id, width_mm, height_mm, colour, mount_type) beyond what the nested schema documents. The schema itself is rich, so the net gain from the description is small.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource ('Creates a cart session') and its concrete output ('returns a cart_id'). It also positions itself in the purchase flow relative to update_cart, create_checkout and complete_checkout, so the agent can distinguish it from get_cart / cancel_cart siblings without opening a schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly gives the ordering ('Next step: update_cart to add items, then create_checkout → complete_checkout') and the precondition that no auth is needed, which is exactly the routing an agent needs. It stops short of a 'when not to use' rule (e.g. reuse an existing cart via get_cart instead of creating another), so it is strong but not exhaustive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Phase 1 of 2 in the purchase flow. Convert a cart (or inline items + customer) into a checkout. Customer name, email, and phone are required. Returns checkout_id. No payment link is minted yet, call complete_checkout for that. Use update_checkout to correct customer details before finalising.
| Name | Required | Description | Default |
|---|---|---|---|
| items | No | ||
| cart_id | No | Either cart_id or items required | |
| customer | No | ||
| payment_method | No | Default 'yoco' |
| Name | Required | Description |
|---|---|---|
| ap2 | No | |
| items | No | |
| status | Yes | |
| message | No | |
| currency | Yes | |
| customer | No | |
| next_step | No | |
| total_zar | Yes | |
| item_count | No | |
| checkout_id | Yes | |
| payment_url | No | |
| payment_method | No | |
| provider_reference | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Adds real context beyond the annotations: it discloses the return value (checkout_id), that no payment link exists yet, and that customer details are validated before creation. It does not address the destructiveHint=true flag at all — there is no mention of whether a repeat call creates a duplicate checkout, or that an unwanted one can be undone via cancel_checkout.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Four short sentences, front-loaded with the phase position and the core conversion action, then the precondition, then the return value, then the alternatives. No filler and no repetition of schema text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so the one-line mention of checkout_id is enough on the return side, and the sibling routing covers the workflow. The only real gap is mutation safety: a newly created checkout's reversibility/cancellation path is never mentioned despite destructiveHint=true.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 50% schema description coverage, the description does useful work by spelling out the mutually exclusive cart_id vs items+customer paths and the required customer fields. But it says nothing about payment_method (default yoco), the per-item required attributes, or quantity defaults, so half the parameter surface is still carried only by the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ("Convert a cart ... into a checkout") and frames it positionally as "Phase 1 of 2 in the purchase flow". It names the sibling that finishes the job (complete_checkout) and the one that amends it (update_checkout), so the tool is distinguishable without opening a schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit routing: use this to create, use complete_checkout to mint the payment link, use update_checkout to fix customer details before finalising. It also states the hard precondition (name, email, phone required) rather than leaving it to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Legacy auth-required tool, prefer the open UCP flow (create_cart → create_checkout → complete_checkout) which needs no credentials. Use create_order only if you hold a Bearer token and want a single-call path to a payment link. All item prices are re-verified server-side against the live pricing engine, agent-supplied prices are ignored. Returns a Yoco or Ozow payment_url.
| Name | Required | Description | Default |
|---|---|---|---|
| items | Yes | Array of configured blind items | |
| customer_city | No | Delivery city | |
| customer_name | Yes | Customer full name | |
| customer_email | Yes | Customer email address | |
| customer_phone | Yes | Customer phone number | |
| payment_method | No | Yoco card or Ozow instant EFT | yoco |
| customer_address | No | Delivery address |
| Name | Required | Description |
|---|---|---|
| ap2 | No | |
| items | No | |
| status | Yes | |
| message | Yes | |
| currency | No | |
| customer | No | |
| next_step | No | |
| total_zar | No | |
| item_count | No | |
| checkout_id | Yes | |
| payment_url | Yes | |
| payment_method | No | |
| order_reference | Yes | |
| provider_reference | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Goes well beyond the annotations by disclosing that this path requires a Bearer token and that all item prices are re-verified server-side so agent-supplied prices are ignored — a critical behavior for an LLM that might invent prices. It does not state idempotency or what happens to a partially-created order on failure, which matters given destructiveHint=true.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with the routing decision, then the credential requirement, then the price-integrity caveat. No filler and the most decision-relevant information comes first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers routing, auth, price verification, and the return artifact; the output schema exists so return details needn't be spelled out. Minor gap: for a tool flagged destructiveHint=true, nothing is said about irreversibility or error handling once an order is placed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3, but the description adds real semantics the schema cannot: the unit_price_zar/total_price_zar fields the agent can supply are silently overridden by the pricing engine. It also names the payment_url return tied to the yoco/ozow enum.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('create_order', single-call path to a payment link) and explicitly distinguishes itself from the sibling flow create_cart → create_checkout → complete_checkout. An agent can tell exactly which path this tool represents without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an explicit when-not ('prefer the open UCP flow … which needs no credentials') and an explicit when ('only if you hold a Bearer token and want a single-call path'), naming the alternative chain. This is exactly the routing decision an agent needs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns the link to the Custom Blinds Visualiser (See it before you buy it), pre-selected to the product when it is supported. The customer adds a photo of their window (any angle), picks a blind and colour, and previews it on their own window. A preview of colour and style, not a measuring tool. No measuring or marking. A name and WhatsApp number are needed; 2 free previews per customer. Also returns the measuring guide (mode 'measure' makes it the main url) and the list of supported products. A customer still unsure of sizes can order with best guess sizes, receive a free tape measure and confirm before production starts. Use when a customer wants to see how a blind or colour will look before ordering, or is unsure how to measure.
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | Which link goes in url: visualize (own-window visualiser), measure (measuring guide) or both (visualiser, the default). Both links are always returned. | |
| product_id | No | Optional. Pre-select a product in the visualiser (e.g. roller-blockout, double-roller-zebra, outdoor-blinds). |
| Name | Required | Description |
|---|---|---|
| url | Yes | |
| note | Yes | |
| product_id | No | |
| measure_url | Yes | |
| visualiser_url | Yes | |
| supported_products | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true, and the description adds substantial context beyond that: two free previews per customer, the requirement for a name and WhatsApp number, that both links are always returned, and that unsupported products fall back to ordering with best-guess sizes plus a free tape measure. These are real operational constraints an agent needs before calling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The purpose and scope are front-loaded in the first sentence, and the usage cue is placed last where it is most useful. It loses a point for mild redundancy, since 'not a measuring tool' and 'No measuring or marking' restate the same idea in consecutive sentences.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be described. Given a two-parameter read-only tool, the description covers the product scope, the preview limits, the contact-data prerequisite, and the measuring fallback — everything an agent would need to call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description still adds meaning the schema does not spell out plainly: 'both links are always returned' regardless of mode, and that product pre-selection only applies 'when it is supported' with the supported list returned alongside. That extra semantic lift from mode selection earns a 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource ('Returns the link to the Custom Blinds Visualiser'), states the pre-selection scope ('pre-selected to the product when it is supported'), and clarifies what the artifact is and is not ('A preview of colour and style, not a measuring tool'). An agent can distinguish this from siblings like get_product_recommendation or request_swatch without opening any schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is explicit: 'Use when a customer wants to see how a blind or colour will look before ordering, or is unsure how to measure,' and the mode enum is explained in terms of which link becomes primary. It doesn't name specific sibling tools as alternatives or state when NOT to call it, but the context is otherwise clear enough to route correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve live cart state by cart_id: full item list, calculated totals in ZAR, and any customer details stored so far. Call after update_cart to confirm changes are correct before proceeding to create_checkout. Cart expires after 24 hours of inactivity.
| Name | Required | Description | Default |
|---|---|---|---|
| cart_id | Yes |
| Name | Required | Description |
|---|---|---|
| items | Yes | |
| cart_id | Yes | |
| currency | Yes | |
| customer | Yes | |
| total_zar | Yes | |
| created_at | Yes | |
| expires_at | Yes | |
| item_count | Yes | |
| updated_at | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
readOnlyHint already declares the safety profile, but the description adds real context beyond it: totals are in ZAR, customer details may be partial ('stored so far'), and the cart expires after 24 hours of inactivity, which matters for retry/ordering logic. Return format detail is left to the output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with what is returned, then the workflow placement and the expiry constraint. No filler, nothing repeated from the name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Simple read tool with an output schema that carries return structure and annotations that carry the safety profile. The description covers the remaining gaps an agent needs: scope of the returned data, currency, expiry, and where it fits between update_cart and create_checkout.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% and the single cart_id parameter has no type/format/example documentation anywhere. The description only restates that lookup is 'by cart_id', adding no syntax (e.g. where the id comes from — create_cart output). Adequate for a self-evident identifier, but it does not compensate for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb + resource ('Retrieve live cart state by cart_id') plus the exact payload returned: item list, ZAR totals, stored customer details. It is clearly distinguishable from siblings like get_checkout and get_order, which deal with downstream states rather than the live cart.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit sequencing guidance: call after update_cart to verify changes, before create_checkout. That tells the agent where this sits in the workflow. It stops short of naming a when-not-to-use case or an alternative (e.g. use get_checkout once a checkout exists), so not a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read checkout by checkout_id. Returns persisted order status, payment_status, payment_method, items, customer, total_zar and currency. Initial order status is started, not pending. This tool does not return a previously generated payment_url: retain the complete_checkout response in caller context.
| Name | Required | Description | Default |
|---|---|---|---|
| checkout_id | Yes |
| Name | Required | Description |
|---|---|---|
| ap2 | No | |
| items | No | |
| status | Yes | |
| message | No | |
| currency | Yes | |
| customer | No | |
| next_step | No | |
| total_zar | Yes | |
| item_count | No | |
| checkout_id | Yes | |
| payment_url | No | |
| payment_method | No | |
| provider_reference | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the safety profile is covered; the description nonetheless adds genuinely non-obvious behavior. 'Initial order status is started, not pending' preempts a common misreading, and the warning that payment_url is not persisted here has real operational consequences (retain complete_checkout's response).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, front-loaded with the primary action, followed by return contents and then two caveats. Every sentence carries distinct information; nothing is repeated from the schema or annotations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the description needn't define return shape, and it still covers the key semantic gotchas (initial status, missing payment_url). It stops short of saying what happens when the checkout_id is unknown or whether cancelled/expired checkouts are still readable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% — the single property has no description at all. The description only reiterates 'by checkout_id' without adding format, source, or failure behavior for an unknown ID, so it barely compensates for the schema gap, but the lone parameter's meaning is clear from the name.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource ('Read checkout by checkout_id') and immediately enumerates the persisted fields returned. It also carves out a scope boundary against complete_checkout by noting the generated payment_url is not included, so an agent can distinguish it from sibling tools without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: the payment_url sentence implicitly routes the agent to complete_checkout for that value, and 'by checkout_id' suggests a post-create_checkout lookup. There is no explicit when-to-use vs get_cart/get_order guidance or stated preconditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Explain the lead time for a new order. Production takes 5 to 7 working days once payment clears, outside peak seasons, then courier transit of about 2 to 5 working days. Returns the ranges and a plain-language summary safe to share. Never quote a dispatch or delivery date: weather and production set them. Call this when a customer asks 'when will it arrive?'.
| Name | Required | Description | Default |
|---|---|---|---|
| order_date | No | ISO date string of the order placement date (e.g. '2026-05-18'). Defaults to today. |
| Name | Required | Description |
|---|---|---|
| summary | Yes | |
| important | Yes | |
| order_date | No | |
| production_starts | No | |
| expedited_available | No | |
| delivery_after_dispatch | Yes | |
| transit_working_days_max | Yes | |
| transit_working_days_min | Yes | |
| production_working_days_max | Yes | |
| production_working_days_min | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only disclose readOnlyHint=true, and the description adds substantially more: what the answer contains (ranges plus a shareable plain-language summary), the seasonal caveat ('outside peak seasons'), and a hard guardrail against quoting exact dispatch or delivery dates because weather and production determine them. That is real operational context an agent cannot get from the annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Four sentences, front-loaded with the substantive lead-time facts before the caveats and the call trigger. Dense and largely waste-free, though the 'plain-language summary safe to share' detail is the only clause that could be trimmed as the output schema already covers return shape.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, return values need no explanation, and the description covers the remaining burden: what is estimated, the ranges' drivers, seasonal exceptions, the guardrail on quoting dates, and the triggering scenario. Nothing an agent needs in order to call and use this correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and order_date is fully documented with an ISO example and a 'defaults to today' note. The description adds nothing about the parameter and never mentions that an order date can be supplied, so this sits at the baseline where the schema does all the work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The first sentence states a specific verb and resource ('Explain the lead time for a new order'), and the scope is disambiguated by naming the contributing stages (production, then courier transit). No sibling tool in the list does delivery estimation, so the agent can identify this immediately.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives an explicit trigger: 'Call this when a customer asks "when will it arrive?"'. It also constrains the answer ('Never quote a dispatch or delivery date'). It stops short of naming a when-not-to-use case or an alternative tool, but no sibling actually competes for this task.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve a confirmed order's status, items, and payment details by order_id. customer_email is required as soft-auth and must exactly match the order record, prevents arbitrary order lookups. Returns payment status (paid | pending | failed), production status, and dispatch date once available.
| Name | Required | Description | Default |
|---|---|---|---|
| order_id | Yes | ||
| customer_email | Yes |
| Name | Required | Description |
|---|---|---|
| items | No | |
| paid_at | No | |
| currency | Yes | |
| order_id | Yes | |
| lead_time | No | |
| total_zar | Yes | |
| order_status | No | |
| payment_status | Yes | |
| order_reference | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
It adds critical behavioral context beyond the annotations and schema, detailing that 'customer_email is required as soft-auth.' Furthermore, it explains the security mechanism that this requirement enforces ('prevents arbitrary order lookups'). It also scopes the return values, mentioning their potential future state, like 'once available.'
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The definition is highly efficient. The core function is front-loaded, and every clause is used to define a constraint (e.g., 'confirmed order's status,' 'soft-auth,' 'prevents arbitrary order lookups').
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is exhaustive. Given that an output schema exists, the description doesn't need to detail return types, but it does list all primary data points that will be returned (status, items, payment details, production status, and dispatch date), providing full context for the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Since the schema description coverage is 0%, the description must carry the full semantic load. It provides crucial information about 'customer_email' that is not in the schema: it explains that this field serves as a soft-auth mechanism and must match the order record exactly.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly defines the function using a specific verb ('Retrieve') applied to a specific resource ('confirmed order'). It informs the agent that the scope is limited to retrieving order status, items, and payment details, which is distinct from tools like `get_cart` or `get_price`.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when a confirmed order's data (like status or items) is needed. While it defines its scope ('confirmed order'), it does not explicitly state when NOT to use it, though the scope is sufficiently narrowed by this constraint to be highly effective.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List available payment processors and their capabilities. Returns Yoco (card, immediate) and Ozow (instant EFT via South African bank account). Call when the customer asks 'how can I pay?' or before presenting options. The result informs the payment_method field in create_checkout and complete_checkout.
| Name | Required | Description | Default |
|---|---|---|---|
| order_total_zar | No | Optional. For future per-handler limit filtering. |
| Name | Required | Description |
|---|---|---|
| note | Yes | |
| handlers | Yes | |
| default_currency | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds real behavioral context beyond that: what is returned (card vs. instant EFT via South African bank account) and how the output feeds create_checkout/complete_checkout. It stops short of mentioning auth or caching/rate behavior, so not a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, front-loaded with what the tool returns, then when to call it, then why it matters. Every sentence adds information an agent needs; nothing is redundant with the title or schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be re-specified, and the only parameter is optional and fully documented. Purpose, trigger, expected content, and downstream dependency are all present for a simple read-only lookup.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single optional parameter order_total_zar is not mentioned in the description, but schema description coverage is 100% and the schema itself explains it is reserved for future per-handler limit filtering. With the schema carrying the load, the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ("List available payment processors and their capabilities") and even enumerates the concrete return values, Yoco and Ozow. An agent can immediately tell this is the payment-options discovery tool and distinguish it from checkout-mutating siblings like create_checkout.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an explicit trigger ("Call when the customer asks 'how can I pay?' or before presenting options") and names the downstream tools whose payment_method field depends on the result. It provides clear usage context but no when-not conditions, which is acceptable since no sibling offers an overlapping capability.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get an exact ZAR price using product_id from search_catalog or lookup_catalog, width_mm and height_mm. Prices include VAT and delivery. Colour selects the bamboo price tier where applicable. A price is not a stock reservation: validate the exact colour and mount with configure_product before creating a cart. Failure can return success:false or a JSON-RPC validation error.
| Name | Required | Description | Default |
|---|---|---|---|
| colour | No | Optional bamboo colour for colour-specific tier pricing | |
| finish | No | Optional finish for aluminium products: Plain, Brushed, Woodgrain | |
| no_drill | No | Optional. true for the no-drill option (tension brackets, inside the frame, max 2000mm wide; 1500mm on 25mm venetians). Adds the R65 no-drill kit per blind. Offered on indoor roller blinds, including value rollers, and 25mm aluminium or aluwood venetians. Dedicated no-drill products already include the kit. | |
| province | No | Optional. Customer's South African province or city. Garden Route locations get Duncan's direct contact; other locations get the online shop contact. | |
| quantity | No | Number of blinds (default 1) | |
| width_mm | Yes | Width in millimetres (e.g. 1200) | |
| height_mm | Yes | Height/drop in millimetres (e.g. 1500) | |
| product_id | Yes | product_id from search_catalog or lookup_catalog (e.g. roller-blockout) |
| Name | Required | Description |
|---|---|---|
| finish | No | |
| limits | No | |
| contact | No | |
| currency | Yes | |
| delivery | No | |
| quantity | Yes | |
| width_mm | Yes | |
| height_mm | Yes | |
| lead_time | No | |
| next_step | No | |
| product_id | Yes | |
| product_name | No | |
| vat_included | Yes | |
| unit_price_zar | Yes | |
| total_price_zar | Yes | |
| effective_width_mm | No | |
| effective_height_mm | No | |
| minimum_charge_applied | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond readOnlyHint, it discloses that prices include VAT and delivery, that colour drives bamboo tier pricing, that the result is not a stock hold, and that failures surface as success:false or a JSON-RPC validation error. That error-shape warning is exactly the kind of behavioral context annotations cannot convey.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Four tight sentences, front-loaded with the core action and required inputs, then caveats and error modes. Nothing is padded and each sentence carries distinct information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, return values need no explanation, and the description still covers prerequisites, what the price includes, non-reservation semantics, and failure modes. An agent has everything needed to call it correctly and interpret a failure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage, the schema already documents every parameter including the colour tier and product_id provenance. The description restates the same semantics rather than adding syntax, ranges, or interaction rules beyond what is structured, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource (get an exact ZAR price) plus the required inputs and their source, so an agent can distinguish it from request_price_match or lookup_catalog without opening a schema. The currency and VAT/delivery inclusion further pin down exactly what price means.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly routes the agent: product_id must come from search_catalog or lookup_catalog, and the exact colour and mount must be validated with configure_product before creating a cart. It also flags the 'when-not' condition by stating a price is not a stock reservation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch complete details for one product by id (e.g. roller-blockout, venetian-25mm-aluwood). Returns all available colours with in-stock status, materials, features, and maximum supported dimensions. Use before configure_product to confirm a colour exists and is in stock before committing.
| Name | Required | Description | Default |
|---|---|---|---|
| product_id | Yes |
| Name | Required | Description |
|---|---|---|
| name | Yes | |
| colours | Yes | |
| category | Yes | |
| features | No | |
| materials | No | |
| product_id | Yes | |
| schema_url | No | |
| description | No | |
| product_url | Yes | |
| size_limits | No | |
| max_width_mm | No | |
| suitable_for | No | |
| max_height_mm | No | |
| installation_type | No | |
| starting_price_zar | No | |
| colour_count_in_stock | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the description doesn't need to argue safety, and instead adds the useful precondition that the returned stock flags gate a later configure_product call. It doesn't cover failure behavior (unknown id) or whether colours are ever omitted, which keeps it from a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, both load-bearing: the first defines scope and output, the second carries the usage constraint. The verb and resource are front-loaded with zero filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the description needn't enumerate return fields, yet it highlights the operationally relevant ones (in-stock colour status) that drive the configure_product decision. It is nearly complete for a single-parameter read tool; only error/not-found behavior is unaddressed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% — product_id is a bare string with no documented format. The description compensates by giving two real slug examples (roller-blockout, venetian-25mm-aluwood), which is exactly the missing format guidance an agent needs to construct a valid call. It doesn't state whether ids are case-sensitive or how to obtain one.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ("Fetch complete details for one product by id") and supplies concrete example ids, so an agent can immediately distinguish it from search_catalog, lookup_catalog, and search_products. The returned payload categories (colours, stock status, materials, features, max dimensions) further pin down what "details" means.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly names the downstream tool and condition: "Use before configure_product to confirm a colour exists and is in stock before committing." That is a real sequencing rule rather than generic advice. It stops short of naming when-not-to-use alternatives (e.g. search_products when you don't already have an id).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Translate a customer's primary concern into a product recommendation. primary_concern must be one of: blockout, heat, glare, moisture, privacy, security, automation. Optionally narrow by room (bedroom, lounge, etc.), location, budget, and aesthetic. Returns a recommended product_id with rationale, pass it to get_price or configure_product next. Security concern routes to brochure MCP (Garden Route customers only).
| Name | Required | Description | Default |
|---|---|---|---|
| room | No | ||
| location | No | ||
| aesthetic | No | ||
| max_budget_zar | No | ||
| primary_concern | Yes |
| Name | Required | Description |
|---|---|---|
| notes | No | |
| handoff | No | |
| recommendations | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish readOnlyHint=true, and the description adds real context beyond that: what comes back (product_id plus rationale), what to do with it, and a coverage limitation (security routing only for Garden Route customers). It does not contradict the read-only annotation — the tool recommends, it does not create or modify.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Four sentences, front-loaded with the core action and ending with the next-step routing — no wasted framing. Repeating the enum values is mild redundancy against the schema, but it keeps the tool callable from the description alone.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the description needn't detail return structure, yet it still summarizes the payload and the downstream handoff, which is exactly what an agent needs to chain calls. Coverage of required input, optional narrowing, and the one exceptional routing case makes this complete for a five-parameter read tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate, and it does: it lists the required concern values and names all four optional narrowing dimensions (room, location, budget, aesthetic), mapping to room, location, max_budget_zar, and aesthetic. It still gives no format or unit hints (e.g. ZAR currency is only inferable from the property name), so it falls just short of full coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb+resource ("Translate a customer's primary concern into a product recommendation") and immediately positions itself relative to siblings by naming get_price and configure_product as the natural next calls. An agent can distinguish this recommendation step from search_products or get_product without opening either schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It clearly states the trigger (a customer's primary concern) and the follow-on path (pass product_id to get_price or configure_product), plus an explicit routing exception for security concerns to the brochure MCP. The only friction is that "security" is both an accepted primary_concern value and a value that gets routed elsewhere, which leaves the agent slightly unsure whether to call this tool at all for that case.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a pre-filled WhatsApp deep link to hand the customer off to the right contact. Garden Route locations (Knysna, Plett, George, Sedgefield, etc.) route to Duncan Kane for a free in-home consultation, booked on the same WhatsApp line (+27760228410); all other South African locations route to that line too (+27760228410). It is WhatsApp only, no voice calls. Use when the customer prefers human assistance or when self-serve checkout isn't appropriate.
| Name | Required | Description | Default |
|---|---|---|---|
| message | No | Optional additional message to prefill | |
| location | No | City/suburb. Drives Duncan vs shop routing. | |
| customer_name | No | ||
| product_context | No | e.g. 'roller blockout for bedroom' |
| Name | Required | Description |
|---|---|---|
| reason | Yes | |
| recipient | Yes | |
| whatsapp_url | Yes | |
| recipient_phone | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true, and the description is consistent with that (it only generates a link, no booking is made server-side). It adds genuinely useful context beyond the annotations: WhatsApp-only channel ('no voice calls'), the hard-coded destination number, and the geography-based routing rule. It never states what the returned link looks like, though an output schema exists, so a 4 is fair.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded correctly with the core action, and the length is defensible for a routing-heavy tool. However, the routing sentence is verbose and self-undermining: it sets up a Garden Route vs. rest-of-SA distinction and then repeats the identical phone number for both branches, wasting text and creating confusion about whether routing actually differs.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present and only 4 optional parameters, the description covers the essentials: what it produces, which channel, where the customer lands, and when to reach for it. The main gap is scope outside South Africa, which is left undefined even though the routing statement is scoped to 'South African locations'.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 75%, so most parameters are already documented. The description explains how 'location' affects routing, but then undercuts that explanation by stating both branches resolve to the same number (+27760228410), which contradicts the schema's note that location 'Drives Duncan vs shop routing'. The other three parameters (message, customer_name, product_context) get no treatment at all. Baseline 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Opens with a specific verb+resource: 'Generate a pre-filled WhatsApp deep link to hand the customer off to the right contact.' The purpose is immediately unambiguous and distinguishable from the cart/checkout siblings. It stops short of naming any sibling it contrasts with, so it lands at 4 rather than 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit trigger conditions are given: 'Use when the customer prefers human assistance or when self-serve checkout isn't appropriate.' That is a clear when-to-use signal tied to the adjacent checkout tools. No explicit exclusions or named alternatives (e.g. submit_enquiry) are offered, so it is not a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Preferred structured discovery. Filter by category, partial colour name or required supported width/drop in mm. Returns results containing product_id, name, category and product_url, plus total. Width/drop filters check separate maximums, not every combination; confirm the exact pair with get_price.
| Name | Required | Description | Default |
|---|---|---|---|
| colour | No | ||
| category | No | roller | venetian | honeycomb | vertical | outdoor | |
| max_width_mm | No | ||
| max_height_mm | No |
| Name | Required | Description |
|---|---|---|
| total | Yes | |
| results | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
readOnlyHint=true already establishes the safety profile, and the description adds a genuinely useful behavioral caveat: width and height filters are evaluated as independent maximums, not as validated combinations. The return-field list adds little because an output schema already exists, and there is no mention of result limits or empty-result behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight sentences with the preferred-usage claim and the filter axes front-loaded, then the return shape, then the caveat. No wasted clauses, though the 'width/drop' terminology adds slight noise against the schema's naming.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The output schema covers return values, so omitting detail there is fine, but the description never addresses result count limits, pagination, or what happens when no products match the independent-maxima filter. For a 4-parameter discovery tool that is otherwise well explained, these are the remaining gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is only 25% (only category is described), so the description must compensate: it clarifies that colour matching is partial and that the mm parameters act as independent maxima. However, it uses the vocabulary 'width/drop' and 'required supported', which does not cleanly map onto the schema's max_width_mm / max_height_mm names, leaving ambiguity about whether these are maximums or requirements.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Names a concrete resource (catalog) and the exact filter axes (category, partial colour, width/drop in mm), and calls itself the 'preferred structured discovery' path, which hints at its place relative to search siblings. It stops short of naming search_catalog or search_products to draw a crisp boundary, so differentiation is implied rather than explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Preferred structured discovery' signals when to reach for this over the free-text search siblings, and the closing sentence explicitly routes the agent to get_price when an exact width/height pair must be confirmed. No explicit when-not conditions beyond that handoff.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Submit a price match claim when the customer has found the same blind at a lower price elsewhere. Custom Blinds matches verified South African retailer prices for identical product, dimensions, and specs. Returns a pre-filled WhatsApp link to the claims team. Not applicable to: Blinds Direct (same supplier), clearance or flash-sale prices, or out-of-stock items. Requires product_id and competitor_price_zar at minimum.
| Name | Required | Description | Default |
|---|---|---|---|
| width_mm | No | Window width in mm | |
| height_mm | No | Window height/drop in mm | |
| product_id | Yes | Product the customer wants to match (e.g. roller-blockout) | |
| customer_name | No | Customer name | |
| competitor_url | No | URL to competitor product page or quote | |
| competitor_name | No | Name of the competitor (e.g. 'Blind Empire') | |
| customer_whatsapp | No | Customer WhatsApp number for follow-up | |
| competitor_price_zar | Yes | Competitor's price in ZAR (incl. VAT) |
| Name | Required | Description |
|---|---|---|
| note | Yes | |
| message | Yes | |
| success | Yes | |
| exclusions | Yes | |
| whatsapp_url | Yes | |
| claim_summary | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare readOnlyHint=true, and the description adds meaningful context beyond that: it discloses the actual output shape (a pre-filled WhatsApp link rather than a database write), the eligibility filter the claim is validated against, and the matching criteria. It does not cover turnaround, what happens if the claim is rejected, or any rate/auth constraints, so it is strong but not exhaustive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three well-ordered sentences: purpose first, then exclusions, then requirements, with zero filler. Slightly dense in the exclusion clause, but every sentence carries distinct information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, yet the description still tells the agent the salient return value (WhatsApp link), plus eligibility rules and required inputs. For an 8-parameter, non-destructive submission tool, an agent has everything needed to decide and call correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so a baseline of 3 applies, but the description adds real value by naming the two minimum required fields and by explaining that product, dimensions, and specs must be identical for a claim to be verified — which is exactly why width_mm/height_mm exist. It stops short of describing competitor_url or customer_whatsapp usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Submit a price match claim') plus the triggering condition ('customer has found the same blind at a lower price elsewhere'). The scope is narrowed further by naming what qualifies (verified South African retailer prices, identical product/dimensions/specs), which leaves no ambiguity against sibling tools like get_price or submit_enquiry.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an explicit positive condition (customer found a lower price at another retailer), explicit exclusions ('Not applicable to: Blinds Direct, clearance or flash-sale prices, or out-of-stock items'), and the minimum prerequisites. This is textbook when/when-not guidance with no inference required.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Log up to 5 colour codes against an EXISTING order for the team (order_ref required; without it the tool returns status order_required and logs nothing). Sample swatches, not off-cuts: on orders over R8,000 the customer can ask on WhatsApp for swatches in the colours they like, for the product they are ordering; if nothing suits, full refund with no fees. Never quote a sample price or courier cost.
| Name | Required | Description | Default |
|---|---|---|---|
| suburb | No | Optional delivery suburb | |
| order_ref | Yes | The order reference the swatches ship with. Required. | |
| swatch_codes | No | Optional specific colour codes (max 5) | |
| customer_name | Yes | Customer's full name. | |
| customer_email | Yes | Customer's email address. | |
| customer_phone | Yes | Used as WhatsApp number | |
| product_interest | Yes | e.g. 'Roller Blockout' or 'Honeycomb' |
| Name | Required | Description |
|---|---|---|
| policy | No | |
| status | Yes | |
| message | Yes | |
| next_step | No | |
| order_ref | No | |
| request_id | No | |
| swatch_count | No | |
| estimated_delivery_days | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations, it discloses the important mutation behavior: it logs colour codes, fails with status order_required when order_ref is missing, logs nothing in that case, and enforces a maximum of 5 codes. It also describes the business policy around eligibility and refunds, which is valuable context for an agent handling the request.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The core action and failure mode are front-loaded, followed by the sample-vs-off-cut distinction and relevant policy constraints. The description is dense but every sentence carries operational or policy meaning, with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema and full input schema coverage, the description supplies the remaining business context an agent needs: existing-order requirement, missing-order_ref behavior, max swatches, eligibility threshold, sample/off-cut distinction, and pricing prohibitions. Nothing material appears missing for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents all parameters, including order_ref being required and swatch_codes having a maximum of 5. The description reinforces the order_ref requirement and links swatches to the product being ordered, but does not add syntax or format details beyond the structured fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a precise verb and resource: logging up to 5 colour codes against an existing order. It also distinguishes the request from off-cuts by clarifying that these are sample swatches, which is useful differentiator language in a catalogue/order toolset.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It clearly states the core precondition: order_ref is required, and without it the tool returns order_required and logs nothing. It also states eligibility (orders over R8,000) and policy exclusions (not off-cuts, never quote sample or courier prices). It does not explicitly name an alternative sibling tool, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Preferred free-text discovery. Returns results containing product_id, name, category, description, product_url and colour_count_in_stock, plus total and currency. For structured filters use lookup_catalog. Pass product_id to get_product or get_price.
| Name | Required | Description | Default |
|---|---|---|---|
| query | No | Free-text query, e.g. 'blockout' or 'venetian' |
| Name | Required | Description |
|---|---|---|
| total | Yes | |
| results | Yes | |
| currency | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, and the description adds return-field context plus follow-up routing. However, it does not disclose ranking, pagination, result limits, or optional-empty-query behavior, which would be useful for a search tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded and compact, with purpose first and alternatives/follow-ups after. The enumerated return fields are somewhat redundant given the output schema, but the overall text remains efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only search tool with a fully documented parameter and an output schema, the description covers purpose, alternative routing, and follow-up usage. It is nearly complete, though it could better distinguish itself from search_products.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the single query parameter is already documented with examples. The description reinforces that this is free-text discovery but adds no syntax, formatting, or behavior beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies a free-text discovery/search capability and lists what results contain. It explicitly distinguishes itself from lookup_catalog, but does not mention the sibling search_products, so sibling differentiation is incomplete.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives clear usage guidance: use this for free-text discovery, use lookup_catalog for structured filters, and pass product_id to get_product or get_price. The main gap is that it does not clarify when to use search_products instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Legacy discovery, retained for backward compatibility. Prefer search_catalog / lookup_catalog, then get_product. Filters by blind type, colour or maximum dimensions. Returns products with id (not product_id), name, description, features and in-stock colour count. Pass that id as product_id to get_price or configure_product.
| Name | Required | Description | Default |
|---|---|---|---|
| type | No | Blind category to filter by: roller, venetian, honeycomb, vertical, outdoor | |
| colour | No | Colour name to search for (partial match) | |
| province | No | Optional. Customer's South African province or city. Garden Route locations get Duncan's direct contact; other locations get the online shop contact. | |
| max_width_mm | No | Maximum width in millimetres the product supports | |
| max_height_mm | No | Maximum height/drop in millimetres the product supports |
| Name | Required | Description |
|---|---|---|
| total | Yes | |
| contact | No | |
| currency | No | |
| products | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so safety is covered; the description adds real value by disclosing the return shape ('id (not product_id), name, description, features and in-stock colour count') and the crucial id-mapping behaviour for get_price/configure_product. It does not mention pagination, result limits, or what an empty result means, so with an output schema present and annotations covering safety, this lands at solid but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight sentences with the legacy caveat and preferred alternatives front-loaded, then filters, then return shape and handoff. Dense but every clause carries information; only minor cost is that the return-shape sentence packs several facts.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only search tool with full schema coverage and an output schema, the description covers the remaining gaps an agent would otherwise hit: deprecation status, the correct next tool, and the id-vs-product_id naming trap. Nothing needed to call it correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents all five parameters including the province-specific contact behaviour. The description only summarises the filter set (blind type, colour, max dimensions) without adding format or syntax detail, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource (search products) plus the filtering dimensions available, and immediately distinguishes itself from siblings search_catalog, lookup_catalog and get_product by naming them as preferred. An agent knows exactly what this tool is and that it is a legacy path.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit routing: 'Legacy discovery, retained for backward compatibility. Prefer search_catalog / lookup_catalog, then get_product.' It gives both the exclusion (don't prefer this) and the ordered alternative chain, which is exactly the when/when-not guidance an agent needs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Legacy auth-required tool, prefer the open UCP flow (create_cart → create_checkout → complete_checkout) for credentialless checkout. Use submit_enquiry only when the customer wants a sales team follow-up by email rather than paying online. Requires Bearer token. Pass a configure_product output plus customer name, email, and phone. Team responds within 24 hours.
| Name | Required | Description | Default |
|---|---|---|---|
| message | Yes | Required enquiry message; at least 10 characters after trimming | |
| customer_name | Yes | Customer full name | |
| customer_email | Yes | Customer email address | |
| customer_phone | Yes | Customer phone number | |
| product_config | Yes | Product configuration from configure_product |
| Name | Required | Description |
|---|---|---|
| contact | Yes | |
| message | Yes | |
| success | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare readOnly=false and destructive=false; the description adds real behavioral context on top: legacy status, a Bearer token requirement, the 24-hour team response expectation, and the prerequisite that product_config comes from configure_product. It stops short of describing what happens on validation failure or whether duplicate enquiries are deduplicated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Four sentences, each doing distinct work: deprecation/routing, the use case, auth, and input provenance plus turnaround. The most important routing information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a five-parameter mutation with a nested object, the description covers the prerequisite tool, auth, SLA, and the alternative path; return values are covered by the existing output schema. An agent has everything needed to decide and to call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema carries the field-level detail and the baseline would be 3. The description earns a bump by disclosing provenance — that product_config must be a configure_product output — which the schema does not state.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description makes clear this submits a sales enquiry by email rather than a purchase, and it explicitly positions itself against the create_cart → create_checkout → complete_checkout flow. The verb+resource are implied by the name and reinforced by 'sales team follow-up by email', though the first sentence is routing advice rather than a direct statement of what the call does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It states when to use (customer wants email follow-up instead of paying online) and when not to use (default to the credentialless UCP flow, named step by step). This is the strongest dimension of the definition — no inference required.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Modify an open cart before checkout. op: 'add' appends items, 'remove' drops items by 0-based index, 'set' replaces the full item list, 'clear' empties the cart. Merges customer details (name, email, phone) via the customer field. Call get_cart afterwards to confirm. Cannot modify a cart that already has a checkout in progress.
| Name | Required | Description | Default |
|---|---|---|---|
| op | No | set | |
| items | No | ||
| cart_id | Yes | ||
| indices | No | Item indices to remove (0-based) when op='remove' | |
| customer | No |
| Name | Required | Description |
|---|---|---|
| items | Yes | |
| cart_id | Yes | |
| currency | Yes | |
| customer | Yes | |
| total_zar | Yes | |
| created_at | Yes | |
| expires_at | Yes | |
| item_count | Yes | |
| updated_at | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already flag this as destructive, but the description adds real value beyond them: the difference between 'set' (full replacement) and 'add'/'remove'/'clear', and the hard failure condition when a checkout is in progress. It does not mention that client-supplied prices are recalculated, but that detail lives in the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded purpose followed by a compact op-by-op breakdown, one pre-call constraint and one post-call step. Every sentence carries distinct information with no repetition of the name or schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given an output schema and destructive annotations, the description covers what an agent needs: operation semantics, a blocking precondition and a verification step. Only the price-recalculation behavior is unaddressed at the description level, and that is documented in parameter schemas.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is low (20%), and the description compensates well: it assigns meaning to each op enum value, explains that 'remove' uses 0-based item indices (matching the indices param), and describes the customer merge fields. The items array itself is left to the rich nested schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Modify an open cart before checkout') and then defines each of the four operations, so an agent can distinguish it from create_cart, get_cart and update_checkout without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an explicit follow-up step ('Call get_cart afterwards to confirm') and a clear exclusion ('Cannot modify a cart that already has a checkout in progress'). It stops short of naming the mutation siblings (update_checkout, cancel_cart) as alternatives, but the precondition and verification loop are actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update customer details or payment_method only before payment-link generation. Paid, cancelled and payment-in-progress checkouts are rejected. Concurrent state changes are detected; retrieve the latest status before retrying.
| Name | Required | Description | Default |
|---|---|---|---|
| customer | No | ||
| checkout_id | Yes | ||
| payment_method | No |
| Name | Required | Description |
|---|---|---|
| ap2 | No | |
| items | No | |
| status | Yes | |
| message | No | |
| currency | Yes | |
| customer | No | |
| next_step | No | |
| total_zar | Yes | |
| item_count | No | |
| checkout_id | Yes | |
| payment_url | No | |
| payment_method | No | |
| provider_reference | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=false and destructiveHint=true, so the write profile is known; the description adds genuinely non-structured behavior: state-based rejection rules, optimistic-concurrency detection, and a retry protocol. It does not cover permissions/auth requirements or whether omitted customer subfields are preserved or cleared.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, zero filler, with the mutability constraint front-loaded and the retry guidance last. Every clause carries actionable information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need no explanation, and the description covers the two things an agent most needs for a gated mutation: which fields are editable and which states will fail. The remaining gap is partial-update semantics and permission prerequisites.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% for the top-level parameters (checkout_id, payment_method, customer object), and the description only says 'customer details or payment_method' without clarifying which customer subfields are updatable or what yoco/ozow imply. It does confirm the two allowed update targets, which partially compensates, but leaves checkout_id format and enum meaning undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource (update checkout) plus the exact mutable surface: 'customer details or payment_method'. The lifecycle qualifier 'before payment-link generation' separates it from update_cart and from the checkout-creation siblings without naming them. Not a 5 because no sibling is named explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an explicit when ('only before payment-link generation') and an explicit when-not ('Paid, cancelled and payment-in-progress checkouts are rejected'), plus a retry procedure ('retrieve the latest status before retrying'). Missing an explicit pointer to the alternative tool (e.g. get_checkout, cancel_checkout) when the checkout is in a terminal state.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
cancel_cart1 field changedInput schema / properties / cart_id / descriptionRemoved value: -"cart_id returned by create_cart."cancel_checkout1 field changedInput schema / properties / checkout_id / descriptionRemoved value: -"checkout_id returned by create_checkout."check_colour_stock2 fields changedInput schema / properties / colour_name / descriptionRemoved value: -"Colour name to check, e.g. \"White\"."Input schema / properties / product_id / descriptionRemoved value: -"product_id from search_catalog or lookup_catalog."complete_checkout1 field changedInput schema / properties / checkout_id / descriptionRemoved value: -"checkout_id returned by create_checkout."configure_product1 field changedInput schema / properties / no_drillAdded value: +{
+ "description": "Optional. true for the no-drill option (tension brackets, inside the frame, max 2000mm wide; 1500mm on 25mm venetians). Adds the R65 no-drill kit per blind. Offered on indoor roller blinds, including value rollers, and 25mm aluminium or aluwood venetians. Dedicated no-drill products already include the kit.",
+ "type": "boolean"
+}create_cart2 fields changedInput schema / properties / customer / descriptionRemoved value: -"Optional customer details (name, email, phone, address, city)."Input schema / properties / items / items / properties / no_drillAdded value: +{
+ "description": "Optional. true for the no-drill option (tension brackets, inside the frame, max 2000mm wide; 1500mm on 25mm venetians). Adds the R65 no-drill kit per blind. Offered on indoor roller blinds, including value rollers, and 25mm aluminium or aluwood venetians. Dedicated no-drill products already include the kit.",
+ "type": "boolean"
+}create_checkout3 fields changedInput schema / properties / customer / descriptionRemoved value: -"Customer details. Name, email, mobile phone and delivery address are required; city is optional. Placeholder or test details are refused."Input schema / properties / items / descriptionRemoved value: -"Line items to buy. Required if cart_id is not given."Input schema / properties / items / items / properties / no_drillAdded value: +{
+ "description": "Optional. true for the no-drill option (tension brackets, inside the frame, max 2000mm wide; 1500mm on 25mm venetians). Adds the R65 no-drill kit per blind. Offered on indoor roller blinds, including value rollers, and 25mm aluminium or aluwood venetians. Dedicated no-drill products already include the kit.",
+ "type": "boolean"
+}create_order1 field changedInput schema / properties / items / items / properties / no_drillAdded value: +{
+ "description": "Optional. true for the no-drill option (tension brackets, inside the frame, max 2000mm wide; 1500mm on 25mm venetians). Adds the R65 no-drill kit per blind. Offered on indoor roller blinds, including value rollers, and 25mm aluminium or aluwood venetians. Dedicated no-drill products already include the kit.",
+ "type": "boolean"
+}get_cart1 field changedInput schema / properties / cart_id / descriptionRemoved value: -"cart_id returned by create_cart."get_checkout1 field changedInput schema / properties / checkout_id / descriptionRemoved value: -"checkout_id returned by create_checkout."get_order2 fields changedInput schema / properties / customer_email / descriptionRemoved value: -"Email address on the order. Must match the order record (not case-sensitive)."Input schema / properties / order_id / descriptionRemoved value: -"Order reference: the checkout_id returned by create_checkout."get_price1 field changedInput schema / properties / no_drillAdded value: +{
+ "description": "Optional. true for the no-drill option (tension brackets, inside the frame, max 2000mm wide; 1500mm on 25mm venetians). Adds the R65 no-drill kit per blind. Offered on indoor roller blinds, including value rollers, and 25mm aluminium or aluwood venetians. Dedicated no-drill products already include the kit.",
+ "type": "boolean"
+}get_product1 field changedInput schema / properties / product_id / descriptionRemoved value: -"product_id from search_catalog or lookup_catalog."get_product_recommendation5 fields changedInput schema / properties / aesthetic / descriptionRemoved value: -"Optional style preference. Noted in the reply."Input schema / properties / location / descriptionRemoved value: -"Optional customer city or suburb. Accepted but not currently used."Input schema / properties / max_budget_zar / descriptionRemoved value: -"Optional budget in ZAR. Drops options whose 1000x1000mm starting price is above it."Input schema / properties / primary_concern / descriptionRemoved value: -"Main need: blockout, heat, glare, moisture, privacy, security or automation. security returns a Garden Route handoff, not shop products."Input schema / properties / room / descriptionRemoved value: -"Optional room, e.g. \"bedroom\". Noted in the reply."get_whatsapp_handoff1 field changedInput schema / properties / customer_name / descriptionRemoved value: -"Customer's name, used in the prefilled WhatsApp message."lookup_catalog3 fields changedInput schema / properties / colour / descriptionRemoved value: -"Partial colour name to match, e.g. \"white\"."Input schema / properties / max_height_mm / descriptionRemoved value: -"Only products that can be made at least this high (drop), in millimetres. Checked separately from max_width_mm; confirm the exact pair with get_price."Input schema / properties / max_width_mm / descriptionRemoved value: -"Only products that can be made at least this wide, in millimetres. Checked separately from max_height_mm, not as a pair."update_cart5 fields changedInput schema / properties / cart_id / descriptionRemoved value: -"cart_id returned by create_cart."Input schema / properties / customer / descriptionRemoved value: -"Customer details (name, email, phone, address, city) merged into the cart."Input schema / properties / items / descriptionRemoved value: -"Items for add or set. Each needs product_id, width_mm, height_mm, colour and mount_type."Input schema / properties / items / items / properties / no_drillAdded value: +{
+ "description": "Optional. true for the no-drill option (tension brackets, inside the frame, max 2000mm wide; 1500mm on 25mm venetians). Adds the R65 no-drill kit per blind. Offered on indoor roller blinds, including value rollers, and 25mm aluminium or aluwood venetians. Dedicated no-drill products already include the kit.",
+ "type": "boolean"
+}Input schema / properties / op / descriptionRemoved value: -"add appends items, remove drops the items at the given indices, set replaces the whole item list, clear empties the cart. Default set."update_checkout3 fields changedInput schema / properties / checkout_id / descriptionRemoved value: -"checkout_id returned by create_checkout."Input schema / properties / customer / descriptionRemoved value: -"Corrected customer details (name, email, phone, address, city)."Input schema / properties / payment_method / descriptionRemoved value: -"yoco for card or ozow for instant EFT."cancel_cart1 field changedInput schema / properties / cart_id / descriptionAdded value: +"cart_id returned by create_cart."cancel_checkout1 field changedInput schema / properties / checkout_id / descriptionAdded value: +"checkout_id returned by create_checkout."check_colour_stock2 fields changedInput schema / properties / colour_name / descriptionAdded value: +"Colour name to check, e.g. \"White\"."Input schema / properties / product_id / descriptionAdded value: +"product_id from search_catalog or lookup_catalog."complete_checkout1 field changedInput schema / properties / checkout_id / descriptionAdded value: +"checkout_id returned by create_checkout."create_cart1 field changedInput schema / properties / customer / descriptionAdded value: +"Optional customer details (name, email, phone, address, city)."create_checkout2 fields changedInput schema / properties / customer / descriptionAdded value: +"Customer details. Name, email, mobile phone and delivery address are required; city is optional. Placeholder or test details are refused."Input schema / properties / items / descriptionAdded value: +"Line items to buy. Required if cart_id is not given."get_cart1 field changedInput schema / properties / cart_id / descriptionAdded value: +"cart_id returned by create_cart."get_checkout1 field changedInput schema / properties / checkout_id / descriptionAdded value: +"checkout_id returned by create_checkout."get_order2 fields changedInput schema / properties / customer_email / descriptionAdded value: +"Email address on the order. Must match the order record (not case-sensitive)."Input schema / properties / order_id / descriptionAdded value: +"Order reference: the checkout_id returned by create_checkout."get_product1 field changedInput schema / properties / product_id / descriptionAdded value: +"product_id from search_catalog or lookup_catalog."get_product_recommendation5 fields changedInput schema / properties / aesthetic / descriptionAdded value: +"Optional style preference. Noted in the reply."Input schema / properties / location / descriptionAdded value: +"Optional customer city or suburb. Accepted but not currently used."Input schema / properties / max_budget_zar / descriptionAdded value: +"Optional budget in ZAR. Drops options whose 1000x1000mm starting price is above it."Input schema / properties / primary_concern / descriptionAdded value: +"Main need: blockout, heat, glare, moisture, privacy, security or automation. security returns a Garden Route handoff, not shop products."Input schema / properties / room / descriptionAdded value: +"Optional room, e.g. \"bedroom\". Noted in the reply."get_whatsapp_handoff1 field changedInput schema / properties / customer_name / descriptionAdded value: +"Customer's name, used in the prefilled WhatsApp message."lookup_catalog3 fields changedInput schema / properties / colour / descriptionAdded value: +"Partial colour name to match, e.g. \"white\"."Input schema / properties / max_height_mm / descriptionAdded value: +"Only products that can be made at least this high (drop), in millimetres. Checked separately from max_width_mm; confirm the exact pair with get_price."Input schema / properties / max_width_mm / descriptionAdded value: +"Only products that can be made at least this wide, in millimetres. Checked separately from max_height_mm, not as a pair."request_swatch2 fields changedInput schema / properties / customer_email / descriptionAdded value: +"Customer's email address."Input schema / properties / customer_name / descriptionAdded value: +"Customer's full name."update_cart4 fields changedInput schema / properties / cart_id / descriptionAdded value: +"cart_id returned by create_cart."Input schema / properties / customer / descriptionAdded value: +"Customer details (name, email, phone, address, city) merged into the cart."Input schema / properties / items / descriptionAdded value: +"Items for add or set. Each needs product_id, width_mm, height_mm, colour and mount_type."Input schema / properties / op / descriptionAdded value: +"add appends items, remove drops the items at the given indices, set replaces the whole item list, clear empties the cart. Default set."update_checkout3 fields changedInput schema / properties / checkout_id / descriptionAdded value: +"checkout_id returned by create_checkout."Input schema / properties / customer / descriptionAdded value: +"Corrected customer details (name, email, phone, address, city)."Input schema / properties / payment_method / descriptionAdded value: +"yoco for card or ozow for instant EFT."get_ar_visualizer_url6 fields changedInput schema / properties / mode / descriptionPrevious value: -"Which tool to surface. Default: both."New value: +"Which link goes in url: visualize (own-window visualiser), measure (measuring guide) or both (visualiser, the default). Both links are always returned."Input schema / properties / product_id / descriptionPrevious value: -"Optional. Pre-select a product in the visualizer (e.g. roller-blockout, venetian-25mm-aluwood)."New value: +"Optional. Pre-select a product in the visualiser (e.g. roller-blockout, double-roller-zebra, outdoor-blinds)."Output schema / properties / measure_urlAdded value: +{
+ "type": "string"
+}Output schema / properties / supported_productsAdded value: +{
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "product_id": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "product_id",
+ "label"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+}Output schema / properties / visualiser_urlAdded value: +{
+ "type": "string"
+}Output schema / requiredPrevious value: -[
- "url",
- "note"
-]New value: +[
+ "url",
+ "visualiser_url",
+ "measure_url",
+ "note"
+]get_delivery_estimate8 fields changedOutput schema / properties / estimated_dispatch_dateRemoved value: -{
- "type": "string"
-}Output schema / properties / production_startsAdded value: +{
+ "type": "string"
+}Output schema / properties / production_working_daysRemoved value: -{
- "type": "number"
-}Output schema / properties / production_working_days_maxAdded value: +{
+ "type": "number"
+}Output schema / properties / production_working_days_minAdded value: +{
+ "type": "number"
+}Output schema / properties / transit_working_days_maxAdded value: +{
+ "type": "number"
+}Output schema / properties / transit_working_days_minAdded value: +{
+ "type": "number"
+}Output schema / requiredPrevious value: -[
- "order_date",
- "production_working_days",
- "estimated_dispatch_date",
- "delivery_after_dispatch",
- "expedited_available",
- "summary",
- "important"
-]New value: +[
+ "production_working_days_min",
+ "production_working_days_max",
+ "transit_working_days_min",
+ "transit_working_days_max",
+ "delivery_after_dispatch",
+ "summary",
+ "important"
+]get_product1 field changedOutput schema / properties / size_limits / anyOfPrevious value: -[
- {
- "additionalProperties": true,
- "properties": {
- "availability_rule": {
- "type": "string"
- },
- "combination_dependent": {
- "type": "boolean"
- },
- "max_height_mm": {
- "type": "number"
- },
- "max_width_mm": {
- "type": "number"
- },
- "measurement_note": {
- "type": "string"
- },
- "minimum_charge_height_mm": {
- "type": "number"
- },
- "minimum_charge_width_mm": {
- "type": "number"
- },
- "product_id": {
- "type": "string"
- },
- "unit": {
- "const": "mm",
- "type": "string"
- },
- "validation_note": {
- "type": "string"
- },
- "width_drop_frontier": {
- "items": {
- "additionalProperties": true,
- "properties": {
- "max_drop_mm": {
- "type": "number"
- },
- "width_band_max_mm": {
- "type": "number"
- }
- },
- "required": [
- "width_band_max_mm",
- "max_drop_mm"
- ],
- "type": "object"
- },
- "type": "array"
- }
- },
- "required": [
- "product_id",
- "unit",
- "max_width_mm",
- "max_height_mm",
- "minimum_charge_width_mm",
- "minimum_charge_height_mm",
- "combination_dependent",
- "availability_rule",
- "width_drop_frontier",
- "measurement_note",
- "validation_note"
- ],
- "type": "object"
- },
- {
- "type": "null"
- }
-]New value: +[
+ {
+ "additionalProperties": true,
+ "properties": {
+ "availability_rule": {
+ "type": "string"
+ },
+ "combination_dependent": {
+ "type": "boolean"
+ },
+ "max_height_mm": {
+ "type": "number"
+ },
+ "max_width_mm": {
+ "type": "number"
+ },
+ "measurement_note": {
+ "type": "string"
+ },
+ "minimum_charge_height_mm": {
+ "type": "number"
+ },
+ "minimum_charge_width_mm": {
+ "type": "number"
+ },
+ "minimum_order_height_mm": {
+ "type": "number"
+ },
+ "minimum_order_width_mm": {
+ "type": "number"
+ },
+ "product_id": {
+ "type": "string"
+ },
+ "unit": {
+ "const": "mm",
+ "type": "string"
+ },
+ "validation_note": {
+ "type": "string"
+ },
+ "width_drop_frontier": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "max_drop_mm": {
+ "type": "number"
+ },
+ "width_band_max_mm": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "width_band_max_mm",
+ "max_drop_mm"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "product_id",
+ "unit",
+ "max_width_mm",
+ "max_height_mm",
+ "minimum_charge_width_mm",
+ "minimum_charge_height_mm",
+ "combination_dependent",
+ "availability_rule",
+ "width_drop_frontier",
+ "measurement_note",
+ "validation_note"
+ ],
+ "type": "object"
+ },
+ {
+ "type": "null"
+ }
+]check_colour_stock12 fields changedOutput schema / properties / alternative_coloursRemoved value: -{
- "items": {
- "additionalProperties": true,
- "properties": {
- "colour_name": {
- "type": "string"
- },
- "in_stock": {
- "type": "boolean"
- },
- "swatch_url": {
- "type": "string"
- }
- },
- "required": [
- "colour_name",
- "in_stock"
- ],
- "type": "object"
- },
- "type": "array"
-}Output schema / properties / colourAdded value: +{
+ "type": "string"
+}Output schema / properties / colour_nameRemoved value: -{
- "type": "string"
-}Output schema / properties / matching_colours / items / properties / colour_nameRemoved value: -{
- "type": "string"
-}Output schema / properties / matching_colours / items / properties / expected_restockAdded value: +{
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / matching_colours / items / properties / finishAdded value: +{
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / matching_colours / items / properties / hexAdded value: +{
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / matching_colours / items / properties / materialAdded value: +{
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / matching_colours / items / properties / nameAdded value: +{
+ "type": "string"
+}Output schema / properties / matching_colours / items / properties / swatch_urlRemoved value: -{
- "type": "string"
-}Output schema / properties / matching_colours / items / requiredPrevious value: -[
- "colour_name",
- "in_stock"
-]New value: +[
+ "name",
+ "in_stock"
+]Output schema / properties / swatch_urlRemoved value: -{
- "type": "string"
-}complete_checkout3 fields changedOutput schema / properties / created_atRemoved value: -{
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
-}Output schema / properties / items / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "colour": {
- "type": "string"
- },
- "finish": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
- },
- "height": {
- "type": "number"
- },
- "mountType": {
- "type": "string"
- },
- "price": {
- "type": "number"
- },
- "productId": {
- "type": "string"
- },
- "productName": {
- "type": "string"
- },
- "quantity": {
- "type": "number"
- },
- "total": {
- "type": "number"
- },
- "width": {
- "type": "number"
- }
- },
- "required": [],
- "type": "object"
- },
- "type": "array"
- },
- {
- "type": "null"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "drop_mm": {
+ "type": "number"
+ },
+ "mount_type": {
+ "type": "string"
+ },
+ "product_name": {
+ "type": "string"
+ },
+ "product_slug": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "total_price": {
+ "type": "number"
+ },
+ "unit_price": {
+ "type": "number"
+ },
+ "width_mm": {
+ "type": "number"
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "type": "null"
+ }
+]Output schema / properties / payment_statusRemoved value: -{
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
-}configure_product32 fields changedOutput schema / oneOfRemoved value: -[
- {
- "properties": {
- "success": {
- "const": true
- }
- },
- "required": [
- "configuration"
- ]
- },
- {
- "properties": {
- "success": {
- "const": false
- }
- },
- "required": [
- "message"
- ]
- }
-]Output schema / properties / colourAdded value: +{
+ "type": "string"
+}Output schema / properties / configurationRemoved value: -{
- "additionalProperties": true,
- "properties": {
- "category": {
- "type": "string"
- },
- "colour": {
- "type": "string"
- },
- "colour_hex": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
- },
- "contact_name": {
- "type": "string"
- },
- "contact_phone": {
- "type": "string"
- },
- "contact_required": {
- "type": "boolean"
- },
- "currency": {
- "const": "ZAR",
- "type": "string"
- },
- "effective_height_mm": {
- "type": "number"
- },
- "effective_width_mm": {
- "type": "number"
- },
- "finish": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
- },
- "height_mm": {
- "type": "number"
- },
- "lead_time": {
- "type": "string"
- },
- "material": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
- },
- "measurement_review_required": {
- "type": "boolean"
- },
- "message": {
- "type": "string"
- },
- "mount_type": {
- "type": "string"
- },
- "note": {
- "type": "string"
- },
- "product_id": {
- "type": "string"
- },
- "product_name": {
- "type": "string"
- },
- "product_url": {
- "type": "string"
- },
- "quantity": {
- "type": "number"
- },
- "success": {
- "type": "boolean"
- },
- "total_price_zar": {
- "type": "number"
- },
- "unit_price_zar": {
- "type": "number"
- },
- "vat_included": {
- "type": "boolean"
- },
- "whatsapp": {
- "type": "string"
- },
- "width_mm": {
- "type": "number"
- }
- },
- "required": [
- "product_id",
- "width_mm",
- "height_mm",
- "colour",
- "mount_type",
- "quantity",
- "unit_price_zar",
- "total_price_zar",
- "currency",
- "vat_included"
- ],
- "type": "object"
-}Output schema / properties / contactAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "email": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "note": {
+ "type": "string"
+ },
+ "whatsapp": {
+ "type": "string"
+ }
+ },
+ "required": [],
+ "type": "object"
+}Output schema / properties / contact_nameRemoved value: -{
- "type": "string"
-}Output schema / properties / contact_phoneRemoved value: -{
- "type": "string"
-}Output schema / properties / contact_requiredRemoved value: -{
- "type": "boolean"
-}Output schema / properties / currencyAdded value: +{
+ "const": "ZAR",
+ "type": "string"
+}Output schema / properties / deliveryAdded value: +{
+ "type": "string"
+}Output schema / properties / effective_height_mmAdded value: +{
+ "type": "number"
+}Output schema / properties / effective_width_mmAdded value: +{
+ "type": "number"
+}Output schema / properties / finishAdded value: +{
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / height_mmAdded value: +{
+ "type": "number"
+}Output schema / properties / in_stockAdded value: +{
+ "type": "boolean"
+}Output schema / properties / lead_timeAdded value: +{
+ "type": "string"
+}Output schema / properties / limitsAdded value: +{
+ "additionalProperties": true,
+ "properties": {},
+ "required": [],
+ "type": "object"
+}Output schema / properties / messageRemoved value: -{
- "type": "string"
-}Output schema / properties / minimum_charge_appliedAdded value: +{
+ "type": "boolean"
+}Output schema / properties / mount_typeAdded value: +{
+ "type": "string"
+}Output schema / properties / next_stepAdded value: +{
+ "type": "string"
+}Output schema / properties / noteRemoved value: -{
- "type": "string"
-}Output schema / properties / price_zarAdded value: +{
+ "type": "number"
+}Output schema / properties / product_idAdded value: +{
+ "type": "string"
+}Output schema / properties / product_nameAdded value: +{
+ "type": "string"
+}Output schema / properties / quantityAdded value: +{
+ "type": "number"
+}Output schema / properties / successRemoved value: -{
- "type": "boolean"
-}Output schema / properties / summaryAdded value: +{
+ "type": "string"
+}Output schema / properties / total_price_zarAdded value: +{
+ "type": "number"
+}Output schema / properties / unit_price_zarAdded value: +{
+ "type": "number"
+}Output schema / properties / vat_includedAdded value: +{
+ "type": "boolean"
+}Output schema / properties / width_mmAdded value: +{
+ "type": "number"
+}Output schema / requiredPrevious value: -[
- "success"
-]New value: +[
+ "product_id",
+ "width_mm",
+ "height_mm",
+ "colour",
+ "mount_type",
+ "quantity",
+ "unit_price_zar",
+ "total_price_zar",
+ "currency"
+]create_checkout3 fields changedOutput schema / properties / created_atRemoved value: -{
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
-}Output schema / properties / items / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "colour": {
- "type": "string"
- },
- "finish": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
- },
- "height": {
- "type": "number"
- },
- "mountType": {
- "type": "string"
- },
- "price": {
- "type": "number"
- },
- "productId": {
- "type": "string"
- },
- "productName": {
- "type": "string"
- },
- "quantity": {
- "type": "number"
- },
- "total": {
- "type": "number"
- },
- "width": {
- "type": "number"
- }
- },
- "required": [],
- "type": "object"
- },
- "type": "array"
- },
- {
- "type": "null"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "drop_mm": {
+ "type": "number"
+ },
+ "mount_type": {
+ "type": "string"
+ },
+ "product_name": {
+ "type": "string"
+ },
+ "product_slug": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "total_price": {
+ "type": "number"
+ },
+ "unit_price": {
+ "type": "number"
+ },
+ "width_mm": {
+ "type": "number"
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "type": "null"
+ }
+]Output schema / properties / payment_statusRemoved value: -{
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
-}create_order13 fields changedOutput schema / properties / ap2Added value: +{
+ "additionalProperties": true,
+ "properties": {
+ "merchant_authorization": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "merchant_authorization"
+ ],
+ "type": "object"
+}Output schema / properties / checkout_idAdded value: +{
+ "type": "string"
+}Output schema / properties / contactRemoved value: -{
- "additionalProperties": true,
- "properties": {
- "contact_name": {
- "type": "string"
- },
- "contact_phone": {
- "type": "string"
- },
- "email": {
- "type": "string"
- },
- "note": {
- "type": "string"
- },
- "whatsapp": {
- "type": "string"
- }
- },
- "required": [],
- "type": "object"
-}Output schema / properties / customerAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "address": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "city": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "email": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "phone": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+ },
+ "required": [],
+ "type": "object"
+}Output schema / properties / itemsAdded value: +{
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "drop_mm": {
+ "type": "number"
+ },
+ "mount_type": {
+ "type": "string"
+ },
+ "product_name": {
+ "type": "string"
+ },
+ "product_slug": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "total_price": {
+ "type": "number"
+ },
+ "unit_price": {
+ "type": "number"
+ },
+ "width_mm": {
+ "type": "number"
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / next_stepAdded value: +{
+ "type": "string"
+}Output schema / properties / order_idRemoved value: -{
- "type": "string"
-}Output schema / properties / order_referenceAdded value: +{
+ "type": "string"
+}Output schema / properties / payment_methodAdded value: +{
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / provider_referenceAdded value: +{
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / statusAdded value: +{
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / successRemoved value: -{
- "type": "boolean"
-}Output schema / requiredPrevious value: -[
- "success",
- "order_id",
- "total_zar",
- "currency",
- "item_count",
- "payment_url",
- "message",
- "contact"
-]New value: +[
+ "order_reference",
+ "checkout_id",
+ "status",
+ "payment_url",
+ "message"
+]get_ar_visualizer_url7 fields changedOutput schema / properties / ar_measurement_noteRemoved value: -{
- "type": "string"
-}Output schema / properties / ar_measurement_urlRemoved value: -{
- "type": "string"
-}Output schema / properties / product_idAdded value: +{
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / product_visualizer_noteRemoved value: -{
- "type": "string"
-}Output schema / properties / product_visualizer_urlRemoved value: -{
- "type": "string"
-}Output schema / properties / urlAdded value: +{
+ "type": "string"
+}Output schema / requiredPrevious value: -[
- "note"
-]New value: +[
+ "url",
+ "note"
+]get_checkout3 fields changedOutput schema / properties / created_atRemoved value: -{
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
-}Output schema / properties / items / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "colour": {
- "type": "string"
- },
- "finish": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
- },
- "height": {
- "type": "number"
- },
- "mountType": {
- "type": "string"
- },
- "price": {
- "type": "number"
- },
- "productId": {
- "type": "string"
- },
- "productName": {
- "type": "string"
- },
- "quantity": {
- "type": "number"
- },
- "total": {
- "type": "number"
- },
- "width": {
- "type": "number"
- }
- },
- "required": [],
- "type": "object"
- },
- "type": "array"
- },
- {
- "type": "null"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "drop_mm": {
+ "type": "number"
+ },
+ "mount_type": {
+ "type": "string"
+ },
+ "product_name": {
+ "type": "string"
+ },
+ "product_slug": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "total_price": {
+ "type": "number"
+ },
+ "unit_price": {
+ "type": "number"
+ },
+ "width_mm": {
+ "type": "number"
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "type": "null"
+ }
+]Output schema / properties / payment_statusRemoved value: -{
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
-}get_order10 fields changedOutput schema / properties / created_atRemoved value: -{
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
-}Output schema / properties / customerRemoved value: -{
- "additionalProperties": true,
- "properties": {
- "address": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
- },
- "city": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
- },
- "email": {
- "type": "string"
- },
- "name": {
- "type": "string"
- },
- "phone": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
- }
- },
- "required": [],
- "type": "object"
-}Output schema / properties / items / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "colour": {
- "type": "string"
- },
- "finish": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
- },
- "height": {
- "type": "number"
- },
- "mountType": {
- "type": "string"
- },
- "price": {
- "type": "number"
- },
- "productId": {
- "type": "string"
- },
- "productName": {
- "type": "string"
- },
- "quantity": {
- "type": "number"
- },
- "total": {
- "type": "number"
- },
- "width": {
- "type": "number"
- }
- },
- "required": [],
- "type": "object"
- },
- "type": "array"
- },
- {
- "type": "null"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "drop_mm": {
+ "type": "number"
+ },
+ "mount_type": {
+ "type": "string"
+ },
+ "product_name": {
+ "type": "string"
+ },
+ "product_slug": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "total_price": {
+ "type": "number"
+ },
+ "unit_price": {
+ "type": "number"
+ },
+ "width_mm": {
+ "type": "number"
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "type": "null"
+ }
+]Output schema / properties / lead_timeAdded value: +{
+ "type": "string"
+}Output schema / properties / order_referenceAdded value: +{
+ "type": "string"
+}Output schema / properties / order_statusAdded value: +{
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / paid_atAdded value: +{
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / payment_methodRemoved value: -{
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
-}Output schema / properties / statusRemoved value: -{
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
-}Output schema / requiredPrevious value: -[
- "order_id"
-]New value: +[
+ "order_id",
+ "payment_status",
+ "total_zar",
+ "currency"
+]get_payment_methods10 fields changedOutput schema / properties / handlers / items / properties / display_nameRemoved value: -{
- "type": "string"
-}Output schema / properties / handlers / items / properties / methodsRemoved value: -{
- "items": {
- "type": "string"
- },
- "type": "array"
-}Output schema / properties / handlers / items / properties / nameAdded value: +{
+ "type": "string"
+}Output schema / properties / handlers / items / properties / noteAdded value: +{
+ "type": "string"
+}Output schema / properties / handlers / items / properties / redirectRemoved value: -{
- "type": "boolean"
-}Output schema / properties / handlers / items / properties / supportsAdded value: +{
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+}Output schema / properties / handlers / items / properties / supports_3dsRemoved value: -{
- "type": "boolean"
-}Output schema / properties / handlers / items / properties / supports_banksRemoved value: -{
- "items": {
- "type": "string"
- },
- "type": "array"
-}Output schema / properties / handlers / items / properties / webhook_verifiedRemoved value: -{
- "type": "boolean"
-}Output schema / properties / handlers / items / requiredPrevious value: -[
- "id",
- "display_name",
- "methods",
- "redirect",
- "webhook_verified"
-]New value: +[
+ "id",
+ "name",
+ "supports"
+]get_price16 fields changedOutput schema / oneOfRemoved value: -[
- {
- "properties": {
- "success": {
- "const": true
- }
- },
- "required": [
- "product_id",
- "width_mm",
- "height_mm",
- "quantity",
- "unit_price_zar",
- "total_price_zar",
- "currency",
- "vat_included"
- ]
- },
- {
- "properties": {
- "success": {
- "const": false
- }
- },
- "required": [
- "message"
- ]
- }
-]Output schema / properties / contactAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "email": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "note": {
+ "type": "string"
+ },
+ "whatsapp": {
+ "type": "string"
+ }
+ },
+ "required": [],
+ "type": "object"
+}Output schema / properties / contact_nameRemoved value: -{
- "type": "string"
-}Output schema / properties / contact_phoneRemoved value: -{
- "type": "string"
-}Output schema / properties / contact_requiredRemoved value: -{
- "type": "boolean"
-}Output schema / properties / deliveryAdded value: +{
+ "type": "string"
+}Output schema / properties / limitsAdded value: +{
+ "additionalProperties": true,
+ "properties": {},
+ "required": [],
+ "type": "object"
+}Output schema / properties / measurement_review_requiredRemoved value: -{
- "type": "boolean"
-}Output schema / properties / messageRemoved value: -{
- "type": "string"
-}Output schema / properties / minimum_charge_appliedAdded value: +{
+ "type": "boolean"
+}Output schema / properties / next_stepAdded value: +{
+ "type": "string"
+}Output schema / properties / noteRemoved value: -{
- "type": "string"
-}Output schema / properties / product_nameAdded value: +{
+ "type": "string"
+}Output schema / properties / successRemoved value: -{
- "type": "boolean"
-}Output schema / properties / whatsappRemoved value: -{
- "type": "string"
-}Output schema / requiredPrevious value: -[
- "success"
-]New value: +[
+ "product_id",
+ "width_mm",
+ "height_mm",
+ "quantity",
+ "unit_price_zar",
+ "total_price_zar",
+ "currency",
+ "vat_included"
+]get_product18 fields changedOutput schema / properties / categoryAdded value: +{
+ "type": "string"
+}Output schema / properties / colour_count_in_stockAdded value: +{
+ "type": "number"
+}Output schema / properties / coloursAdded value: +{
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "expected_restock": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "finish": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "hex": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "in_stock": {
+ "type": "boolean"
+ },
+ "material": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "name": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "name",
+ "in_stock"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+}Output schema / properties / descriptionAdded value: +{
+ "type": "string"
+}Output schema / properties / featuresAdded value: +{
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+}Output schema / properties / installation_typeAdded value: +{
+ "type": "string"
+}Output schema / properties / materialsAdded value: +{
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+}Output schema / properties / max_height_mmAdded value: +{
+ "anyOf": [
+ {
+ "type": "number"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / max_width_mmAdded value: +{
+ "anyOf": [
+ {
+ "type": "number"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / nameAdded value: +{
+ "type": "string"
+}Output schema / properties / productRemoved value: -{
- "additionalProperties": true,
- "properties": {
- "category": {
- "type": "string"
- },
- "colour_count_in_stock": {
- "type": "number"
- },
- "colours": {
- "items": {
- "additionalProperties": true,
- "properties": {
- "expected_restock": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
- },
- "finish": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
- },
- "hex": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
- },
- "in_stock": {
- "type": "boolean"
- },
- "material": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
- },
- "name": {
- "type": "string"
- }
- },
- "required": [],
- "type": "object"
- },
- "type": "array"
- },
- "description": {
- "type": "string"
- },
- "features": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "installation_type": {
- "type": "string"
- },
- "materials": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "max_height_mm": {
- "type": "number"
- },
- "max_width_mm": {
- "type": "number"
- },
- "name": {
- "type": "string"
- },
- "product_id": {
- "type": "string"
- },
- "product_url": {
- "type": "string"
- },
- "schema_url": {
- "type": "string"
- },
- "size_limits": {
- "additionalProperties": true,
- "properties": {
- "availability_rule": {
- "type": "string"
- },
- "combination_dependent": {
- "type": "boolean"
- },
- "max_height_mm": {
- "type": "number"
- },
- "max_width_mm": {
- "type": "number"
- },
- "measurement_note": {
- "type": "string"
- },
- "minimum_charge_height_mm": {
- "type": "number"
- },
- "minimum_charge_width_mm": {
- "type": "number"
- },
- "product_id": {
- "type": "string"
- },
- "unit": {
- "const": "mm",
- "type": "string"
- },
- "validation_note": {
- "type": "string"
- },
- "width_drop_frontier": {
- "items": {
- "additionalProperties": true,
- "properties": {
- "max_drop_mm": {
- "type": "number"
- },
- "width_band_max_mm": {
- "type": "number"
- }
- },
- "required": [
- "width_band_max_mm",
- "max_drop_mm"
- ],
- "type": "object"
- },
- "type": "array"
- }
- },
- "required": [
- "product_id",
- "unit",
- "max_width_mm",
- "max_height_mm",
- "minimum_charge_width_mm",
- "minimum_charge_height_mm",
- "combination_dependent",
- "availability_rule",
- "width_drop_frontier",
- "measurement_note",
- "validation_note"
- ],
- "type": "object"
- },
- "suitable_for": {
- "items": {
- "type": "string"
- },
- "type": "array"
- }
- },
- "required": [
- "product_id",
- "name",
- "category",
- "colours",
- "product_url"
- ],
- "type": "object"
-}Output schema / properties / product_idAdded value: +{
+ "type": "string"
+}Output schema / properties / product_urlAdded value: +{
+ "type": "string"
+}Output schema / properties / schema_urlAdded value: +{
+ "type": "string"
+}Output schema / properties / size_limitsAdded value: +{
+ "anyOf": [
+ {
+ "additionalProperties": true,
+ "properties": {
+ "availability_rule": {
+ "type": "string"
+ },
+ "combination_dependent": {
+ "type": "boolean"
+ },
+ "max_height_mm": {
+ "type": "number"
+ },
+ "max_width_mm": {
+ "type": "number"
+ },
+ "measurement_note": {
+ "type": "string"
+ },
+ "minimum_charge_height_mm": {
+ "type": "number"
+ },
+ "minimum_charge_width_mm": {
+ "type": "number"
+ },
+ "product_id": {
+ "type": "string"
+ },
+ "unit": {
+ "const": "mm",
+ "type": "string"
+ },
+ "validation_note": {
+ "type": "string"
+ },
+ "width_drop_frontier": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "max_drop_mm": {
+ "type": "number"
+ },
+ "width_band_max_mm": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "width_band_max_mm",
+ "max_drop_mm"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "product_id",
+ "unit",
+ "max_width_mm",
+ "max_height_mm",
+ "minimum_charge_width_mm",
+ "minimum_charge_height_mm",
+ "combination_dependent",
+ "availability_rule",
+ "width_drop_frontier",
+ "measurement_note",
+ "validation_note"
+ ],
+ "type": "object"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / starting_price_zarAdded value: +{
+ "anyOf": [
+ {
+ "type": "number"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / suitable_forAdded value: +{
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+}Output schema / requiredPrevious value: -[
- "product"
-]New value: +[
+ "product_id",
+ "name",
+ "category",
+ "colours",
+ "product_url"
+]request_swatch7 fields changedInput schema / properties / order_refAdded value: +{
+ "description": "The order reference the swatches ship with. Required.",
+ "type": "string"
+}Input schema / properties / swatch_codes / descriptionPrevious value: -"Optional specific colour codes; no count limit enforced by this handler"New value: +"Optional specific colour codes (max 5)"Input schema / requiredPrevious value: -[
- "customer_name",
- "customer_email",
- "customer_phone",
- "product_interest"
-]New value: +[
+ "customer_name",
+ "customer_email",
+ "customer_phone",
+ "product_interest",
+ "order_ref"
+]Output schema / properties / next_stepAdded value: +{
+ "type": "string"
+}Output schema / properties / order_refAdded value: +{
+ "type": "string"
+}Output schema / properties / policyAdded value: +{
+ "type": "string"
+}Output schema / requiredPrevious value: -[
- "request_id",
- "status",
- "estimated_delivery_days",
- "swatch_count",
- "message"
-]New value: +[
+ "status",
+ "message"
+]search_products14 fields changedOutput schema / properties / contactAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "email": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "note": {
+ "type": "string"
+ },
+ "whatsapp": {
+ "type": "string"
+ }
+ },
+ "required": [],
+ "type": "object"
+}Output schema / properties / contact_nameRemoved value: -{
- "type": "string"
-}Output schema / properties / contact_phoneRemoved value: -{
- "type": "string"
-}Output schema / properties / currencyAdded value: +{
+ "const": "ZAR",
+ "type": "string"
+}Output schema / properties / noteRemoved value: -{
- "type": "string"
-}Output schema / properties / products / items / properties / colour_countRemoved value: -{
- "type": "number"
-}Output schema / properties / products / items / properties / colour_count_in_stockAdded value: +{
+ "type": "number"
+}Output schema / properties / products / items / properties / idRemoved value: -{
- "type": "string"
-}Output schema / properties / products / items / properties / installation_typeRemoved value: -{
- "type": "string"
-}Output schema / properties / products / items / properties / materialsRemoved value: -{
- "items": {
- "type": "string"
- },
- "type": "array"
-}Output schema / properties / products / items / properties / product_idAdded value: +{
+ "type": "string"
+}Output schema / properties / products / items / properties / starting_price_zarAdded value: +{
+ "anyOf": [
+ {
+ "type": "number"
+ },
+ {
+ "type": "null"
+ }
+ ]
+}Output schema / properties / products / items / properties / suitable_forRemoved value: -{
- "items": {
- "type": "string"
- },
- "type": "array"
-}Output schema / properties / products / items / requiredPrevious value: -[
- "id",
- "name",
- "category",
- "product_url"
-]New value: +[
+ "product_id",
+ "name",
+ "category",
+ "product_url"
+]submit_enquiry5 fields changedOutput schema / properties / contact / properties / contact_nameRemoved value: -{
- "type": "string"
-}Output schema / properties / contact / properties / contact_phoneRemoved value: -{
- "type": "string"
-}Output schema / properties / contact / properties / nameAdded value: +{
+ "type": "string"
+}Output schema / properties / enquiry_idRemoved value: -{
- "type": "string"
-}Output schema / requiredPrevious value: -[
- "success",
- "enquiry_id",
- "message",
- "contact"
-]New value: +[
+ "success",
+ "message",
+ "contact"
+]update_checkout3 fields changedOutput schema / properties / created_atRemoved value: -{
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
-}Output schema / properties / items / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "colour": {
- "type": "string"
- },
- "finish": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
- },
- "height": {
- "type": "number"
- },
- "mountType": {
- "type": "string"
- },
- "price": {
- "type": "number"
- },
- "productId": {
- "type": "string"
- },
- "productName": {
- "type": "string"
- },
- "quantity": {
- "type": "number"
- },
- "total": {
- "type": "number"
- },
- "width": {
- "type": "number"
- }
- },
- "required": [],
- "type": "object"
- },
- "type": "array"
- },
- {
- "type": "null"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "drop_mm": {
+ "type": "number"
+ },
+ "mount_type": {
+ "type": "string"
+ },
+ "product_name": {
+ "type": "string"
+ },
+ "product_slug": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "total_price": {
+ "type": "number"
+ },
+ "unit_price": {
+ "type": "number"
+ },
+ "width_mm": {
+ "type": "number"
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "type": "null"
+ }
+]Output schema / properties / payment_statusRemoved value: -{
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ]
-}cancel_cart1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "cancelled": {
+ "type": "boolean"
+ },
+ "cart_id": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "cancelled",
+ "cart_id"
+ ],
+ "type": "object"
+}cancel_checkout1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "checkout_id": {
+ "type": "string"
+ },
+ "status": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "checkout_id",
+ "status"
+ ],
+ "type": "object"
+}check_colour_stock1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "alternative_colours": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour_name": {
+ "type": "string"
+ },
+ "in_stock": {
+ "type": "boolean"
+ },
+ "swatch_url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "colour_name",
+ "in_stock"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "available_colours": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "colour_name": {
+ "type": "string"
+ },
+ "exact_colour_match": {
+ "type": "boolean"
+ },
+ "expected_restock": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "found": {
+ "type": "boolean"
+ },
+ "in_stock": {
+ "type": "boolean"
+ },
+ "matching_colours": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour_name": {
+ "type": "string"
+ },
+ "in_stock": {
+ "type": "boolean"
+ },
+ "swatch_url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "colour_name",
+ "in_stock"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "message": {
+ "type": "string"
+ },
+ "product_id": {
+ "type": "string"
+ },
+ "requires_exact_colour_selection": {
+ "type": "boolean"
+ },
+ "swatch_url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "in_stock"
+ ],
+ "type": "object"
+}complete_checkout1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "allOf": [
+ {
+ "if": {
+ "properties": {
+ "payment_url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "payment_url"
+ ]
+ },
+ "then": {
+ "required": [
+ "total_zar",
+ "currency",
+ "payment_method"
+ ]
+ }
+ }
+ ],
+ "properties": {
+ "ap2": {
+ "additionalProperties": true,
+ "properties": {
+ "merchant_authorization": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "merchant_authorization"
+ ],
+ "type": "object"
+ },
+ "checkout_id": {
+ "type": "string"
+ },
+ "created_at": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "currency": {
+ "const": "ZAR",
+ "type": "string"
+ },
+ "customer": {
+ "additionalProperties": true,
+ "properties": {
+ "address": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "city": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "email": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "phone": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "item_count": {
+ "type": "number"
+ },
+ "items": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour": {
+ "type": "string"
+ },
+ "finish": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "height": {
+ "type": "number"
+ },
+ "mountType": {
+ "type": "string"
+ },
+ "price": {
+ "type": "number"
+ },
+ "productId": {
+ "type": "string"
+ },
+ "productName": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "total": {
+ "type": "number"
+ },
+ "width": {
+ "type": "number"
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "message": {
+ "type": "string"
+ },
+ "next_step": {
+ "type": "string"
+ },
+ "payment_method": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "payment_status": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "payment_url": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "provider_reference": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "status": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "total_zar": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "checkout_id",
+ "status",
+ "payment_url",
+ "message"
+ ],
+ "type": "object"
+}configure_product5 fields changedInput schema / properties / mount_type / descriptionPrevious value: -"Mount type: inside (recess) or outside (face-fix)"New value: +"Use inside (recess) or outside (face-fix); handler requires a nonempty value"Input schema / properties / mount_type / enumRemoved value: -[
- "inside",
- "outside"
-]Input schema / properties / mount_type / minLengthAdded value: +1Input schema / properties / product_id / descriptionPrevious value: -"Product ID from search_products"New value: +"product_id from search_catalog or lookup_catalog"Output schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "oneOf": [
+ {
+ "properties": {
+ "success": {
+ "const": true
+ }
+ },
+ "required": [
+ "configuration"
+ ]
+ },
+ {
+ "properties": {
+ "success": {
+ "const": false
+ }
+ },
+ "required": [
+ "message"
+ ]
+ }
+ ],
+ "properties": {
+ "configuration": {
+ "additionalProperties": true,
+ "properties": {
+ "category": {
+ "type": "string"
+ },
+ "colour": {
+ "type": "string"
+ },
+ "colour_hex": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "contact_name": {
+ "type": "string"
+ },
+ "contact_phone": {
+ "type": "string"
+ },
+ "contact_required": {
+ "type": "boolean"
+ },
+ "currency": {
+ "const": "ZAR",
+ "type": "string"
+ },
+ "effective_height_mm": {
+ "type": "number"
+ },
+ "effective_width_mm": {
+ "type": "number"
+ },
+ "finish": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "height_mm": {
+ "type": "number"
+ },
+ "lead_time": {
+ "type": "string"
+ },
+ "material": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "measurement_review_required": {
+ "type": "boolean"
+ },
+ "message": {
+ "type": "string"
+ },
+ "mount_type": {
+ "type": "string"
+ },
+ "note": {
+ "type": "string"
+ },
+ "product_id": {
+ "type": "string"
+ },
+ "product_name": {
+ "type": "string"
+ },
+ "product_url": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "success": {
+ "type": "boolean"
+ },
+ "total_price_zar": {
+ "type": "number"
+ },
+ "unit_price_zar": {
+ "type": "number"
+ },
+ "vat_included": {
+ "type": "boolean"
+ },
+ "whatsapp": {
+ "type": "string"
+ },
+ "width_mm": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "product_id",
+ "width_mm",
+ "height_mm",
+ "colour",
+ "mount_type",
+ "quantity",
+ "unit_price_zar",
+ "total_price_zar",
+ "currency",
+ "vat_included"
+ ],
+ "type": "object"
+ },
+ "contact_name": {
+ "type": "string"
+ },
+ "contact_phone": {
+ "type": "string"
+ },
+ "contact_required": {
+ "type": "boolean"
+ },
+ "message": {
+ "type": "string"
+ },
+ "note": {
+ "type": "string"
+ },
+ "success": {
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "success"
+ ],
+ "type": "object"
+}create_cart5 fields changedInput schema / properties / customer / descriptionRemoved value: -"Optional customer details"Input schema / properties / customer / propertiesAdded value: +{
+ "address": {
+ "type": "string"
+ },
+ "city": {
+ "type": "string"
+ },
+ "email": {
+ "description": "Real customer email, checked before checkout creation",
+ "type": "string"
+ },
+ "name": {
+ "description": "Real customer name, checked before checkout creation",
+ "type": "string"
+ },
+ "phone": {
+ "description": "South African phone number, checked before checkout creation",
+ "type": "string"
+ }
+}Input schema / properties / items / descriptionPrevious value: -"Optional initial items (configured blinds)"New value: +"Optional configured items; all submitted prices are ignored"Input schema / properties / items / itemsAdded value: +{
+ "properties": {
+ "colour": {
+ "description": "Exact available colour; validate with configure_product before adding",
+ "minLength": 1,
+ "type": "string"
+ },
+ "finish": {
+ "description": "Optional pricing finish for aluminium Venetians",
+ "type": "string"
+ },
+ "height_mm": {
+ "description": "Actual ordered drop in millimetres",
+ "exclusiveMinimum": 0,
+ "type": "number"
+ },
+ "mount_type": {
+ "description": "Use inside for recess fit or outside for face fix",
+ "minLength": 1,
+ "type": "string"
+ },
+ "product_id": {
+ "description": "product_id returned by search_catalog or lookup_catalog",
+ "type": "string"
+ },
+ "product_name": {
+ "description": "Optional; server resolves the catalogue name",
+ "type": "string"
+ },
+ "quantity": {
+ "description": "Number of blinds; defaults to 1",
+ "type": "number"
+ },
+ "total_price_zar": {
+ "description": "Optional, ignored: server recalculates all totals",
+ "type": "number"
+ },
+ "unit_price_zar": {
+ "description": "Optional, ignored: server recalculates all prices",
+ "type": "number"
+ },
+ "width_mm": {
+ "description": "Actual ordered width in millimetres",
+ "exclusiveMinimum": 0,
+ "type": "number"
+ }
+ },
+ "required": [
+ "product_id",
+ "width_mm",
+ "height_mm",
+ "colour",
+ "mount_type"
+ ],
+ "type": "object"
+}Output schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "cart_id": {
+ "type": "string"
+ },
+ "created_at": {
+ "type": "string"
+ },
+ "currency": {
+ "const": "ZAR",
+ "type": "string"
+ },
+ "customer": {
+ "anyOf": [
+ {
+ "additionalProperties": true,
+ "properties": {
+ "address": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "city": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "email": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "phone": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "expires_at": {
+ "type": "string"
+ },
+ "item_count": {
+ "type": "number"
+ },
+ "items": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour": {
+ "type": "string"
+ },
+ "finish": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "height_mm": {
+ "type": "number"
+ },
+ "mount_type": {
+ "type": "string"
+ },
+ "product_id": {
+ "type": "string"
+ },
+ "product_name": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "total_price_zar": {
+ "type": "number"
+ },
+ "unit_price_zar": {
+ "type": "number"
+ },
+ "width_mm": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "product_id",
+ "width_mm",
+ "height_mm",
+ "quantity",
+ "unit_price_zar",
+ "total_price_zar"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "total_zar": {
+ "type": "number"
+ },
+ "updated_at": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "cart_id",
+ "items",
+ "item_count",
+ "total_zar",
+ "currency",
+ "customer",
+ "created_at",
+ "updated_at",
+ "expires_at"
+ ],
+ "type": "object"
+}create_checkout8 fields changedInput schema / anyOfAdded value: +[
+ {
+ "required": [
+ "cart_id"
+ ]
+ },
+ {
+ "properties": {
+ "customer": {
+ "required": [
+ "name",
+ "email",
+ "phone"
+ ]
+ }
+ },
+ "required": [
+ "items",
+ "customer"
+ ]
+ }
+]Input schema / properties / customer / properties / email / descriptionAdded value: +"Real customer email, checked before checkout creation"Input schema / properties / customer / properties / name / descriptionAdded value: +"Real customer name, checked before checkout creation"Input schema / properties / customer / properties / phone / descriptionAdded value: +"South African phone number, checked before checkout creation"Input schema / properties / customer / requiredRemoved value: -[
- "name",
- "email",
- "phone"
-]Input schema / properties / items / itemsAdded value: +{
+ "properties": {
+ "colour": {
+ "description": "Exact available colour; validate with configure_product before adding",
+ "minLength": 1,
+ "type": "string"
+ },
+ "finish": {
+ "description": "Optional pricing finish for aluminium Venetians",
+ "type": "string"
+ },
+ "height_mm": {
+ "description": "Actual ordered drop in millimetres",
+ "exclusiveMinimum": 0,
+ "type": "number"
+ },
+ "mount_type": {
+ "description": "Use inside for recess fit or outside for face fix",
+ "minLength": 1,
+ "type": "string"
+ },
+ "product_id": {
+ "description": "product_id returned by search_catalog or lookup_catalog",
+ "type": "string"
+ },
+ "product_name": {
+ "description": "Optional; server resolves the catalogue name",
+ "type": "string"
+ },
+ "quantity": {
+ "description": "Number of blinds; defaults to 1",
+ "type": "number"
+ },
+ "total_price_zar": {
+ "description": "Optional, ignored: server recalculates all totals",
+ "type": "number"
+ },
+ "unit_price_zar": {
+ "description": "Optional, ignored: server recalculates all prices",
+ "type": "number"
+ },
+ "width_mm": {
+ "description": "Actual ordered width in millimetres",
+ "exclusiveMinimum": 0,
+ "type": "number"
+ }
+ },
+ "required": [
+ "product_id",
+ "width_mm",
+ "height_mm",
+ "colour",
+ "mount_type"
+ ],
+ "type": "object"
+}Input schema / properties / items / minItemsAdded value: +1Output schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "ap2": {
+ "additionalProperties": true,
+ "properties": {
+ "merchant_authorization": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "merchant_authorization"
+ ],
+ "type": "object"
+ },
+ "checkout_id": {
+ "type": "string"
+ },
+ "created_at": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "currency": {
+ "const": "ZAR",
+ "type": "string"
+ },
+ "customer": {
+ "additionalProperties": true,
+ "properties": {
+ "address": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "city": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "email": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "phone": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "item_count": {
+ "type": "number"
+ },
+ "items": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour": {
+ "type": "string"
+ },
+ "finish": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "height": {
+ "type": "number"
+ },
+ "mountType": {
+ "type": "string"
+ },
+ "price": {
+ "type": "number"
+ },
+ "productId": {
+ "type": "string"
+ },
+ "productName": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "total": {
+ "type": "number"
+ },
+ "width": {
+ "type": "number"
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "message": {
+ "type": "string"
+ },
+ "next_step": {
+ "type": "string"
+ },
+ "payment_method": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "payment_status": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "payment_url": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "provider_reference": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "status": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "total_zar": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "checkout_id",
+ "status",
+ "total_zar",
+ "currency"
+ ],
+ "type": "object"
+}create_order4 fields changedInput schema / properties / items / items / requiredPrevious value: -[
- "product_id",
- "width_mm",
- "height_mm",
- "colour",
- "mount_type",
- "unit_price_zar",
- "total_price_zar"
-]New value: +[
+ "product_id",
+ "width_mm",
+ "height_mm",
+ "colour",
+ "mount_type"
+]Input schema / properties / items / minItemsAdded value: +1Input schema / properties / payment_methodAdded value: +{
+ "default": "yoco",
+ "description": "Yoco card or Ozow instant EFT",
+ "enum": [
+ "yoco",
+ "ozow"
+ ],
+ "type": "string"
+}Output schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "contact": {
+ "additionalProperties": true,
+ "properties": {
+ "contact_name": {
+ "type": "string"
+ },
+ "contact_phone": {
+ "type": "string"
+ },
+ "email": {
+ "type": "string"
+ },
+ "note": {
+ "type": "string"
+ },
+ "whatsapp": {
+ "type": "string"
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "currency": {
+ "const": "ZAR",
+ "type": "string"
+ },
+ "item_count": {
+ "type": "number"
+ },
+ "message": {
+ "type": "string"
+ },
+ "order_id": {
+ "type": "string"
+ },
+ "payment_url": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "success": {
+ "type": "boolean"
+ },
+ "total_zar": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "success",
+ "order_id",
+ "total_zar",
+ "currency",
+ "item_count",
+ "payment_url",
+ "message",
+ "contact"
+ ],
+ "type": "object"
+}get_ar_visualizer_url1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "ar_measurement_note": {
+ "type": "string"
+ },
+ "ar_measurement_url": {
+ "type": "string"
+ },
+ "note": {
+ "type": "string"
+ },
+ "product_visualizer_note": {
+ "type": "string"
+ },
+ "product_visualizer_url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "note"
+ ],
+ "type": "object"
+}get_cart1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "cart_id": {
+ "type": "string"
+ },
+ "created_at": {
+ "type": "string"
+ },
+ "currency": {
+ "const": "ZAR",
+ "type": "string"
+ },
+ "customer": {
+ "anyOf": [
+ {
+ "additionalProperties": true,
+ "properties": {
+ "address": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "city": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "email": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "phone": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "expires_at": {
+ "type": "string"
+ },
+ "item_count": {
+ "type": "number"
+ },
+ "items": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour": {
+ "type": "string"
+ },
+ "finish": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "height_mm": {
+ "type": "number"
+ },
+ "mount_type": {
+ "type": "string"
+ },
+ "product_id": {
+ "type": "string"
+ },
+ "product_name": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "total_price_zar": {
+ "type": "number"
+ },
+ "unit_price_zar": {
+ "type": "number"
+ },
+ "width_mm": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "product_id",
+ "width_mm",
+ "height_mm",
+ "quantity",
+ "unit_price_zar",
+ "total_price_zar"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "total_zar": {
+ "type": "number"
+ },
+ "updated_at": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "cart_id",
+ "items",
+ "item_count",
+ "total_zar",
+ "currency",
+ "customer",
+ "created_at",
+ "updated_at",
+ "expires_at"
+ ],
+ "type": "object"
+}get_checkout1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "ap2": {
+ "additionalProperties": true,
+ "properties": {
+ "merchant_authorization": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "merchant_authorization"
+ ],
+ "type": "object"
+ },
+ "checkout_id": {
+ "type": "string"
+ },
+ "created_at": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "currency": {
+ "const": "ZAR",
+ "type": "string"
+ },
+ "customer": {
+ "additionalProperties": true,
+ "properties": {
+ "address": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "city": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "email": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "phone": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "item_count": {
+ "type": "number"
+ },
+ "items": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour": {
+ "type": "string"
+ },
+ "finish": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "height": {
+ "type": "number"
+ },
+ "mountType": {
+ "type": "string"
+ },
+ "price": {
+ "type": "number"
+ },
+ "productId": {
+ "type": "string"
+ },
+ "productName": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "total": {
+ "type": "number"
+ },
+ "width": {
+ "type": "number"
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "message": {
+ "type": "string"
+ },
+ "next_step": {
+ "type": "string"
+ },
+ "payment_method": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "payment_status": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "payment_url": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "provider_reference": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "status": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "total_zar": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "checkout_id",
+ "status",
+ "total_zar",
+ "currency"
+ ],
+ "type": "object"
+}get_delivery_estimate1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "delivery_after_dispatch": {
+ "type": "string"
+ },
+ "estimated_dispatch_date": {
+ "type": "string"
+ },
+ "expedited_available": {
+ "type": "boolean"
+ },
+ "important": {
+ "type": "string"
+ },
+ "order_date": {
+ "type": "string"
+ },
+ "production_working_days": {
+ "type": "number"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "order_date",
+ "production_working_days",
+ "estimated_dispatch_date",
+ "delivery_after_dispatch",
+ "expedited_available",
+ "summary",
+ "important"
+ ],
+ "type": "object"
+}get_order1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "created_at": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "currency": {
+ "const": "ZAR",
+ "type": "string"
+ },
+ "customer": {
+ "additionalProperties": true,
+ "properties": {
+ "address": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "city": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "email": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "phone": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "items": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour": {
+ "type": "string"
+ },
+ "finish": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "height": {
+ "type": "number"
+ },
+ "mountType": {
+ "type": "string"
+ },
+ "price": {
+ "type": "number"
+ },
+ "productId": {
+ "type": "string"
+ },
+ "productName": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "total": {
+ "type": "number"
+ },
+ "width": {
+ "type": "number"
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "order_id": {
+ "type": "string"
+ },
+ "payment_method": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "payment_status": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "status": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "total_zar": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "order_id"
+ ],
+ "type": "object"
+}get_payment_methods1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "default_currency": {
+ "const": "ZAR",
+ "type": "string"
+ },
+ "handlers": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "display_name": {
+ "type": "string"
+ },
+ "id": {
+ "type": "string"
+ },
+ "methods": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "redirect": {
+ "type": "boolean"
+ },
+ "supports_3ds": {
+ "type": "boolean"
+ },
+ "supports_banks": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "webhook_verified": {
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "id",
+ "display_name",
+ "methods",
+ "redirect",
+ "webhook_verified"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "note": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "default_currency",
+ "handlers",
+ "note"
+ ],
+ "type": "object"
+}get_price3 fields changedInput schema / properties / colourAdded value: +{
+ "description": "Optional bamboo colour for colour-specific tier pricing",
+ "type": "string"
+}Input schema / properties / product_id / descriptionPrevious value: -"Product ID from search_products (e.g. roller-blockout, venetian-25mm-aluminium)"New value: +"product_id from search_catalog or lookup_catalog (e.g. roller-blockout)"Output schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "oneOf": [
+ {
+ "properties": {
+ "success": {
+ "const": true
+ }
+ },
+ "required": [
+ "product_id",
+ "width_mm",
+ "height_mm",
+ "quantity",
+ "unit_price_zar",
+ "total_price_zar",
+ "currency",
+ "vat_included"
+ ]
+ },
+ {
+ "properties": {
+ "success": {
+ "const": false
+ }
+ },
+ "required": [
+ "message"
+ ]
+ }
+ ],
+ "properties": {
+ "contact_name": {
+ "type": "string"
+ },
+ "contact_phone": {
+ "type": "string"
+ },
+ "contact_required": {
+ "type": "boolean"
+ },
+ "currency": {
+ "const": "ZAR",
+ "type": "string"
+ },
+ "effective_height_mm": {
+ "type": "number"
+ },
+ "effective_width_mm": {
+ "type": "number"
+ },
+ "finish": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "height_mm": {
+ "type": "number"
+ },
+ "lead_time": {
+ "type": "string"
+ },
+ "measurement_review_required": {
+ "type": "boolean"
+ },
+ "message": {
+ "type": "string"
+ },
+ "note": {
+ "type": "string"
+ },
+ "product_id": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "success": {
+ "type": "boolean"
+ },
+ "total_price_zar": {
+ "type": "number"
+ },
+ "unit_price_zar": {
+ "type": "number"
+ },
+ "vat_included": {
+ "type": "boolean"
+ },
+ "whatsapp": {
+ "type": "string"
+ },
+ "width_mm": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "success"
+ ],
+ "type": "object"
+}get_product1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "product": {
+ "additionalProperties": true,
+ "properties": {
+ "category": {
+ "type": "string"
+ },
+ "colour_count_in_stock": {
+ "type": "number"
+ },
+ "colours": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "expected_restock": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "finish": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "hex": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "in_stock": {
+ "type": "boolean"
+ },
+ "material": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "name": {
+ "type": "string"
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "description": {
+ "type": "string"
+ },
+ "features": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "installation_type": {
+ "type": "string"
+ },
+ "materials": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "max_height_mm": {
+ "type": "number"
+ },
+ "max_width_mm": {
+ "type": "number"
+ },
+ "name": {
+ "type": "string"
+ },
+ "product_id": {
+ "type": "string"
+ },
+ "product_url": {
+ "type": "string"
+ },
+ "schema_url": {
+ "type": "string"
+ },
+ "size_limits": {
+ "additionalProperties": true,
+ "properties": {
+ "availability_rule": {
+ "type": "string"
+ },
+ "combination_dependent": {
+ "type": "boolean"
+ },
+ "max_height_mm": {
+ "type": "number"
+ },
+ "max_width_mm": {
+ "type": "number"
+ },
+ "measurement_note": {
+ "type": "string"
+ },
+ "minimum_charge_height_mm": {
+ "type": "number"
+ },
+ "minimum_charge_width_mm": {
+ "type": "number"
+ },
+ "product_id": {
+ "type": "string"
+ },
+ "unit": {
+ "const": "mm",
+ "type": "string"
+ },
+ "validation_note": {
+ "type": "string"
+ },
+ "width_drop_frontier": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "max_drop_mm": {
+ "type": "number"
+ },
+ "width_band_max_mm": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "width_band_max_mm",
+ "max_drop_mm"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "product_id",
+ "unit",
+ "max_width_mm",
+ "max_height_mm",
+ "minimum_charge_width_mm",
+ "minimum_charge_height_mm",
+ "combination_dependent",
+ "availability_rule",
+ "width_drop_frontier",
+ "measurement_note",
+ "validation_note"
+ ],
+ "type": "object"
+ },
+ "suitable_for": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "product_id",
+ "name",
+ "category",
+ "colours",
+ "product_url"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "product"
+ ],
+ "type": "object"
+}get_product_recommendation1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "handoff": {
+ "additionalProperties": true,
+ "properties": {
+ "product_family": {
+ "type": "string"
+ },
+ "reason": {
+ "type": "string"
+ },
+ "url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "url",
+ "product_family",
+ "reason"
+ ],
+ "type": "object"
+ },
+ "notes": {
+ "type": "string"
+ },
+ "recommendations": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "currency": {
+ "const": "ZAR",
+ "type": "string"
+ },
+ "product_id": {
+ "type": "string"
+ },
+ "product_name": {
+ "type": "string"
+ },
+ "reason": {
+ "type": "string"
+ },
+ "shop_url": {
+ "type": "string"
+ },
+ "starting_price_zar_for_1m_x_1m": {
+ "anyOf": [
+ {
+ "type": "number"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+ },
+ "required": [
+ "product_id",
+ "product_name",
+ "reason",
+ "starting_price_zar_for_1m_x_1m",
+ "currency",
+ "shop_url"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "recommendations"
+ ],
+ "type": "object"
+}get_whatsapp_handoff1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "reason": {
+ "type": "string"
+ },
+ "recipient": {
+ "type": "string"
+ },
+ "recipient_phone": {
+ "type": "string"
+ },
+ "whatsapp_url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "whatsapp_url",
+ "recipient",
+ "recipient_phone",
+ "reason"
+ ],
+ "type": "object"
+}lookup_catalog1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "results": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "category": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "product_id": {
+ "type": "string"
+ },
+ "product_url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "product_id",
+ "name",
+ "category",
+ "product_url"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "total": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "results",
+ "total"
+ ],
+ "type": "object"
+}request_price_match1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "claim_summary": {
+ "additionalProperties": true,
+ "properties": {
+ "competitor": {
+ "type": "string"
+ },
+ "competitor_price_zar": {
+ "type": "string"
+ },
+ "dimensions": {
+ "type": "string"
+ },
+ "product_id": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "product_id",
+ "dimensions",
+ "competitor",
+ "competitor_price_zar"
+ ],
+ "type": "object"
+ },
+ "exclusions": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "message": {
+ "type": "string"
+ },
+ "note": {
+ "type": "string"
+ },
+ "success": {
+ "type": "boolean"
+ },
+ "whatsapp_url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "success",
+ "claim_summary",
+ "whatsapp_url",
+ "message",
+ "exclusions",
+ "note"
+ ],
+ "type": "object"
+}request_swatch2 fields changedInput schema / properties / swatch_codes / descriptionPrevious value: -"Optional specific colour codes (max 5)"New value: +"Optional specific colour codes; no count limit enforced by this handler"Output schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "estimated_delivery_days": {
+ "additionalProperties": true,
+ "properties": {
+ "max": {
+ "type": "number"
+ },
+ "min": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "min",
+ "max"
+ ],
+ "type": "object"
+ },
+ "message": {
+ "type": "string"
+ },
+ "request_id": {
+ "type": "number"
+ },
+ "status": {
+ "type": "string"
+ },
+ "swatch_count": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "request_id",
+ "status",
+ "estimated_delivery_days",
+ "swatch_count",
+ "message"
+ ],
+ "type": "object"
+}search_catalog1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "currency": {
+ "const": "ZAR",
+ "type": "string"
+ },
+ "results": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "category": {
+ "type": "string"
+ },
+ "colour_count_in_stock": {
+ "type": "number"
+ },
+ "description": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "product_id": {
+ "type": "string"
+ },
+ "product_url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "product_id",
+ "name",
+ "category",
+ "description",
+ "product_url",
+ "colour_count_in_stock"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "total": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "results",
+ "total",
+ "currency"
+ ],
+ "type": "object"
+}search_products1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "contact_name": {
+ "type": "string"
+ },
+ "contact_phone": {
+ "type": "string"
+ },
+ "note": {
+ "type": "string"
+ },
+ "products": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "category": {
+ "type": "string"
+ },
+ "colour_count": {
+ "type": "number"
+ },
+ "description": {
+ "type": "string"
+ },
+ "features": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "id": {
+ "type": "string"
+ },
+ "installation_type": {
+ "type": "string"
+ },
+ "materials": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "name": {
+ "type": "string"
+ },
+ "product_url": {
+ "type": "string"
+ },
+ "suitable_for": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "id",
+ "name",
+ "category",
+ "product_url"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "total": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "products",
+ "total"
+ ],
+ "type": "object"
+}submit_enquiry4 fields changedInput schema / properties / message / descriptionPrevious value: -"Additional message or questions from the customer"New value: +"Required enquiry message; at least 10 characters after trimming"Input schema / properties / message / minLengthAdded value: +10Input schema / requiredPrevious value: -[
- "product_config",
- "customer_name",
- "customer_email",
- "customer_phone"
-]New value: +[
+ "product_config",
+ "customer_name",
+ "customer_email",
+ "customer_phone",
+ "message"
+]Output schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "contact": {
+ "additionalProperties": true,
+ "properties": {
+ "contact_name": {
+ "type": "string"
+ },
+ "contact_phone": {
+ "type": "string"
+ },
+ "email": {
+ "type": "string"
+ },
+ "note": {
+ "type": "string"
+ },
+ "whatsapp": {
+ "type": "string"
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "enquiry_id": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "success": {
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "success",
+ "enquiry_id",
+ "message",
+ "contact"
+ ],
+ "type": "object"
+}update_cart4 fields changedInput schema / properties / customer / propertiesAdded value: +{
+ "address": {
+ "type": "string"
+ },
+ "city": {
+ "type": "string"
+ },
+ "email": {
+ "description": "Real customer email, checked before checkout creation",
+ "type": "string"
+ },
+ "name": {
+ "description": "Real customer name, checked before checkout creation",
+ "type": "string"
+ },
+ "phone": {
+ "description": "South African phone number, checked before checkout creation",
+ "type": "string"
+ }
+}Input schema / properties / items / itemsAdded value: +{
+ "properties": {
+ "colour": {
+ "description": "Exact available colour; validate with configure_product before adding",
+ "minLength": 1,
+ "type": "string"
+ },
+ "finish": {
+ "description": "Optional pricing finish for aluminium Venetians",
+ "type": "string"
+ },
+ "height_mm": {
+ "description": "Actual ordered drop in millimetres",
+ "exclusiveMinimum": 0,
+ "type": "number"
+ },
+ "mount_type": {
+ "description": "Use inside for recess fit or outside for face fix",
+ "minLength": 1,
+ "type": "string"
+ },
+ "product_id": {
+ "description": "product_id returned by search_catalog or lookup_catalog",
+ "type": "string"
+ },
+ "product_name": {
+ "description": "Optional; server resolves the catalogue name",
+ "type": "string"
+ },
+ "quantity": {
+ "description": "Number of blinds; defaults to 1",
+ "type": "number"
+ },
+ "total_price_zar": {
+ "description": "Optional, ignored: server recalculates all totals",
+ "type": "number"
+ },
+ "unit_price_zar": {
+ "description": "Optional, ignored: server recalculates all prices",
+ "type": "number"
+ },
+ "width_mm": {
+ "description": "Actual ordered width in millimetres",
+ "exclusiveMinimum": 0,
+ "type": "number"
+ }
+ },
+ "required": [
+ "product_id",
+ "width_mm",
+ "height_mm",
+ "colour",
+ "mount_type"
+ ],
+ "type": "object"
+}Input schema / properties / op / defaultAdded value: +"set"Output schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "cart_id": {
+ "type": "string"
+ },
+ "created_at": {
+ "type": "string"
+ },
+ "currency": {
+ "const": "ZAR",
+ "type": "string"
+ },
+ "customer": {
+ "anyOf": [
+ {
+ "additionalProperties": true,
+ "properties": {
+ "address": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "city": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "email": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "phone": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "expires_at": {
+ "type": "string"
+ },
+ "item_count": {
+ "type": "number"
+ },
+ "items": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour": {
+ "type": "string"
+ },
+ "finish": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "height_mm": {
+ "type": "number"
+ },
+ "mount_type": {
+ "type": "string"
+ },
+ "product_id": {
+ "type": "string"
+ },
+ "product_name": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "total_price_zar": {
+ "type": "number"
+ },
+ "unit_price_zar": {
+ "type": "number"
+ },
+ "width_mm": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "product_id",
+ "width_mm",
+ "height_mm",
+ "quantity",
+ "unit_price_zar",
+ "total_price_zar"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "total_zar": {
+ "type": "number"
+ },
+ "updated_at": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "cart_id",
+ "items",
+ "item_count",
+ "total_zar",
+ "currency",
+ "customer",
+ "created_at",
+ "updated_at",
+ "expires_at"
+ ],
+ "type": "object"
+}update_checkout2 fields changedInput schema / properties / customer / propertiesAdded value: +{
+ "address": {
+ "type": "string"
+ },
+ "city": {
+ "type": "string"
+ },
+ "email": {
+ "description": "Real customer email, checked before checkout creation",
+ "type": "string"
+ },
+ "name": {
+ "description": "Real customer name, checked before checkout creation",
+ "type": "string"
+ },
+ "phone": {
+ "description": "South African phone number, checked before checkout creation",
+ "type": "string"
+ }
+}Output schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "properties": {
+ "ap2": {
+ "additionalProperties": true,
+ "properties": {
+ "merchant_authorization": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "merchant_authorization"
+ ],
+ "type": "object"
+ },
+ "checkout_id": {
+ "type": "string"
+ },
+ "created_at": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "currency": {
+ "const": "ZAR",
+ "type": "string"
+ },
+ "customer": {
+ "additionalProperties": true,
+ "properties": {
+ "address": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "city": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "email": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "phone": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "item_count": {
+ "type": "number"
+ },
+ "items": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "colour": {
+ "type": "string"
+ },
+ "finish": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "height": {
+ "type": "number"
+ },
+ "mountType": {
+ "type": "string"
+ },
+ "price": {
+ "type": "number"
+ },
+ "productId": {
+ "type": "string"
+ },
+ "productName": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "number"
+ },
+ "total": {
+ "type": "number"
+ },
+ "width": {
+ "type": "number"
+ }
+ },
+ "required": [],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "message": {
+ "type": "string"
+ },
+ "next_step": {
+ "type": "string"
+ },
+ "payment_method": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "payment_status": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "payment_url": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "provider_reference": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "status": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "total_zar": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "checkout_id",
+ "status",
+ "total_zar",
+ "currency"
+ ],
+ "type": "object"
+}cancel_cartcancel_checkoutcheck_colour_stockcomplete_checkoutconfigure_productcreate_cartcreate_checkoutcreate_orderget_ar_visualizer_urlget_cartget_checkoutget_delivery_estimateget_orderget_payment_methodsget_priceget_productget_product_recommendationget_whatsapp_handofflookup_catalogrequest_price_matchrequest_swatchsearch_catalogsearch_productssubmit_enquiryupdate_cartupdate_checkout
Add one secure layer between your agents and this server.