WhatsApp: Multi-WABA Same-Business Shared Memory

pip install maximem-synap maximem-synap-openai-agents openai-agents heyoo

uv add maximem-synap maximem-synap-openai-agents openai-agents heyoo
# pip-compatible (existing venv): uv pip install maximem-synap maximem-synap-openai-agents openai-agents heyoo

npm install @maximem/synap-js-sdk @maximem/synap-vercel-adk ai @ai-sdk/openai

PERSONAS = {
    "1066…sales":   {"name": "sales",   "model": "gpt-4o",      "system": SALES_SYSTEM},
    "1066…support": {"name": "support", "model": "gpt-4o-mini", "system": SUPPORT_SYSTEM},
    "1066…vip":     {"name": "vip",     "model": "gpt-4o",      "system": VIP_SYSTEM},
}

def persona_for(phone_number_id: str) -> dict:
    persona = PERSONAS.get(phone_number_id)
    if not persona:
        raise ValueError(f"Unknown WABA phone_number_id: {phone_number_id}")
    return persona

const PERSONAS: Record<string, { name: string; model: string; system: string }> = {
  "1066…sales":   { name: "sales",   model: "gpt-4o",      system: SALES_SYSTEM },
  "1066…support": { name: "support", model: "gpt-4o-mini", system: SUPPORT_SYSTEM },
  "1066…vip":     { name: "vip",     model: "gpt-4o",      system: VIP_SYSTEM },
};

function personaFor(phoneNumberId: string) {
  const p = PERSONAS[phoneNumberId];
  if (!p) throw new Error(`Unknown WABA phone_number_id: ${phoneNumberId}`);
  return p;
}

@app.post("/webhook/whatsapp")
async def webhook(request: Request, bg: BackgroundTasks):
    body = await request.json()
    for inbound in iter_inbound_with_waba(body):
        bg.add_task(
            handle_inbound,
            phone=inbound["from"],
            text=inbound["text"],
            phone_number_id=inbound["phone_number_id"],  # the WABA that received it
        )
    return {"ok": True}

async def handle_inbound(phone: str, text: str, phone_number_id: str):
    persona = persona_for(phone_number_id)
    CUSTOMER_ID = "your-business"

    # Ingest inbound with source-WABA metadata
    await sdk.memories.create(
        document=f"Customer: {text}",
        document_type="ai-chat-conversation",
        user_id=phone,
        customer_id=CUSTOMER_ID,
        metadata={
            "channel": "whatsapp",
            "direction": "inbound",
            "source_waba": persona["name"],
            "source_waba_id": phone_number_id,
        },
    )

    reply = await run_persona(persona, phone, text)
    wa_for(phone_number_id).send_message(reply, phone)

    await sdk.memories.create(
        document=f"{persona['name'].capitalize()} agent: {reply}",
        document_type="ai-chat-conversation",
        user_id=phone,
        customer_id=CUSTOMER_ID,
        metadata={
            "channel": "whatsapp",
            "direction": "outbound",
            "source_waba": persona["name"],
        },
    )

export const runtime = "nodejs";
const CUSTOMER_ID = "your-business";

export async function POST(req: Request) {
  const body = await req.json();
  for (const inbound of iterInboundWithWaba(body)) {
    handleInbound(inbound.from, inbound.text, inbound.phoneNumberId)
      .catch(console.error);
  }
  return Response.json({ ok: true });
}

async function handleInbound(phone: string, text: string, phoneNumberId: string) {
  const persona = personaFor(phoneNumberId);

  await synap.sdk.memories.create({
    document: `Customer: ${text}`,
    documentType: "ai-chat-conversation",
    userId: phone,
    customerId: CUSTOMER_ID,
    metadata: {
      channel: "whatsapp",
      direction: "inbound",
      sourceWaba: persona.name,
      sourceWabaId: phoneNumberId,
    },
  });

  const reply = await runPersona(persona, phone, text);
  await sendWaMessage(phoneNumberId, phone, reply);

  await synap.sdk.memories.create({
    document: `${persona.name} agent: ${reply}`,
    documentType: "ai-chat-conversation",
    userId: phone,
    customerId: CUSTOMER_ID,
    metadata: {
      channel: "whatsapp",
      direction: "outbound",
      sourceWaba: persona.name,
    },
  });
}

SALES_SYSTEM = """You are the WhatsApp sales agent for <Business>.
You see the same memory as our support and VIP lines. If the customer has had recent
support issues, acknowledge that briefly before pivoting. Don't oversell.
Be concise. Always confirm intent before sending a paywall / signup link."""

SUPPORT_SYSTEM = """You are the WhatsApp support agent for <Business>.
You see the same memory as sales and VIP. If they recently bought, focus on onboarding-style
help. If they're frustrated, prioritize de-escalation over deflection.
Be concise."""

VIP_SYSTEM = """You are the WhatsApp VIP-line agent for <Business>.
The customer reached out on the VIP number; they expect white-glove. You see their
full history including recent sales/support interactions. Match that level of attention."""

async def run_persona(persona: dict, phone: str, text: str) -> str:
    synap_search = create_search_tool(sdk=sdk, user_id=phone, customer_id=CUSTOMER_ID)
    synap_store  = create_store_tool(sdk=sdk, user_id=phone, customer_id=CUSTOMER_ID)

    agent = Agent(
        name=f"wa_{persona['name']}",
        instructions=persona["system"],
        model=persona["model"],
        tools=[
            FunctionTool(synap_search, name_override="synap_search"),
            FunctionTool(synap_store,  name_override="synap_store"),
            # ...persona-specific business tools
        ],
    )
    result = await Runner.run(agent, input=text)
    return result.final_output

const SALES_SYSTEM = `You are the WhatsApp sales agent for <Business>. ...`;
const SUPPORT_SYSTEM = `You are the WhatsApp support agent for <Business>. ...`;
const VIP_SYSTEM = `You are the WhatsApp VIP-line agent for <Business>. ...`;

async function runPersona(
  persona: { name: string; model: string; system: string },
  phone: string,
  text: string,
): Promise<string> {
  const model = synap.wrap(openai(persona.model), {
    userId: phone,
    customerId: CUSTOMER_ID,
    conversationId: phone,
  });

  const { text: reply } = await generateText({
    model,
    system: persona.system,
    prompt: text,
    // tools: { ...persona-specific tools }
  });
  return reply;
}

# All recent support-line interactions for this customer
docs = await sdk.memories.search(
    user_id=phone,
    customer_id=CUSTOMER_ID,
    query="prior support tickets",
    metadata_filter={"source_waba": "support"},
    max_results=10,
)

const docs = await synap.sdk.memories.search({
  userId: phone,
  customerId: CUSTOMER_ID,
  query: "prior support tickets",
  metadataFilter: { sourceWaba: "support" },
  maxResults: 10,
});