@alexkroman1/aai-cli 7.0.0 → 8.1.0

package/dist/templates/retail/store.ts

@@ -76,51 +76,50 @@ export const retailSlot = sessionSlot("retail", createDefaultState);
 /**
  * Where this call is, and what may be done from here, as a plain state map.
  *
- * A {@link DialogSpec} rather than an XState machine: this dialog said three
- * states, two events and an instruction each, which is exactly what a spec can
- * say — and the `setup({ types: {} as { events: … } })` block it used to carry
- * restated the two event names already written in the `on` maps. The
- * instruction is a declared field now instead of an untyped `meta` bag, so
- * misspelling it is a compile error rather than a refusal that arrives with no
- * recovery text. `as const` is what keeps the `on` keys literal, so `send`
- * below is checked against the events this spec actually declares.
+ * A {@link DialogSpec} rather than an XState machine: everything this dialog
+ * says is states, events and an instruction each, which is exactly what a spec
+ * can say. The instruction is a declared field instead of an untyped `meta`
+ * bag, so misspelling it is a compile error rather than a refusal that arrives
+ * with no recovery text. `as const` is what keeps the `on` keys literal, so
+ * `send` below is checked against the events this spec actually declares.
  *
- * The policy's first two sections — "Authenticate first" and "Handing off to a
- * human" — used to be prose plus a boolean. `requiresAuth` was that boolean:
- * fifteen tools declared it (five opting out), the wrapper below read it, and a
- * refusal answered one fixed sentence. Three things change by declaring the
- * states instead.
+ * Three of the policy's sections live here rather than in prose.
  *
- * **`transferred` is a real terminal state, and it was not enforced at all.**
- * The policy says to call `transfer_to_human_agents` and then say exactly one
- * sentence "and nothing else" — which nothing checked, so every tool stayed
- * callable after the handoff and a model that kept going would keep acting on a
- * call it had already given away. It is a `final` state now: no tool declares
- * itself legal there, so every one of them refuses.
+ * **"Authenticate first."** `identifying`'s instruction names both finder
+ * tools, and ten tools declare `when: "serving"`, so the gate is the SDK's.
  *
- * **The refusal quotes the state.** `when` names where a tool may run and the
- * SDK writes the sentence, so the message is one thing rather than a constant
- * threaded through a wrapper — and it says where the call actually is, which
- * "Not authenticated" could not.
+ * **"Handing off to a human."** The policy says to call
+ * `transfer_to_human_agents` and then say exactly one sentence "and nothing
+ * else" — which nothing checked, so every tool stayed callable after the handoff
+ * and a model that kept going kept acting on a call it had already given away.
+ * `transferred` is a `final` state: no tool declares itself legal there, so
+ * every one of them refuses. `TRANSFERRED` sits on the `serving` PARENT so it
+ * is reachable from either child — a caller asking for a human mid-confirmation
+ * must get one.
  *
- * **The position rides every result.** A flow tool answers the author's value
- * wrapped in the position it landed in, so the stage and its instruction reach
- * the model on every call rather than only when the prompt is still in context.
+ * **"Confirm every change out loud."** This was the last rule in the policy
+ * carried by nothing at all, and it is `serving`'s two children now. Nothing in
+ * this template mutates the store except `confirm_change`, which is legal only
+ * in `awaitingConfirmation`, which is reachable only by staging a change. See
+ * `pending.ts` for what that buys and what it still cannot promise.
  *
- * `IDENTIFIED` is declared on `serving` as well, because a caller repeating
- * their email must not hit an error — see `authenticateAs`, which is what
- * refuses a switch to a DIFFERENT customer. Whether the flow is identified and
- * WHO it is identified as are two facts: this holds the first,
- * `authenticatedUserId` holds the second.
+ * **`IDENTIFIED` is deliberately NOT declared on `serving`.** It was, while
+ * `serving` was a leaf, so that a caller repeating their email did not hit an
+ * error. Now that `serving` has children, a self-transition would RE-ENTER it
+ * and reset to `helping` — stranding a staged change that `state.pending` still
+ * holds, which is the one way the position and the store could come to
+ * disagree. An event no active state handles is ignored, and ignoring it is
+ * exactly right: re-identifying the same customer does not move the call.
+ * `authenticateAs` is what refuses a switch to a DIFFERENT customer. Whether
+ * the call is identified and WHO it is identified as are two facts: this holds
+ * the first, `authenticatedUserId` holds the second.
  */
 const callSpec = {
   initial: "identifying",
   states: {
     identifying: {
       // The instruction NAMES the two tools, because this sentence is what a
-      // refusal quotes and a refusal is the model's recovery path — the same
-      // job the removed `NOT_AUTHENTICATED` constant did, now attached to the
-      // state that means it.
+      // refusal quotes and a refusal is the model's recovery path.
       instruction:
         "You do not know who this is yet. Identify the caller with " +
         "find_user_id_by_email, or find_user_id_by_name_zip if they cannot " +
@@ -128,11 +127,25 @@ const callSpec = {
       on: { IDENTIFIED: "serving", TRANSFERRED: "transferred" },
     },
     serving: {
-      instruction:
-        "You are helping one identified customer, and only that one. Say what you " +
-        "are about to change — the order, the items, the amounts, where the money " +
-        "goes — and wait for an explicit yes before you call anything that changes it.",
-      on: { IDENTIFIED: "serving", TRANSFERRED: "transferred" },
+      initial: "helping",
+      on: { TRANSFERRED: "transferred" },
+      states: {
+        helping: {
+          instruction:
+            "You are helping one identified customer, and only that one. Nothing is " +
+            "waiting on their word. A tool that changes something only STAGES it and " +
+            "hands you a sentence to read back.",
+          on: { STAGED: "awaitingConfirmation" },
+        },
+        awaitingConfirmation: {
+          instruction:
+            "A change is staged and NOTHING HAS HAPPENED YET. Read the staged sentence " +
+            "back — the order, the items, the amounts, where the money goes — and wait " +
+            "for an explicit yes. Then call confirm_change, or cancel_change if they " +
+            "say no or want to change any part of it.",
+          on: { SETTLED: "helping" },
+        },
+      },
     },
     transferred: {
       final: true,
@@ -145,13 +158,19 @@ const callSpec = {
 
 /**
  * The flow. Its own slot key beside {@link retailSlot}: the flow holds the
- * POSITION and the store holds the customer, the orders and the activity feed.
+ * POSITION and the store holds the customer, the orders, the activity feed and
+ * the staged change itself, because an inspectable {@link PendingAction} is
+ * what `confirm_change` applies. One tool call always moves both — a staging
+ * tool writes `pending` and sends `STAGED` in the same synchronous window.
  */
 export const callFlow = dialog("call", callSpec);
 
 /** Every state a tool may run in before the call is handed to a human — i.e.
- *  everything but `transferred`. What the five formerly `requiresAuth: false`
- *  tools declare, so the terminal state gates them without an auth gate. */
+ *  everything but `transferred`. What the two finders, the three catalog reads
+ *  and the transfer itself declare, so the terminal state gates them without an
+ *  auth gate. `"serving"` matches both of its children, which is what keeps a
+ *  read legal while a change is waiting: a caller who asks "what was the total
+ *  again?" mid-confirmation must be answerable. */
 export const BEFORE_TRANSFER = ["identifying", "serving"] as const;
 
 export function setFocus(
@@ -287,17 +306,27 @@ interface RetailToolSpec<S extends z.ZodType<Record<string, unknown>>, R> {
   /**
    * The state(s) this tool may run in, as `callFlow`'s states spell them.
    *
-   * Replaces the `requiresAuth` boolean this spec used to carry. Ten tools want
-   * `"serving"`; the two finders, the three catalog reads and the transfer want
-   * {@link BEFORE_TRANSFER}, which is every state but the terminal one — so
-   * "does not need a customer" and "is still legal after the handoff" stopped
-   * being the same claim, and they were never the same claim.
+   * Replaces the `requiresAuth` boolean this spec used to carry. Nine tools
+   * want `"serving"` — which matches both of its children, so a read and a
+   * staging tool are equally legal while a change waits; the two settling
+   * tools want `"serving.awaitingConfirmation"`; and the two finders, the three
+   * catalog reads and the transfer want {@link BEFORE_TRANSFER}, which is every
+   * state but the terminal one — so "does not need a customer" and "is still
+   * legal after the handoff" stopped being the same claim, and they were never
+   * the same claim.
    */
   when: string | readonly string[];
   /** The event to send once the body has succeeded, for a tool that MOVES the
-   *  call. Three do: the two finders send `IDENTIFIED`, the transfer sends
-   *  `TRANSFERRED`. Nothing is sent when the body answers a `ToolFailure`. */
-  send?: { type: "IDENTIFIED" } | { type: "TRANSFERRED" };
+   *  call. Twelve do: the two finders send `IDENTIFIED`, the transfer sends
+   *  `TRANSFERRED`, the seven staging tools send `STAGED`, and `confirm_change`
+   *  and `cancel_change` send `SETTLED`. Nothing is sent when the body answers
+   *  a `ToolFailure` — which is what stops a refused stage from moving the call
+   *  into a confirmation with nothing behind it. */
+  send?:
+    | { type: "IDENTIFIED" }
+    | { type: "TRANSFERRED" }
+    | { type: "STAGED" }
+    | { type: "SETTLED" };
   /**
    * One line for the activity feed, from the call that SUCCEEDED.
    *
@@ -336,7 +365,13 @@ interface RetailToolSpec<S extends z.ZodType<Record<string, unknown>>, R> {
   execute: (args: z.output<S>, state: RetailState, ctx: ToolContext) => R | ToolFailure;
 }
 
-function record(state: RetailState, name: string, summary: string): void {
+/**
+ * One line of the activity feed, and the `callSeq` bump the sidebar moves on.
+ *
+ * Exported because {@link retailTool} is no longer its only caller: `agent.ts`
+ * records the calls that never reach a body — see {@link gateFor}.
+ */
+export function record(state: RetailState, name: string, summary: string): void {
   state.callSeq += 1;
   pushCapped(
     state.activity,
@@ -345,6 +380,24 @@ function record(state: RetailState, name: string, summary: string): void {
   );
 }
 
+/**
+ * Which states each retail tool may run in, by the name the model calls it by.
+ *
+ * Populated as the fifteen `tools/` modules are loaded, because {@link retailTool}
+ * is what every one of them calls. It exists so `agent.ts`'s `tool.called` hook
+ * can ask the SAME question the gate asks — this is one fact evaluated twice, not
+ * two copies of a fact.
+ */
+const TOOL_GATES = new Map<string, readonly string[]>();
+
+/**
+ * The states `name` may run in, or `undefined` for a tool this template did not
+ * declare (a builtin, or anything a future author adds outside the wrapper).
+ */
+export function gateFor(name: string): readonly string[] | undefined {
+  return TOOL_GATES.get(name);
+}
+
 /**
  * Every retail tool is built through this. It owns two things no tool body may
  * re-implement:
@@ -355,12 +408,14 @@ function record(state: RetailState, name: string, summary: string): void {
  *
  * The third thing it used to own — the authentication gate — is
  * {@link callFlow}'s now, declared per tool as `when`. What that buys is in the
- * machine's own doc; what it COSTS is one line of the activity feed: a refused
- * call short-circuits before this wrapper's body runs, so a blocked call no
- * longer records `blocked: not authenticated` and no longer bumps `callSeq`.
- * That is the right trade — the refusal reaches the model, which the sidebar
- * line never did, and it carries the state and its instruction rather than one
- * fixed sentence.
+ * machine's own doc; what it COST was one line of the activity feed, because a
+ * refused call short-circuits before this wrapper's body runs and so recorded
+ * nothing and bumped no `callSeq`.
+ *
+ * **That line is back, and not from here.** `agent.ts` declares a `tool.called`
+ * hook, which the runtime emits for every call the model makes INCLUDING the
+ * ones the gate goes on to refuse — a place to observe from that a tool wrapper
+ * structurally does not have. See {@link gateFor}.
  *
  * **`callFlow.tool` rather than `retailSlot.updateTool`**, so the body opens the
  * store's window itself. A flow tool's own `execute` is handed `(args, ctx)`;
@@ -373,6 +428,7 @@ function record(state: RetailState, name: string, summary: string): void {
 export function retailTool<S extends z.ZodType<Record<string, unknown>>, R>(
   spec: RetailToolSpec<S, R>,
 ) {
+  TOOL_GATES.set(spec.name, typeof spec.when === "string" ? [spec.when] : spec.when);
   return callFlow.tool({
     description: spec.description,
     inputSchema: spec.inputSchema,

package/dist/templates/retail/swap.test.ts

@@ -1,7 +1,7 @@
 import { isToolFailure } from "@alexkroman1/aai";
 import { describe, expect, test } from "vitest";
 import { createDefaultState, findUser } from "./store.ts";
-import { applySwap, assertCanCoverDiff, planItemSwap } from "./swap.ts";
+import { applySwapLines, assertCanCoverDiff, planItemSwap, toSwapLines } from "./swap.ts";
 
 function fixture(orderId: string) {
   const state = createDefaultState();
@@ -152,7 +152,7 @@ describe("assertCanCoverDiff", () => {
   });
 });
 
-describe("applySwap", () => {
+describe("applySwapLines", () => {
   test("each swapped line takes its OWN new price and options", () => {
     const { state, order } = fixture("#W9311069");
     // Two different products in one call — this is what catches the leaked
@@ -165,7 +165,7 @@ describe("applySwap", () => {
       { requireDifferent: true },
     );
     if (isToolFailure(plan)) throw new Error(plan.error);
-    applySwap(order, plan);
+    applySwapLines(order, toSwapLines(plan));
 
     const vacuum = order.items.find((i) => i.item_id === "4725166838");
     const kettle = order.items.find((i) => i.item_id === "3909406921");
@@ -183,7 +183,7 @@ describe("applySwap", () => {
       requireDifferent: true,
     });
     if (isToolFailure(plan)) throw new Error(plan.error);
-    applySwap(order, plan);
+    applySwapLines(order, toSwapLines(plan));
     expect(order.items.map((i) => i.item_id)).toEqual(["3909406921", "7292993796"]);
   });
 });

package/dist/templates/retail/swap.ts

@@ -1,6 +1,22 @@
+/**
+ * Swapping items for other options of the same product — the validation both
+ * item changes share, and the two actions built on it (modifying a pending
+ * order, exchanging a delivered one) as plan/apply pairs.
+ *
+ * See `cancel.ts` for why every mutating action is split that way.
+ */
+
 import { isToolFailure, type ToolFailure } from "@alexkroman1/aai";
+import { resolveOrder } from "./resolve.ts";
 import type { Order, OrderItem, RetailState, User, Variant } from "./shared.ts";
-import { findPaymentMethod, findProduct, findVariant, isGiftCard, money } from "./store.ts";
+import {
+  authenticatedUser,
+  findPaymentMethod,
+  findProduct,
+  findVariant,
+  isGiftCard,
+  money,
+} from "./store.ts";
 
 export interface SwapPair {
   /** Index into `order.items`. Matching by index rather than by "first item
@@ -17,12 +33,30 @@ export interface SwapPlan {
 }
 
 /**
- * Validate a proposed item swap and compute its price difference, without
- * mutating anything. Shared by `modify_pending_order_items` (pending, which
- * additionally forbids a no-op swap) and `exchange_delivered_order_items`
- * (delivered, which does not).
+ * One priced swap, flattened to primitives.
  *
- * Validation order matches tau2's so a bad call fails on the same check.
+ * A {@link SwapPair} holds live `OrderItem` and `Variant` references into the
+ * store, which is right for a plan computed and applied inside one tool call
+ * and wrong for one that waits in a session slot for the caller to say yes —
+ * see `CancelPlan` in `cancel.ts`. This is the storable form, and it carries enough that
+ * {@link applySwapLines} needs no lookup at all.
+ */
+export interface SwapLine {
+  index: number;
+  fromItemId: string;
+  fromName: string;
+  fromOptions: Record<string, string>;
+  fromPrice: number;
+  toItemId: string;
+  toName: string;
+  toOptions: Record<string, string>;
+  toPrice: number;
+}
+
+/**
+ * Validate a proposed item swap and compute its price difference, without
+ * mutating anything. Shared by the pending-order change (which additionally
+ * forbids a no-op swap) and the delivered-order exchange (which does not).
  */
 export function planItemSwap(
   state: RetailState,
@@ -103,6 +137,23 @@ export function planItemSwap(
   return { pairs, diff: money(diff) };
 }
 
+/** Flatten a freshly-computed plan into the form a staged action can hold. */
+export function toSwapLines(plan: SwapPlan): SwapLine[] {
+  return plan.pairs.map((pair) => ({
+    index: pair.index,
+    fromItemId: pair.item.item_id,
+    fromName: pair.item.name,
+    fromOptions: { ...pair.item.options },
+    fromPrice: pair.item.price,
+    toItemId: pair.newVariant.item_id,
+    // Same product by construction — a swap can only reach another option of
+    // it — so the name is the item's own and the OPTIONS are what differ.
+    toName: pair.item.name,
+    toOptions: { ...pair.newVariant.options },
+    toPrice: pair.newVariant.price,
+  }));
+}
+
 /**
  * Gate the price difference on the chosen payment method. Only a gift card has
  * a balance to run out of; a negative difference is a refund and never gated.
@@ -118,14 +169,196 @@ export function assertCanCoverDiff(user: User, methodId: string, diff: number):
   return null;
 }
 
-/** Apply a validated plan. Each line takes its OWN new variant's price, options
- *  and name — see the module note on tau2's leaked loop variable. */
-export function applySwap(order: Order, plan: SwapPlan): void {
-  for (const pair of plan.pairs) {
-    const line = order.items[pair.index];
-    if (!line) continue;
-    line.item_id = pair.newVariant.item_id;
-    line.price = pair.newVariant.price;
-    line.options = pair.newVariant.options;
+/** Apply validated lines. Each takes its OWN new option's price and options —
+ *  see the module note on tau2's leaked loop variable. */
+export function applySwapLines(order: Order, lines: readonly SwapLine[]): void {
+  for (const line of lines) {
+    const item = order.items[line.index];
+    if (!item) continue;
+    item.item_id = line.toItemId;
+    item.price = line.toPrice;
+    item.options = { ...line.toOptions };
+  }
+}
+
+/** "the glass 2 litre one for the stainless steel 1 litre one" — how a swap is
+ *  said out loud. Item numbers are never in it; the prompt forbids reading one. */
+function describeLine(line: SwapLine): string {
+  const from = Object.values(line.fromOptions).join(" ");
+  const to = Object.values(line.toOptions).join(" ");
+  return `the ${from} ${line.fromName} for the ${to} one`;
+}
+
+function describeDiff(diff: number, methodId: string): string {
+  if (diff > 0) return `$${diff.toFixed(2)} charged to ${methodId}`;
+  if (diff < 0) return `$${Math.abs(diff).toFixed(2)} refunded to ${methodId}`;
+  return "no price difference";
+}
+
+// ─── Changing the items in a pending order ───────────────────────────────────
+
+export interface ModifyItemsPlan {
+  readBack: string;
+  orderId: string;
+  lines: SwapLine[];
+  diff: number;
+  paymentMethodId: string;
+}
+
+export function planModifyItems(
+  state: RetailState,
+  spokenOrderId: string,
+  itemIds: string[],
+  newItemIds: string[],
+  paymentMethodId: string,
+): ModifyItemsPlan | ToolFailure {
+  const user = authenticatedUser(state);
+  if (isToolFailure(user)) return user;
+
+  const order = resolveOrder(state, spokenOrderId);
+  if (isToolFailure(order)) return order;
+
+  // Exactly 'pending'. A 'pending (item modified)' order has already used its
+  // one modification, which is what makes this action terminal.
+  if (order.status !== "pending") {
+    return {
+      error: `Order ${order.order_id} is ${order.status}. Items can only be changed while an order is exactly 'pending', and only once.`,
+    };
+  }
+
+  const plan = planItemSwap(state, order, itemIds, newItemIds, { requireDifferent: true });
+  if (isToolFailure(plan)) return plan;
+
+  const blocked = assertCanCoverDiff(user, paymentMethodId, plan.diff);
+  if (blocked) return blocked;
+
+  const lines = toSwapLines(plan);
+  return {
+    readBack:
+      `swap ${lines.map(describeLine).join(", and ")} on order ${order.order_id}, ` +
+      `with ${describeDiff(plan.diff, paymentMethodId)} — and this is the ONE change that order ` +
+      "allows: after it, it can no longer be cancelled or modified by anyone",
+    orderId: order.order_id,
+    lines,
+    diff: plan.diff,
+    paymentMethodId,
+  };
+}
+
+export function applyModifyItems(state: RetailState, plan: ModifyItemsPlan) {
+  const order = state.store.orders[plan.orderId];
+  const user = order ? state.store.users[order.user_id] : undefined;
+
+  if (order && user) {
+    const method = user.payment_methods[plan.paymentMethodId];
+    if (method && isGiftCard(method)) {
+      method.balance = money(method.balance - plan.diff);
+    }
+    order.payment_history.push({
+      transaction_type: plan.diff > 0 ? "payment" : "refund",
+      amount: money(Math.abs(plan.diff)),
+      payment_method_id: plan.paymentMethodId,
+    });
+    applySwapLines(order, plan.lines);
+    order.status = "pending (item modified)";
   }
+
+  return {
+    order_id: plan.orderId,
+    status: "pending (item modified)" as const,
+    price_difference: plan.diff,
+    items: (order?.items ?? []).map((item) => ({
+      name: item.name,
+      item_id: item.item_id,
+      options: item.options,
+      price: item.price,
+    })),
+    message:
+      plan.diff > 0
+        ? `Done. $${plan.diff.toFixed(2)} was charged to ${plan.paymentMethodId}. This order can no longer be modified or cancelled.`
+        : `Done. $${Math.abs(plan.diff).toFixed(2)} is being refunded to ${plan.paymentMethodId}. This order can no longer be modified or cancelled.`,
+  };
+}
+
+// ─── Exchanging a delivered order ────────────────────────────────────────────
+
+export interface ExchangePlan {
+  readBack: string;
+  orderId: string;
+  lines: SwapLine[];
+  diff: number;
+  paymentMethodId: string;
+}
+
+export function planExchange(
+  state: RetailState,
+  spokenOrderId: string,
+  itemIds: string[],
+  newItemIds: string[],
+  paymentMethodId: string,
+): ExchangePlan | ToolFailure {
+  const user = authenticatedUser(state);
+  if (isToolFailure(user)) return user;
+
+  const order = resolveOrder(state, spokenOrderId);
+  if (isToolFailure(order)) return order;
+
+  if (order.status !== "delivered") {
+    return {
+      error: `Order ${order.order_id} is ${order.status}. Only a delivered order can be exchanged, and only once.`,
+    };
+  }
+
+  // requireDifferent is false: a zero-difference line is harmless on a
+  // delivered order, and refusing one would reject a caller who listed every
+  // item and changed their mind about only some.
+  const plan = planItemSwap(state, order, itemIds, newItemIds, { requireDifferent: false });
+  if (isToolFailure(plan)) return plan;
+
+  const blocked = assertCanCoverDiff(user, paymentMethodId, plan.diff);
+  if (blocked) return blocked;
+
+  const lines = toSwapLines(plan);
+  return {
+    readBack:
+      `exchange ${lines.map(describeLine).join(", and ")} on order ${order.order_id}, ` +
+      `with ${describeDiff(plan.diff, paymentMethodId)}`,
+    orderId: order.order_id,
+    lines,
+    diff: plan.diff,
+    paymentMethodId,
+  };
+}
+
+export function applyExchange(state: RetailState, plan: ExchangePlan) {
+  const order = state.store.orders[plan.orderId];
+
+  // The pairing AS PRICED, in the order the caller gave it. tau2 stored these
+  // as two INDEPENDENTLY SORTED lists, which permuted the second against the
+  // first whenever more than one item was named — two sets, not a pairing, and
+  // the result had to carry the real pairing separately to avoid telling the
+  // caller a quote that was not the one they got. Nothing here is compared
+  // against a tau2 end state any more, so the fields hold the pairing itself.
+  if (order) {
+    order.status = "exchange requested";
+    order.exchange_items = plan.lines.map((line) => line.fromItemId);
+    order.exchange_new_items = plan.lines.map((line) => line.toItemId);
+    order.exchange_payment_method_id = plan.paymentMethodId;
+    order.exchange_price_difference = plan.diff;
+  }
+
+  return {
+    order_id: plan.orderId,
+    status: "exchange requested" as const,
+    price_difference: plan.diff,
+    exchanges: plan.lines.map((line) => ({
+      item_id: line.fromItemId,
+      new_item_id: line.toItemId,
+      price_difference: money(line.toPrice - line.fromPrice),
+    })),
+    message:
+      plan.diff > 0
+        ? `Exchange requested on ${plan.orderId}. $${plan.diff.toFixed(2)} will be charged to ${plan.paymentMethodId}. An email with return instructions is on its way.`
+        : `Exchange requested on ${plan.orderId}. $${Math.abs(plan.diff).toFixed(2)} will be refunded to ${plan.paymentMethodId}. An email with return instructions is on its way.`,
+  };
 }