#WhatsApp Support Bot with OpenClaw and MoltFlow

Customer → WhatsApp → MoltFlow → Your Server → OpenClaw Agent
                           ↑                          ↓
                           └──────── Response ────────┘

curl -X POST https://apiv2.waiflow.app/api/v2/sessions \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "support-bot",
    "status": "starting"
  }'

curl -X POST https://apiv2.waiflow.app/api/v2/webhooks \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-server.com/webhook/whatsapp",
    "events": ["message"]
  }'

pip install openclaw-sdk

from openclaw import Agent, Skill
from openclaw.skills import FAQRetriever, TicketCreator

# Define your agent with a clear system prompt
support_agent = Agent(
    name="WhatsApp Support Bot",
    system_prompt="""You are a helpful customer support agent for our e-commerce platform.
    Your job is to answer customer questions, help troubleshoot issues, and escalate
    complex problems to human agents when necessary.

    Keep responses concise (WhatsApp users expect quick replies).
    Use plain text only—WhatsApp doesn't render markdown well.
    If you don't know the answer, admit it and offer to connect them with a human.
    Be warm but professional. No emojis unless the customer uses them first.""",

    skills=[
        FAQRetriever(knowledge_base="./data/faq.json"),
        TicketCreator(ticketing_system="zendesk"),
    ],

    model="gpt-4o",  # or claude-3-5-sonnet, whatever you prefer
    temperature=0.7
)

{
  "faqs": [
    {
      "question": "What's your return policy?",
      "answer": "We accept returns within 30 days of purchase. Items must be unused with original packaging. Start a return through your order page."
    },
    {
      "question": "How do I track my order?",
      "answer": "Check your order status at example.com/orders using the email you provided at checkout."
    }
  ]
}

from fastapi import FastAPI, Request
import httpx
from openclaw import Agent

app = FastAPI()

# Your support agent instance (defined above)
support_agent = Agent(...)

# MoltFlow API credentials
MOLTFLOW_API_TOKEN = "your_token_here"
MOLTFLOW_API_BASE = "https://apiv2.waiflow.app/api/v2"

@app.post("/webhook/whatsapp")
async def handle_whatsapp_message(request: Request):
    """Receives messages from MoltFlow, processes with OpenClaw, replies via API."""

    # Parse incoming webhook payload
    payload = await request.json()

    # Extract relevant fields
    message_text = payload["data"]["body"]  # Customer's message
    sender_id = payload["data"]["from"]  # Customer's WhatsApp ID
    session_name = payload["session"]  # Your MoltFlow session name

    # Pass message to OpenClaw agent for processing
    agent_response = await support_agent.process(
        input_text=message_text,
        context={"sender_id": sender_id}  # Include sender for conversation memory
    )

    # Send agent's response back via MoltFlow API
    async with httpx.AsyncClient() as client:
        await client.post(
            f"{MOLTFLOW_API_BASE}/sessions/{session_name}/messages",
            headers={
                "Authorization": f"Bearer {MOLTFLOW_API_TOKEN}",
                "Content-Type": "application/json"
            },
            json={
                "chatId": sender_id,
                "text": agent_response.text
            }
        )

    return {"status": "ok"}

system_prompt="""...
If the customer explicitly asks for a human ("speak to a person", "I want to talk to someone"),
or if you've failed to resolve the issue after 3 exchanges, respond with:
'I'll connect you with one of our support specialists. One moment please.'
Then escalate.
"""

from openclaw import Skill

class HumanEscalation(Skill):
    """Forwards conversation to support team WhatsApp group."""

    def __init__(self, support_group_id: str):
        self.support_group_id = support_group_id

    async def execute(self, context: dict):
        """Send message to support group with customer context."""

        sender = context["sender_id"]
        conversation_summary = context.get("conversation_summary", "No summary available")

        # Notify support team via group message
        async with httpx.AsyncClient() as client:
            await client.post(
                f"{MOLTFLOW_API_BASE}/sessions/support-bot/messages",
                headers={"Authorization": f"Bearer {MOLTFLOW_API_TOKEN}"},
                json={
                    "chatId": self.support_group_id,  # Support team group ID
                    "text": f"🚨 Escalation Request\n\nCustomer: {sender}\n\nSummary:\n{conversation_summary}\n\nPlease respond directly to the customer."
                }
            )

        return "Escalated to support team"

conversation_history = {}  # sender_id -> list of messages

@app.post("/webhook/whatsapp")
async def handle_whatsapp_message(request: Request):
    payload = await request.json()
    message_text = payload["data"]["body"]
    sender_id = payload["data"]["from"]

    # Retrieve or initialize conversation history
    if sender_id not in conversation_history:
        conversation_history[sender_id] = []

    history = conversation_history[sender_id]
    history.append({"role": "user", "content": message_text})

    # Pass full conversation to agent
    agent_response = await support_agent.process(
        input_text=message_text,
        conversation_history=history,
        context={"sender_id": sender_id}
    )

    # Store agent's response in history
    history.append({"role": "assistant", "content": agent_response.text})

    # Keep only last 10 messages to avoid token bloat
    conversation_history[sender_id] = history[-10:]

    # Send response via MoltFlow
    # ... (same as before)

system_prompt="""...
Detect the customer's language and respond in the same language.
If unsure, default to English.
"""