Abandoned Cart Recovery

import { createTool, KV } from '@runflow-ai/sdk';
import { z } from 'zod';

const CART_TTL = 24 * 3600; // cart expires after 24h of inactivity

export function createCartTools(phone: string) {
  const carts = KV.namespace('carts');
  const cartKey = `cart:${phone}`;

  const addToCart = createTool({
    id: 'add-to-cart',
    description: 'Add an item to the customer cart. Use whenever the customer decides on a product.',
    inputSchema: z.object({
      sku: z.string(),
      name: z.string(),
      quantity: z.number().min(1),
      unitPrice: z.number(),
    }),
    execute: async (item) => {
      const cart = (await carts.get<{ items: any[] }>(cartKey)) ?? { items: [] };
      cart.items.push(item);

      // Every write refreshes the TTL — activity keeps the cart alive
      await carts.set(cartKey, cart, { ttl: CART_TTL });
      return { itemCount: cart.items.length };
    },
  });

  const viewCart = createTool({
    id: 'view-cart',
    description: 'Show the current cart contents and total.',
    inputSchema: z.object({}),
    execute: async () => {
      const cart = await carts.get<{ items: any[] }>(cartKey);
      if (!cart) return { empty: true };
      const total = cart.items.reduce((s, i) => s + i.quantity * i.unitPrice, 0);
      return { items: cart.items, total };
    },
  });

  const checkout = createTool({
    id: 'checkout',
    description: 'Close the order and generate a payment link. Use when the customer confirms the purchase.',
    inputSchema: z.object({}),
    execute: async () => {
      const cart = await carts.get<{ items: any[] }>(cartKey);
      if (!cart) return { error: 'Cart is empty' };

      const order = await createOrder(phone, cart.items); // your order system
      await carts.delete(cartKey); // cart fulfilled — remove it

      return { paymentLink: order.paymentLink, orderId: order.id };
    },
  });

  return { addToCart, viewCart, checkout };
}

import { Agent, openai } from '@runflow-ai/sdk';
import { createCartTools } from './tools/cart-tools';

export function createSalesAgent(phone: string) {
  const { addToCart, viewCart, checkout } = createCartTools(phone);

  return new Agent({
    name: 'Sales Agent',
    instructions: `You sell products for ACME Store via WhatsApp.

## Tools — when to use each
- **add-to-cart**: whenever the customer decides on a product and quantity.
- **view-cart**: when the customer asks what's in the cart, or before checkout.
- **checkout**: when the customer confirms they want to buy.

## Cart recovery follow-ups
When asked to recover an abandoned cart, mention the items by name,
offer help finishing the order, and keep it short and friendly.
Never pressure. One message only.`,

    model: openai('gpt-4o'),
    tools: { addToCart, viewCart, checkout },

    memory: {
      maxTurns: 30,
      summarizeAfter: 20,
      summarizePrompt: 'Summarize: customer name, products discussed, sizes/preferences, objections.',
    },
  });
}

import { identify } from '@runflow-ai/sdk/observability';
import { createSalesAgent } from './agent';

export default async function main(input: { message: string; phone: string }) {
  // Bind conversation memory to the customer
  identify(input.phone);

  const agent = createSalesAgent(input.phone);
  return agent.process({ message: input.message });
}

import { KV } from '@runflow-ai/sdk';
import { createSalesAgent } from './agent';

const IDLE_MS = 2 * 60 * 60 * 1000; // nudge after 2h of silence

export default async function recovery() {
  const carts = KV.namespace('carts');
  const reminders = KV.namespace('cart-reminders');

  const { items } = await carts.listEntries({ pattern: 'cart:*', limit: 500 });
  const cutoff = Date.now() - IDLE_MS;

  for (const entry of items) {
    // Not idle long enough yet
    if (new Date(entry.updatedAt).getTime() > cutoff) continue;

    // Already reminded — never nudge twice (idempotency via KV)
    if (await reminders.has(entry.key)) continue;

    const phone = entry.key.replace('cart:', '');
    const itemNames = entry.value.items.map((i: any) => i.name).join(', ');

    const agent = createSalesAgent(phone);
    await agent.process({
      message: `The customer left these items in the cart 2+ hours ago: ${itemNames}. Send a friendly recovery message.`,
      entityType: 'phone',
      entityValue: phone,
      channel: 'whatsapp',
    });

    // Reminder marker expires with the same window as the cart
    await reminders.set(entry.key, { at: new Date().toISOString() }, { ttl: 24 * 3600 });
  }
}