Merge pull request #11 from chaosloth/conno/bot-hooks

Bot hooks

Author: leroychan

serverless-functions/src/functions/api/bot/bot.helper.private.ts

@@ -0,0 +1,154 @@
+import { sign, decode } from "jsonwebtoken";
+import { Context } from "@twilio-labs/serverless-runtime-types/types";
+
+/**
+ * Sends a message to the bot
+ * @param context - The Twilio runtime context
+ * @param botInstanceId - The ID of the bot instance
+ * @param body - The message body to send
+ */
+export async function sendMessageToBot(
+  context: Context & { TWILIO_REGION?: string; ACCOUNT_SID: string; AUTH_TOKEN: string },
+  botInstanceId: string,
+  body: Record<string, any>
+) {
+  const url = `https://ROVO_URL_HERE`;
+
+  const response = await fetch(url, {
+    method: "POST",
+    body: JSON.stringify(body),
+    headers: {
+      Authorization: `Basic ${Buffer.from(
+        `${context.ACCOUNT_SID}:${context.AUTH_TOKEN}`,
+        "utf-8"
+      ).toString("base64")}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    },
+  });
+  if (response.ok) {
+    console.log("Sent message to Bot");
+    return;
+  } else {
+    throw new Error(
+      "Failed to send request to Bot. " + (await response.text())
+    );
+  }
+}
+
+/**
+ * Reads attributes from a conversation
+ * @param context - The Twilio runtime context
+ * @param chatServiceSid - The Chat Service SID
+ * @param conversationSid - The Conversation SID
+ * @returns The parsed conversation attributes
+ */
+export async function readConversationAttributes(
+  context: Context & { getTwilioClient: () => any },
+  chatServiceSid: string,
+  conversationSid: string
+) {
+  try {
+    const client = context.getTwilioClient();
+    const data = await client.conversations.v1
+      .services(chatServiceSid)
+      .conversations(conversationSid)
+      .fetch();
+    return JSON.parse(data.attributes);
+  } catch (err) {
+    console.error(err);
+    return {};
+  }
+}
+
+/**
+ * Gets the bot ID from context or event
+ * @param context - The Twilio runtime context
+ * @param event - The event object
+ * @returns The bot ID
+ */
+export async function getBotId(
+  context: Context & { AUTH_TOKEN: string; BOT_ID?: string },
+  event: {
+    EventType?: string;
+    botId?: string;
+    ConversationSid?: string;
+    ChatServiceSid?: string;
+  }
+) {
+  if (event.EventType === "onMessageAdded") {
+    try {
+      const { ConversationSid, ChatServiceSid } = event;
+      const parsed = await readConversationAttributes(
+        context,
+        ChatServiceSid,
+        ConversationSid
+      );
+      if (typeof parsed.botId === "string" && parsed.botId) {
+        return parsed.botId;
+      }
+    } catch (err) {
+      console.log("Invalid attribute structure", err);
+    }
+  }
+  const botId = event.botId || context.BOT_ID || event.botId || context.BOT_ID;
+
+  if (!botId) {
+    throw new Error("Missing Bot ID configuration");
+  }
+
+  return botId;
+}
+
+/**
+ * Signs a request with JWT
+ * @param context - The Twilio runtime context
+ * @param event - The event object
+ * @returns The signed JWT token
+ */
+export async function signRequest(
+  context: Context & { AUTH_TOKEN: string },
+  event: Record<string, any>
+) {
+  const assistantSid = await getBotId(context, event);
+  const authToken = context.AUTH_TOKEN;
+  if (!authToken) {
+    throw new Error("No auth token found");
+  }
+  return sign({ assistantSid }, authToken, { expiresIn: "5m" });
+}
+
+/**
+ * Verifies a request token
+ * @param context - The Twilio runtime context
+ * @param event - The event object containing the token
+ * @returns Whether the token is valid
+ */
+export function verifyRequest(
+  context: Context & { AUTH_TOKEN: string },
+  event: { _token: string }
+) {
+  const token = event._token;
+  if (!token) {
+    throw new Error("Missing token");
+  }
+
+  const authToken = context.AUTH_TOKEN;
+  if (!authToken) {
+    throw new Error("No auth token found");
+  }
+
+  try {
+    // The decode function from jsonwebtoken only takes a token and options
+    const decoded = decode(token, { json: true });
+    if (decoded && typeof decoded === 'object' && 'assistantSid' in decoded) {
+      return true;
+    }
+  } catch (err) {
+    console.error("Failed to verify token", err);
+    return false;
+  }
+  return false;
+}
+
+// All functions are already exported using named exports

serverless-functions/src/functions/api/bot/incoming-conversation.ts

@@ -0,0 +1,112 @@
+import { ServerlessFunctionSignature } from "@twilio-labs/serverless-runtime-types/types";
+import {
+  signRequest,
+  getBotId,
+  sendMessageToBot,
+  readConversationAttributes
+} from "./bot.helper.private";
+
+// Import Twilio for Response object - using require for Twilio.Response compatibility
+const Twilio = require('twilio');
+
+// Define the context interface
+interface BotContext {
+  getTwilioClient: () => any;
+  DOMAIN_NAME: string;
+  ACCOUNT_SID: string;
+  AUTH_TOKEN: string;
+  [key: string]: any; // Index signature to satisfy EnvironmentVariables constraint
+}
+
+// Define the event interface
+interface BotEvent {
+  request: {
+    cookies: Record<string, string>;
+    headers: Record<string, string>;
+  };
+  Body?: string;
+  ConversationSid: string;
+  ChatServiceSid: string;
+  Author: string;
+  [key: string]: any; // Index signature for additional properties
+}
+
+/**
+ * Handler for Bot onMessageAdded events
+ */
+export const handler: ServerlessFunctionSignature<BotContext, BotEvent> =
+  async function (context, event, callback) {
+    const assistantSid = await getBotId(context, event);
+
+    const { ConversationSid, ChatServiceSid, Author } = event;
+    const BotIdentity =
+      typeof event.AssistantIdentity === "string"
+        ? event.AssistantIdentity
+        : undefined;
+
+    let identity = Author.includes(":") ? Author : `user_id:${Author}`;
+
+    const client = context.getTwilioClient();
+
+    const webhooks = (
+      await client.conversations.v1
+        .services(ChatServiceSid)
+        .conversations(ConversationSid)
+        .webhooks.list()
+    ).filter((entry: { target: string }) => entry.target === "studio");
+
+    if (webhooks.length > 0) {
+      // ignoring if the conversation has a studio webhook set (assuming it was handed over)
+      return callback(null, "");
+    }
+
+    const participants = await client.conversations.v1
+      .services(ChatServiceSid)
+      .conversations(ConversationSid)
+      .participants.list();
+
+    if (participants.length > 1) {
+      // Ignoring the conversation because there is more than one human
+      return callback(null, "");
+    }
+
+    const token = await signRequest(context, event);
+    const params = new URLSearchParams();
+    params.append("_token", token);
+    if (typeof BotIdentity === "string") {
+      params.append("_assistantIdentity", BotIdentity);
+    }
+    const body = {
+      body: event.Body,
+      identity: identity,
+      session_id: `conversations__${ChatServiceSid}/${ConversationSid}`,
+      // using a callback to handle AI Assistant responding
+      webhook: `https://${
+        context.DOMAIN_NAME
+      }/channels/conversations/response?${params.toString()}`,
+    };
+
+    const response = new Twilio.Response();
+    response.appendHeader("content-type", "text/plain");
+    response.setBody("");
+
+    const attributes = await readConversationAttributes(
+      context,
+      ChatServiceSid,
+      ConversationSid
+    );
+    await client.conversations.v1
+      .services(ChatServiceSid)
+      .conversations(ConversationSid)
+      .update({
+        attributes: JSON.stringify({ ...attributes, assistantIsTyping: true }),
+      });
+
+    try {
+      await sendMessageToBot(context, assistantSid, body);
+    } catch (err) {
+      console.error(err);
+    }
+
+    callback(null, response);
+  };