@adrata/adrata-mcp 1.0.0

package/toolsets/communications.js

@@ -0,0 +1,276 @@
+/**
+ * Communications Toolset (5 tools, Enterprise tier)
+ *
+ * make_call, send_sms, get_call_transcript,
+ * check_calendar, schedule_meeting
+ */
+
+import { z } from 'zod';
+import { md, mdError, table, formatDate } from '../output-formatter.js';
+
+export function register(server, api, AUTH) {
+
+  // -----------------------------------------------------------------------
+  // make_call
+  // -----------------------------------------------------------------------
+  server.tool(
+    'make_call',
+    'Dial a number via connected telephony provider. Initiates the call and returns a call ID for tracking. Use get_call_transcript after the call to get the AI summary.',
+    {
+      phoneNumber: z.string().describe('Phone number to dial'),
+      personId: z.string().optional().describe('Person ID for CRM linking'),
+      companyId: z.string().optional().describe('Company ID for CRM linking'),
+      notes: z.string().optional().describe('Pre-call notes or talking points'),
+    },
+    async (args) => {
+      try {
+        const result = await api('POST', '/api/v1/calls', {
+          body: {
+            phoneNumber: args.phoneNumber,
+            personId: args.personId,
+            companyId: args.companyId,
+            notes: args.notes,
+          },
+        });
+
+        const c = result?.data || result || {};
+        let text = `## Call Initiated\n\n`;
+        text += `- **To:** ${args.phoneNumber}\n`;
+        text += `- **Call ID:** ${c.id || c.callId || '\u2014'}\n`;
+        text += `- **Status:** ${c.status || 'Connecting...'}\n`;
+        if (args.personId) text += `- **Linked to person:** ${args.personId}\n`;
+        if (args.notes) text += `\n### Talking Points\n${args.notes}\n`;
+        text += '\nAfter the call, use `get_call_transcript` to get the AI summary.\n';
+
+        // Log action
+        if (args.personId) {
+          await api('POST', '/api/v1/actions', {
+            body: {
+              title: `Call to ${args.phoneNumber}`,
+              type: 'call',
+              personId: args.personId,
+              companyId: args.companyId,
+              status: 'IN_PROGRESS',
+              metadata: { callId: c.id || c.callId, phoneNumber: args.phoneNumber },
+            },
+          }).catch(() => {});
+        }
+
+        return md(text);
+      } catch (err) {
+        return mdError('Call failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // send_sms
+  // -----------------------------------------------------------------------
+  server.tool(
+    'send_sms',
+    'Send a text message via connected telephony provider (Twilio/Vonage). Links to CRM for tracking.',
+    {
+      to: z.string().describe('Recipient phone number'),
+      message: z.string().describe('SMS message text'),
+      personId: z.string().optional().describe('Person ID for CRM linking'),
+    },
+    async (args) => {
+      try {
+        const result = await api('POST', '/api/v1/sms', {
+          body: {
+            to: args.to,
+            message: args.message,
+            personId: args.personId,
+          },
+        });
+
+        const r = result?.data || result || {};
+        let text = `## SMS Sent\n\n`;
+        text += `- **To:** ${args.to}\n`;
+        text += `- **Message:** ${args.message}\n`;
+        text += `- **Status:** ${r.status || 'Sent'}\n`;
+        if (r.id) text += `- **ID:** ${r.id}\n`;
+
+        return md(text);
+      } catch (err) {
+        return mdError('SMS failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // get_call_transcript
+  // -----------------------------------------------------------------------
+  server.tool(
+    'get_call_transcript',
+    'Retrieve call recording transcript with AI summary, key topics, action items, and sentiment analysis.',
+    {
+      callId: z.string().describe('Call ID (from make_call or meeting)'),
+    },
+    async (args) => {
+      try {
+        const result = await api('GET', `/api/v1/calls/${args.callId}/transcript`);
+        const t = result?.data || result || {};
+
+        let text = `## Call Transcript\n\n`;
+        text += `- **Call ID:** ${args.callId}\n`;
+        text += `- **Duration:** ${t.duration || '\u2014'}\n`;
+        text += `- **Date:** ${formatDate(t.date || t.createdAt)}\n`;
+        if (t.sentiment) text += `- **Sentiment:** ${t.sentiment}\n`;
+        text += '\n';
+
+        if (t.summary) {
+          text += `### AI Summary\n${t.summary}\n\n`;
+        }
+
+        if (t.keyTopics?.length) {
+          text += `### Key Topics\n`;
+          t.keyTopics.forEach(topic => { text += `- ${topic}\n`; });
+          text += '\n';
+        }
+
+        if (t.actionItems?.length) {
+          text += `### Action Items\n`;
+          t.actionItems.forEach(item => { text += `- [ ] ${item}\n`; });
+          text += '\n';
+        }
+
+        if (t.transcript) {
+          text += `### Full Transcript\n${t.transcript}\n`;
+        }
+
+        return md(text);
+      } catch (err) {
+        return mdError('Transcript retrieval failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // check_calendar
+  // -----------------------------------------------------------------------
+  server.tool(
+    'check_calendar',
+    'View your calendar: upcoming meetings, free/busy times, and scheduling conflicts. Helps find open slots for meetings.',
+    {
+      date: z.string().optional().describe('Date to check (ISO, default: today)'),
+      days: z.number().optional().describe('Number of days to look ahead (default 7)'),
+    },
+    async (args) => {
+      try {
+        // Read the calendar `events` store (real meetings with startTime and
+        // attendee rosters), not the AI meeting-copilot `meetings` table which
+        // is empty until a call is recorded. `args.date` anchors the window;
+        // `args.days` extends the lookahead (default 7).
+        const start = args.date ? new Date(args.date) : new Date();
+        const days = Number.isFinite(args.days) ? args.days : 7;
+        const end = new Date(start.getTime() + days * 24 * 60 * 60 * 1000);
+        const params = {
+          start_date: start.toISOString(),
+          end_date: end.toISOString(),
+          limit: 25,
+          page: 1,
+        };
+
+        const meetings = await api('GET', '/api/v1/events', { params });
+        const list = meetings?.data || [];
+
+        if (list.length === 0) {
+          return md('## Calendar\n\nNo upcoming meetings. Your calendar is wide open.\n');
+        }
+
+        let text = `## Calendar \u2014 ${list.length} Upcoming Meetings\n\n`;
+        const rows = list.slice(0, 15).map(m => [
+          formatDate(m.startTime || m.date),
+          m.startTime ? new Date(m.startTime).toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit' }) : '\u2014',
+          m.title || m.subject || '\u2014',
+          m.attendees?.length ? `${m.attendees.length} attendees` : '\u2014',
+          m.duration || '\u2014',
+        ]);
+        text += table(['Date', 'Time', 'Meeting', 'Attendees', 'Duration'], rows);
+
+        return md(text);
+      } catch (err) {
+        return mdError('Calendar check failed', err.message);
+      }
+    }
+  );
+
+  // -----------------------------------------------------------------------
+  // schedule_meeting
+  // -----------------------------------------------------------------------
+  server.tool(
+    'schedule_meeting',
+    'Preview or create a meeting through the governed Adrata calendar path. Never claims invite delivery before provider synchronization.',
+    {
+      title: z.string().describe('Meeting title'),
+      eventId: z.string().optional().describe('Existing event ID to update instead of creating a duplicate'),
+      startTime: z.string().describe('Start time (ISO datetime)'),
+      duration: z.number().optional().describe('Duration in minutes (default 30)'),
+      attendeeEmails: z.array(z.string()).optional().describe('Attendee email addresses'),
+      personIds: z.array(z.string()).optional().describe('Person IDs from CRM'),
+      companyId: z.string().optional().describe('Company ID for CRM linking'),
+      description: z.string().optional().describe('Meeting description/agenda'),
+      location: z.string().optional().describe('Location or video link'),
+      endTime: z.string().optional().describe('End time (ISO datetime); defaults from duration'),
+      dryRun: z.boolean().optional().describe('Defaults true. Set false only after explicit approval.'),
+      reason: z.string().optional().describe('Required reason for requesting live-write confirmation.'),
+      confirmationToken: z.string().optional().describe('Single-use confirmation token returned by the server.'),
+    },
+    async (args) => {
+      try {
+        const start = new Date(args.startTime);
+        const endTime = args.endTime || new Date(start.getTime() + (args.duration || 30) * 60000).toISOString();
+        const result = await api('POST', '/api/v1/ai-crm-tools/execute', {
+          body: {
+            toolName: 'schedule_meeting',
+            arguments: {
+              title: args.title,
+              eventId: args.eventId,
+              startTime: args.startTime,
+              endTime,
+              attendees: args.attendeeEmails,
+              personIds: args.personIds,
+              companyId: args.companyId,
+              description: args.description,
+              location: args.location,
+            },
+            dryRun: args.dryRun ?? true,
+            reason: args.reason,
+            confirmationToken: args.confirmationToken,
+          },
+        });
+
+        const envelope = result?.data || result || {};
+        const m = envelope?.data || envelope;
+        let text = `## Meeting ${m.id ? 'Queued' : m.confirmationToken ? 'Awaiting Confirmation' : 'Preview'}\n\n`;
+        text += `- **Title:** ${args.title}\n`;
+        text += `- **When:** ${formatDate(args.startTime)} at ${new Date(args.startTime).toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit' })}\n`;
+        text += `- **Duration:** ${args.duration || 30} minutes\n`;
+        if (args.attendeeEmails?.length) text += `- **Attendees:** ${args.attendeeEmails.join(', ')}\n`;
+        if (args.location) text += `- **Location:** ${args.location}\n`;
+        if (m.id) text += `- **ID:** ${m.id}\n`;
+        text += `\n${m.message || 'No invite delivery has been confirmed.'}\n`;
+
+        // Log action
+        if (m.id && (args.companyId || args.personIds?.length)) {
+          await api('POST', '/api/v1/actions', {
+            body: {
+              title: `Meeting scheduled: ${args.title}`,
+              type: 'meeting',
+              companyId: args.companyId,
+              personId: args.personIds?.[0],
+              status: 'PLANNED',
+              dueDate: args.startTime,
+              metadata: { meetingId: m.id, attendees: args.attendeeEmails },
+            },
+          }).catch(() => {});
+        }
+
+        return md(text);
+      } catch (err) {
+        return mdError('Scheduling failed', err.message);
+      }
+    }
+  );
+}