SDR Agent with Scheduled Follow-ups

import { Agent, openai, createScheduleTools } from '@runflow-ai/sdk';
import { qualifyLeadTool } from './tools/qualify-lead';
import { closeConversationTool } from './tools/close-conversation';

const scheduleTools = createScheduleTools();

export const sdrAgent = new Agent({
  name: 'SDR Agent',
  instructions: `You are an SDR qualifying leads via WhatsApp for ACME Corp.

## Qualification (BANT)
- Budget: can they afford the solution?
- Authority: are they the decision maker?
- Need: do they have a real problem we solve?
- Timeline: when do they need a solution?

Ask one question at a time. Be natural, not robotic.

## Tools — when to use each
- **qualify-lead**: Use when you have enough info to score the lead (at least 3 of 4 BANT criteria). This marks the conversation as qualified or nurturing.
- **close-conversation**: Use when the lead explicitly says they are not interested, asks to stop, or is a wrong contact. This marks the conversation as closed.
- **create_schedule**: Use when the lead asks to be called back later. ALWAYS set maxExecutions to 1 for one-time callbacks.

## Resuming conversations
- When resuming a scheduled callback, greet naturally: "Oi [name]! Conforme combinamos..."
- When following up on an inactive lead, be brief and casual. Reference the last topic discussed.
- Don't repeat questions they already answered.`,

  model: openai('gpt-4o'),

  tools: {
    create_schedule: scheduleTools.create_schedule,
    qualifyLead: qualifyLeadTool,
    closeConversation: closeConversationTool,
  },

  memory: {
    maxTurns: 30,
    summarizeAfter: 20,
    summarizePrompt: 'Summarize: lead name, BANT score so far, topics discussed, next steps, and any objections raised.',
  },
});

import { createTool } from '@runflow-ai/sdk';
import { Memory } from '@runflow-ai/sdk';
import { track } from '@runflow-ai/sdk/observability';
import { z } from 'zod';

export const qualifyLeadTool = createTool({
  id: 'qualify-lead',
  description: 'Record lead qualification score based on BANT criteria. Use when you have enough info to score (at least 3 of 4 criteria answered). This marks the session status.',
  inputSchema: z.object({
    leadName: z.string(),
    budget: z.number().min(0).max(10),
    authority: z.number().min(0).max(10),
    need: z.number().min(0).max(10),
    timeline: z.number().min(0).max(10),
    notes: z.string().optional(),
  }),
  execute: async ({ context }) => {
    const score = (context.budget + context.authority + context.need + context.timeline) / 4;
    const qualified = score >= 7;
    const status = qualified ? 'qualified' : 'nurturing';

    // Set session status — this is how Memory.list() knows to skip this lead
    await Memory.setStatus(status);

    track('lead_qualified', {
      leadName: context.leadName,
      score,
      qualified,
    });

    return {
      score: Math.round(score * 10) / 10,
      qualified,
      status,
      recommendation: qualified
        ? 'Lead qualificado. Agendar demo com AE.'
        : 'Lead morno. Continuar nurturing.',
    };
  },
});

import { createTool } from '@runflow-ai/sdk';
import { Memory } from '@runflow-ai/sdk';
import { track } from '@runflow-ai/sdk/observability';
import { z } from 'zod';

export const closeConversationTool = createTool({
  id: 'close-conversation',
  description: 'Close this conversation permanently. Use when: lead says they are not interested, asks to stop receiving messages, is a wrong contact, or the conversation is finished.',
  inputSchema: z.object({
    reason: z.enum(['not_interested', 'wrong_contact', 'already_customer', 'completed', 'other']),
    notes: z.string().optional(),
  }),
  execute: async ({ context }) => {
    await Memory.setStatus('closed');

    track('conversation_closed', { reason: context.reason });

    return { closed: true, reason: context.reason };
  },
});

import { identify, Memory } from '@runflow-ai/sdk';
import { sdrAgent } from './agent';

export async function main(input: any) {
  // Identify the lead — this is what loads the right memory
  const phone = input.entityValue || input.metadata?.phone;
  if (phone) {
    identify(phone); // Auto-detects type as 'phone'
  }

  // Check if this is a CRON trigger for inactive leads
  if (input.metadata?.isScheduled && input.message === 'Check inactive leads') {
    return handleInactiveLeads();
  }

  // Regular conversation or scheduled callback — same flow
  return sdrAgent.process(input);
}

// ... main() function from above ...

async function handleInactiveLeads() {
  // Find leads inactive for 4+ hours that haven't been qualified or closed
  const inactive = await Memory.list({
    lastInteractionBefore: new Date(Date.now() - 4 * 60 * 60 * 1000),
    // status: null means "in progress" — skips qualified, closed, nurturing
  });

  let processed = 0;

  for (const session of inactive) {
    // Skip sessions that already have a status (qualified, closed, etc.)
    if (session.status) continue;

    // Only follow up if the agent was the last to speak (lead didn't respond)
    if (session.lastMessage?.role !== 'assistant') continue;

    // Skip if no entity info (can't identify the lead)
    if (!session.entityType || !session.entityValue) continue;

    // Pass context directly in the input — no identify() in the loop
    await sdrAgent.process({
      message: 'This lead has not responded in a few hours. Send a brief, natural follow-up referencing the last topic discussed.',
      entityType: session.entityType,
      entityValue: session.entityValue,
      channel: 'whatsapp',
    });

    processed++;
  }

  return { processed, message: `Followed up with ${processed} inactive leads` };
}