Automating Meeting Scheduling in an OpenClaw Sales Assistant

// leadScoringAgent.js
module.exports = async function handleLeadScored(event, context) {
  const { leadId, score } = event.payload;

  // Existing logic … (AI model inference)

  if (score >= 80) {
    // Emit qualified event for downstream agents
    await context.emit('lead_qualified', { leadId, score });
    console.log(`Lead ${leadId} qualified (score: ${score})`);
  } else {
    console.log(`Lead ${leadId} not qualified (score: ${score})`);
  }
};

ubos deploy agent leadScoringAgent.js --name lead-scoring

// calendarAuth.js
const { google } = require('googleapis');
const { Client } = require('@microsoft/microsoft-graph-client');
require('dotenv').config();

async function getGoogleAuth() {
  const auth = new google.auth.GoogleAuth({
    credentials: {
      client_email: process.env.GOOGLE_CLIENT_EMAIL,
      private_key: process.env.GOOGLE_PRIVATE_KEY.replace(/\\n/g, '\n')
    },
    scopes: ['https://www.googleapis.com/auth/calendar']
  });
  return await auth.getClient();
}

function getOutlookClient() {
  const client = Client.init({
    authProvider: async (done) => {
      // Acquire token via client credentials
      const tokenResponse = await fetch('https://login.microsoftonline.com/' + process.env.OUTLOOK_TENANT_ID + '/oauth2/v2.0/token', {
        method: 'POST',
        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
        body: new URLSearchParams({
          client_id: process.env.OUTLOOK_CLIENT_ID,
          client_secret: process.env.OUTLOOK_CLIENT_SECRET,
          scope: 'https://graph.microsoft.com/.default',
          grant_type: 'client_credentials'
        })
      });
      const token = (await tokenResponse.json()).access_token;
      done(null, token);
    }
  });
  return client;
}

module.exports = { getGoogleAuth, getOutlookClient };

// availability.js
async function getGoogleFreeSlots(auth) {
  const calendar = google.calendar({ version: 'v3', auth });
  const now = new Date();
  const max = new Date();
  max.setDate(now.getDate() + 5);

  const res = await calendar.freebusy.query({
    requestBody: {
      timeMin: now.toISOString(),
      timeMax: max.toISOString(),
      timeZone: 'UTC',
      items: [{ id: 'primary' }]
    }
  });

  const busy = res.data.calendars.primary.busy;
  // Simple algorithm: return first 30‑min slot not in busy list
  // (In production, use a robust slot‑generation library)
  let slotStart = new Date(now);
  while (slotStart  new Date(b.start)  slotStart);
    if (!overlapping) return { start: slotStart, end: slotEnd };
    slotStart = new Date(slotStart.getTime() + 15 * 60000); // step 15 min
  }
  throw new Error('No free slot found');
}

async function getOutlookFreeSlots(client) {
  const now = new Date().toISOString();
  const max = new Date(Date.now() + 5 * 24 * 60 * 60 * 1000).toISOString();

  const events = await client.api('/me/calendarview')
    .header('Prefer', 'outlook.timezone="UTC"')
    .query({ startDateTime: now, endDateTime: max })
    .get();

  // Similar slot‑generation logic as Google
  // Omitted for brevity – replace with your own implementation
  // Return { start: Date, end: Date }
}

// schedulerAgent.js
const { getGoogleAuth, getOutlookClient } = require('./calendarAuth');
const { getGoogleFreeSlots, getOutlookFreeSlots } = require('./availability');
const axios = require('axios');

module.exports = async function scheduleMeeting(event, context) {
  const { leadId } = event.payload;

  // 1️⃣ Fetch lead details from CRM
  const leadRes = await axios.get(`https://api.yourcrm.com/leads/${leadId}`, {
    headers: { Authorization: `Bearer ${process.env.CRM_API_KEY}` }
  });
  const lead = leadRes.data;
  const { email, name, preferredCalendar } = lead;

  // 2️⃣ Authenticate & find free slot
  let slot;
  if (preferredCalendar === 'google') {
    const auth = await getGoogleAuth();
    slot = await getGoogleFreeSlots(auth);
  } else {
    const client = getOutlookClient();
    slot = await getOutlookFreeSlots(client);
  }

  // 3️⃣ Create meeting
  const meeting = {
    summary: `Demo Call with ${name}`,
    description: `Automated meeting scheduled by OpenClaw sales assistant.`,
    start: { dateTime: slot.start.toISOString(), timeZone: 'UTC' },
    end: { dateTime: slot.end.toISOString(), timeZone: 'UTC' },
    attendees: [{ email, displayName: name }]
  };

  if (preferredCalendar === 'google') {
    const auth = await getGoogleAuth();
    const calendar = google.calendar({ version: 'v3', auth });
    await calendar.events.insert({ calendarId: 'primary', requestBody: meeting });
  } else {
    const client = getOutlookClient();
    await client.api('/me/events').post(meeting);
  }

  // 4️⃣ Notify prospect (simple email via SendGrid or similar)
  await axios.post('https://api.sendgrid.com/v3/mail/send', {
    personalizations: [{ to: [{ email }] }],
    from: { email: 'sales@yourcompany.com' },
    subject: 'Your Demo Call is Scheduled',
    content: [{ type: 'text/plain', value: `Hi ${name},\n\nYour demo is set for ${slot.start.toUTCString()}.\n\nBest,\nSales Team` }]
  }, { headers: { Authorization: `Bearer ${process.env.SENDGRID_API_KEY}` } });

  console.log(`Meeting scheduled for lead ${leadId} at ${slot.start}`);
};

ubos deploy agent schedulerAgent.js --name meeting-scheduler

// orchestrator.js
const { EventBus } = require('@ubos/event-bus');

const bus = new EventBus();

bus.on('lead_qualified', async (payload) => {
  console.log('Orchestrator: lead qualified, invoking scheduler...');
  await bus.emit('schedule_meeting', payload); // internal event
});

bus.on('schedule_meeting', async (payload) => {
  // Forward to the scheduler agent
  await bus.invokeAgent('meeting-scheduler', payload);
});

module.exports = bus;

ubos deploy service orchestrator.js --name orchestrator