Airbnb Replier: Automated Guest Communication with Human-in-the-Loop Approval

graph TD
    A[Airbnb Messages] --> B[n8n Monitor]
    B --> C[Message Classification]
    C --> D[Google ADK Agent]
    D --> E[Draft Response]
    E --> F[Slack Notification]
    F --> G{Human Approval}
    G -->|Approve| H[Send Response]
    G -->|Edit| I[Modify Response]
    G -->|Reject| J[Manual Response]
    I --> H

// n8n workflow configuration
{
  "name": "Airbnb Message Monitor",
  "nodes": [
    {
      "name": "Gmail Trigger",
      "type": "n8n-nodes-base.gmail",
      "parameters": {
        "pollTimes": {
          "item": [
            {
              "mode": "everyMinute",
              "value": 2
            }
          ]
        },
        "filters": {
          "from": "automated@airbnb.com",
          "subject": "New message from"
        }
      }
    },
    {
      "name": "Extract Message Data",
      "type": "n8n-nodes-base.function",
      "parameters": {
        "functionCode": `
          const emailBody = items[0].json.body;
          const guestName = extractGuestName(emailBody);
          const messageContent = extractMessageContent(emailBody);
          const reservationId = extractReservationId(emailBody);
 
          return [{
            json: {
              guestName,
              messageContent,
              reservationId,
              timestamp: new Date().toISOString()
            }
          }];
        `
      }
    },
    {
      "name": "Call AI Agent",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "https://your-fastapi-service.com/process-message",
        "method": "POST",
        "body": {
          "guest_name": "={{$json.guestName}}",
          "message": "={{$json.messageContent}}",
          "reservation_id": "={{$json.reservationId}}"
        }
      }
    }
  ]
}

from google.adk import Agent, Tool
from fastapi import FastAPI, BackgroundTasks
from pydantic import BaseModel
import asyncio
 
app = FastAPI()
 
class MessageRequest(BaseModel):
    guest_name: str
    message: str
    reservation_id: str
    property_id: str
 
class ResponseResult(BaseModel):
    draft_response: str
    confidence_score: float
    requires_human_review: bool
    suggested_actions: list[str]
 
# Initialize ADK Agent with tools
agent = Agent(
    name="airbnb-guest-assistant",
    tools=[
        PropertyInfoTool(),
        CheckInInstructionsTool(),
        LocalRecommendationsTool(),
        WeatherTool(),
        EmergencyContactTool()
    ]
)
 
@app.post("/process-message", response_model=ResponseResult)
async def process_guest_message(request: MessageRequest):
    # Analyze message intent and context
    intent = await analyze_message_intent(request.message)
 
    # Get property-specific context
    property_context = await get_property_context(request.property_id)
 
    # Generate response using ADK agent
    prompt = f"""
    You are a helpful Airbnb host assistant. A guest named {request.guest_name}
    has sent the following message about their reservation {request.reservation_id}:
 
    "{request.message}"
 
    Property Context: {property_context}
 
    Generate a warm, helpful response that addresses their inquiry completely.
    If you need additional information, use the available tools.
    """
 
    response = await agent.generate_response(prompt)
 
    # Calculate confidence and determine if human review is needed
    confidence = calculate_response_confidence(request.message, response)
    needs_review = should_require_human_review(intent, confidence)
 
    # Send to Slack for approval if needed
    if needs_review:
        await send_slack_approval_request(request, response)
 
    return ResponseResult(
        draft_response=response,
        confidence_score=confidence,
        requires_human_review=needs_review,
        suggested_actions=get_suggested_actions(intent)
    )

import slack_sdk
from slack_sdk.web import WebClient
 
class SlackApprovalSystem:
    def __init__(self, bot_token: str):
        self.client = WebClient(token=bot_token)
 
    async def send_approval_request(self, guest_message: str, draft_response: str,
                                  guest_name: str, reservation_id: str):
        blocks = [
            {
                "type": "header",
                "text": {
                    "type": "plain_text",
                    "text": f"📨 New message from {guest_name}"
                }
            },
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f"*Guest Message:*\n> {guest_message}"
                }
            },
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f"*Suggested Response:*\n```{draft_response}```"
                }
            },
            {
                "type": "actions",
                "elements": [
                    {
                        "type": "button",
                        "text": {"type": "plain_text", "text": "✅ Approve & Send"},
                        "style": "primary",
                        "action_id": "approve_response",
                        "value": reservation_id
                    },
                    {
                        "type": "button",
                        "text": {"type": "plain_text", "text": "✏️ Edit Response"},
                        "action_id": "edit_response",
                        "value": reservation_id
                    },
                    {
                        "type": "button",
                        "text": {"type": "plain_text", "text": "❌ Handle Manually"},
                        "style": "danger",
                        "action_id": "manual_response",
                        "value": reservation_id
                    }
                ]
            }
        ]
 
        result = await self.client.chat_postMessage(
            channel="#guest-communications",
            blocks=blocks
        )
 
        return result

@app.post("/slack/approval")
async def handle_slack_approval(payload: dict):
    action = payload['actions'][0]
    reservation_id = action['value']
 
    if action['action_id'] == 'approve_response':
        # Send the approved response
        await send_airbnb_response(reservation_id, get_draft_response(reservation_id))
        await update_approval_status(reservation_id, 'approved')
 
    elif action['action_id'] == 'edit_response':
        # Open modal for editing
        await open_edit_modal(payload['trigger_id'], reservation_id)
 
    elif action['action_id'] == 'manual_response':
        # Mark for manual handling
        await update_approval_status(reservation_id, 'manual')
        await notify_manual_intervention_needed(reservation_id)
 
    return {"status": "success"}