create-message-kit 1.0.16 → 1.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-message-kit",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "license": "MIT",
   "type": "module",
   "main": "index.js",

package/templates/agent/src/handler/ens.ts

@@ -1,52 +1,39 @@
 import { HandlerContext } from "@xmtp/message-kit";
-import { Client } from "@xmtp/xmtp-js";
-import { getUserInfo, getInfoCache, isOnXMTP } from "../lib/resolver.js";
-import { textGeneration, responseParser } from "../lib/openai.js";
+import { getUserInfo, clearInfoCache, isOnXMTP } from "../lib/resolver.js";
+import { textGeneration } from "../lib/openai.js";
+import { processResponseWithSkill } from "../lib/openai.js";
+import { isAddress } from "viem";
 import { ens_agent_prompt } from "../prompt.js";
-import type {
-  ensDomain,
-  converseUsername,
-  tipAddress,
-  chatHistories,
-  tipDomain,
-} from "../lib/types.js";
-import { frameUrl, ensUrl, baseTxUrl, InfoCache } from "../lib/types.js";
-
-let tipAddress: tipAddress = {};
-let tipDomain: tipDomain = {};
-let ensDomain: ensDomain = {};
-let infoCache: InfoCache = {};
-let converseUsername: converseUsername = {};
-let chatHistories: chatHistories = {};
-
-// URL for the send transaction
+import { frameUrl, ensUrl, baseTxUrl } from "../index.js";
+import { clearChatHistories } from "../lib/openai.js";
+
 export async function handleEns(context: HandlerContext) {
   const {
     message: {
       content: { command, params, sender },
     },
   } = context;
-
-  if (command == "renew") {
+  if (command == "reset") {
+    clear();
+    return { code: 200, message: "Conversation reset." };
+  } else if (command == "renew") {
     // Destructure and validate parameters for the ens command
     const { domain } = params;
     // Check if the user holds the domain
     if (!domain) {
-      context.reply("Missing required parameters. Please provide domain.");
-      return;
+      return {
+        code: 400,
+        message: "Missing required parameters. Please provide domain.",
+      };
     }
 
-    const { infoCache: retrievedInfoCache } = await getInfoCache(
-      domain,
-      infoCache,
-    );
-    infoCache = retrievedInfoCache;
-    let data = infoCache[domain].info;
+    const data = await getUserInfo(domain);
 
-    if (data?.address !== sender?.address) {
+    if (!data || data?.address !== sender?.address) {
       return {
         code: 403,
-        message: "You do not hold this domain. Only the owner can renew it.",
+        message:
+          "Looks like this domain is not registered to you. Only the owner can renew it.",
       };
     }
 
@@ -69,22 +56,23 @@ export async function handleEns(context: HandlerContext) {
   } else if (command == "info") {
     const { domain } = params;
 
-    const { infoCache: retrievedInfoCache } = await getInfoCache(
-      domain,
-      infoCache,
-    );
-    infoCache = retrievedInfoCache;
-    let data = infoCache[domain].info;
+    const data = await getUserInfo(domain);
+    if (!data) {
+      return {
+        code: 404,
+        message: "Domain not found.",
+      };
+    }
 
     const formattedData = {
       Address: data?.address,
-      "Avatar URL": data?.avatar_url,
-      Description: data?.description,
-      ENS: data?.ens,
-      "Primary ENS": data?.ens_primary,
-      GitHub: data?.github,
-      Resolver: data?.resolverAddress,
-      Twitter: data?.twitter,
+      "Avatar URL": data?.ensInfo?.avatar,
+      Description: data?.ensInfo?.description,
+      ENS: data?.ensDomain,
+      "Primary ENS": data?.ensInfo?.ens_primary,
+      GitHub: data?.ensInfo?.github,
+      Resolver: data?.ensInfo?.resolverAddress,
+      Twitter: data?.ensInfo?.twitter,
       URL: `${ensUrl}${domain}`,
     };
 
@@ -96,23 +84,20 @@ export async function handleEns(context: HandlerContext) {
     }
     message += `\n\nWould you like to tip the domain owner for getting there first 🤣?`;
     message = message.trim();
-    if (await isOnXMTP(context.v2client, data?.ens, data?.address)) {
-      context.send(
+    if (
+      await isOnXMTP(
+        context.v2client,
+        data?.ensInfo?.ens,
+        data?.ensInfo?.address,
+      )
+    ) {
+      await context.send(
         `Ah, this domains is in XMTP, you can message it directly: https://converse.xyz/dm/${domain}`,
       );
     }
     return { code: 200, message };
   } else if (command == "check") {
-    console.log(params);
-    const { domain, cool_alternatives } = params;
-
-    const cool_alternativesFormat = cool_alternatives
-      ?.split(",")
-      .map(
-        (alternative: string, index: number) =>
-          `${index + 1}. ${alternative} ✨`,
-      )
-      .join("\n");
+    const { domain } = params;
 
     if (!domain) {
       return {
@@ -120,82 +105,46 @@ export async function handleEns(context: HandlerContext) {
         message: "Please provide a domain name to check.",
       };
     }
-    const { infoCache: retrievedInfoCache } = await getInfoCache(
-      domain,
-      infoCache,
-    );
-    infoCache = retrievedInfoCache;
-    let data = infoCache?.[domain]?.info;
+
+    const data = await getUserInfo(domain);
     if (!data?.address) {
-      let message = `Looks like ${domain} is available! Do you want to register it? ${ensUrl}${domain}`;
+      let message = `Looks like ${domain} is available! Do you want to register it? ${ensUrl}${domain} or would you like to see some cool alternatives?`;
       return {
         code: 200,
         message,
       };
     } else {
-      let message = `Looks like ${domain} is already registered! What about these cool alternatives?\n\n${cool_alternativesFormat}`;
+      let message = `Looks like ${domain} is already registered!`;
+      await context.skill("/cool " + domain);
       return {
         code: 404,
         message,
       };
     }
   } else if (command == "tip") {
-    // Destructure and validate parameters for the send command
     const { address } = params;
-
-    const { infoCache: retrievedInfoCache } = await getInfoCache(
-      address,
-      infoCache,
-    );
-    infoCache = retrievedInfoCache;
-    let data = infoCache[address].info;
-
-    tipAddress[sender.address] = data?.address;
-    tipDomain[sender.address] = data?.ens;
-
-    if (!address || !tipAddress[sender.address]) {
-      context.reply("Missing required parameters. Please provide address.");
-      return;
+    if (!address) {
+      return {
+        code: 400,
+        message: "Please provide an address to tip.",
+      };
     }
-    let txUrl = `${baseTxUrl}/transaction/?transaction_type=send&buttonName=Tip%20${tipDomain[sender.address]}&amount=1&token=USDC&receiver=${tipAddress[sender.address]}`;
-    // Generate URL for the send transaction
-    context.send(`Here is the url to send the tip:\n${txUrl}`);
+    const data = await getUserInfo(address);
+    let txUrl = `${baseTxUrl}/transaction/?transaction_type=send&buttonName=Tip%20${data?.ensDomain ?? ""}&amount=1&token=USDC&receiver=${
+      isAddress(address) ? address : data?.address
+    }`;
+    console.log(txUrl);
+    return {
+      code: 200,
+      message: txUrl,
+    };
   } else if (command == "cool") {
-    return;
-  }
-}
-
-export async function clearChatHistory() {
-  chatHistories = {};
-}
-
-async function processResponseWithIntent(
-  reply: string,
-  context: any,
-  senderAddress: string,
-) {
-  let messages = reply
-    .split("\n")
-    .map((message: string) => responseParser(message))
-    .filter((message): message is string => message.length > 0);
-
-  console.log(messages);
-  for (const message of messages) {
-    if (message.startsWith("/")) {
-      const response = await context.intent(message);
-      if (response && response.message) {
-        let msg = responseParser(response.message);
-
-        chatHistories[senderAddress].push({
-          role: "system",
-          content: msg,
-        });
-
-        await context.send(response.message);
-      }
-    } else {
-      await context.send(message);
-    }
+    const { domain } = params;
+    //What about these cool alternatives?\
+    return {
+      code: 200,
+      message: `${generateCoolAlternatives(domain)}`,
+    };
   }
 }
 
@@ -215,33 +164,48 @@ export async function ensAgent(context: HandlerContext) {
 
   try {
     let userPrompt = params?.prompt ?? content;
-    const { converseUsername: newConverseUsername, ensDomain: newEnsDomain } =
-      await getUserInfo(
-        sender.address,
-        ensDomain[sender.address],
-        converseUsername[sender.address],
-      );
-
-    ensDomain[sender.address] = newEnsDomain;
-    converseUsername[sender.address] = newConverseUsername;
-    let txUrl = `${baseTxUrl}/transaction/?transaction_type=send&buttonName=Tip%20${tipDomain[sender.address]}&amount=1&token=USDC&receiver=${tipAddress[sender.address]}`;
+    const userInfo = await getUserInfo(sender.address);
+    if (!userInfo) {
+      console.log("User info not found");
+      return;
+    }
+    const { ensDomain, converseUsername } = userInfo;
 
-    const { reply, history } = await textGeneration(
+    const { reply } = await textGeneration(
+      sender.address,
       userPrompt,
-      await ens_agent_prompt(
-        sender.address,
-        ensDomain[sender.address],
-        converseUsername[sender.address],
-        tipAddress[sender.address],
-        txUrl,
-      ),
-      chatHistories[sender.address],
+      await ens_agent_prompt(sender.address, ensDomain, converseUsername),
+      group !== undefined,
     );
-    if (!group) chatHistories[sender.address] = history; // Update chat history for the user
-
-    await processResponseWithIntent(reply, context, sender.address);
+    await processResponseWithSkill(sender.address, reply, context);
   } catch (error) {
     console.error("Error during OpenAI call:", error);
     await context.send("An error occurred while processing your request.");
   }
 }
+
+export const generateCoolAlternatives = (domain: string) => {
+  const suffixes = ["lfg", "cool", "degen", "moon", "base", "gm"];
+  const alternatives = [];
+  for (let i = 0; i < 5; i++) {
+    const randomPosition = Math.random() < 0.5;
+    const baseDomain = domain.replace(/\.eth$/, ""); // Remove any existing .eth suffix
+    alternatives.push(
+      randomPosition
+        ? `${suffixes[i]}${baseDomain}.eth`
+        : `${baseDomain}${suffixes[i]}.eth`,
+    );
+  }
+
+  const cool_alternativesFormat = alternatives
+    .map(
+      (alternative: string, index: number) => `${index + 1}. ${alternative} ✨`,
+    )
+    .join("\n");
+  return cool_alternativesFormat;
+};
+
+export async function clear() {
+  clearChatHistories();
+  clearInfoCache();
+}

package/templates/agent/src/index.ts

@@ -1,6 +1,14 @@
 import { run, HandlerContext } from "@xmtp/message-kit";
 import { ensAgent } from "./handler/ens.js";
 
+export const frameUrl = "https://ens.steer.fun/";
+export const ensUrl = "https://app.ens.domains/";
+export const baseTxUrl = "https://base-tx-frame.vercel.app";
+
 run(async (context: HandlerContext) => {
+  const { group, message } = context;
+  /*All the commands are handled through the commands file*/
+  /* If its just text, it will be handled by the ensAgent*/
+  /* If its a group message, it will be handled by the groupAgent*/
   await ensAgent(context);
 });

package/templates/agent/src/lib/openai.ts

@@ -6,12 +6,17 @@ const openai = new OpenAI({
   apiKey: process.env.OPEN_AI_API_KEY,
 });
 
+export type ChatHistoryEntry = { role: string; content: string };
+export type ChatHistories = Record<string, ChatHistoryEntry[]>;
+
+let chatHistories: ChatHistories = {};
 export async function textGeneration(
+  address: string,
   userPrompt: string,
   systemPrompt: string,
-  chatHistory?: any[],
+  isGroup: boolean = false,
 ) {
-  let messages = chatHistory ? [...chatHistory] : []; // Start with existing chat history
+  let messages = chatHistories[address] || [];
   if (messages.length === 0) {
     messages.push({
       role: "system",
@@ -33,7 +38,7 @@ export async function textGeneration(
       content: reply || "No response from OpenAI.",
     });
     const cleanedReply = responseParser(reply as string);
-
+    if (!isGroup) chatHistories[address] = messages;
     return { reply: cleanedReply, history: messages };
   } catch (error) {
     console.error("Failed to fetch from OpenAI:", error);
@@ -78,6 +83,35 @@ export async function vision(imageData: Uint8Array, systemPrompt: string) {
   }
 }
 
+export async function processResponseWithSkill(
+  address: string,
+  reply: string,
+  context: any,
+) {
+  let messages = reply
+    .split("\n")
+    .map((message: string) => responseParser(message))
+    .filter((message): message is string => message.length > 0);
+
+  console.log(messages);
+  for (const message of messages) {
+    if (message.startsWith("/")) {
+      const response = await context.skill(message);
+      if (response && response.message) {
+        let msg = responseParser(response.message);
+
+        chatHistories[address].push({
+          role: "system",
+          content: msg,
+        });
+
+        await context.send(response.message);
+      }
+    } else {
+      await context.send(message);
+    }
+  }
+}
 export function responseParser(message: string) {
   let trimmedMessage = message;
   // Remove bold and underline markdown
@@ -94,32 +128,10 @@ export function responseParser(message: string) {
   trimmedMessage = trimmedMessage?.replace(/^\s+|\s+$/g, "");
   // Remove any remaining leading or trailing whitespace
   trimmedMessage = trimmedMessage.trim();
-  return trimmedMessage;
-}
-
-// UNTESTED, recursive response parser
-export function responseParser2(message: string | string[]): string | string[] {
-  // If message is an array, process each item individually
-  if (Array.isArray(message)) {
-    return message
-      .map((item) => responseParser(item))
-      .flat() // Flatten nested arrays
-      .filter((item: string) => item.length > 0)
-      .filter((item: string) => item !== "`");
-  }
-  let trimmedMessage = message;
-  // Remove bold and underline markdown
-  trimmedMessage = trimmedMessage?.replace(/(\*\*|__)(.*?)\1/g, "$2");
-  // Remove markdown links, keeping only the URL
-  trimmedMessage = trimmedMessage?.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$2");
-  // Remove markdown headers
-  trimmedMessage = trimmedMessage?.replace(/^#+\s*(.*)$/gm, "$1");
-  // Remove inline code formatting
-  trimmedMessage = trimmedMessage?.replace(/(`{1,3})(.*?)\1/g, "$2");
-  // Remove leading and trailing whitespace
-  trimmedMessage = trimmedMessage?.replace(/`/g, ""); // Remove single backticks
-  // Remove any remaining leading or trailing whitespace
-  trimmedMessage = trimmedMessage?.trim();
 
   return trimmedMessage;
 }
+
+export const clearChatHistories = () => {
+  chatHistories = {};
+};

package/templates/agent/src/lib/resolver.ts

@@ -1,76 +1,120 @@
-import type { EnsData } from "./types.js";
-import { endpointURL } from "./types.js";
 import { Client } from "@xmtp/xmtp-js";
-import { InfoCache } from "./types.js";
+import { isAddress } from "viem";
 
-export async function getUserInfo(
-  address: string,
-  ensDomain: string | undefined,
-  converseUsername: string | undefined,
-) {
-  if (!ensDomain) {
-    const response = await fetch(`https://ensdata.net/${address}`);
-    const data: EnsData = (await response.json()) as EnsData;
-    ensDomain = data?.ens;
+export const converseEndpointURL =
+  "https://converse-website-git-endpoit-ephemerahq.vercel.app";
+//export const converseEndpointURL = "http://localhost:3000";
+
+export type InfoCache = Map<string, UserInfo>;
+export type ConverseProfile = {
+  address: string | null;
+  onXmtp: boolean;
+  avatar: string | null;
+  formattedName: string | null;
+  name: string | null;
+};
+export type UserInfo = {
+  ensDomain?: string | undefined;
+  address?: string | undefined;
+  converseUsername?: string | undefined;
+  ensInfo?: EnsData | undefined;
+  avatar?: string | undefined;
+};
+export interface EnsData {
+  address?: string;
+  avatar?: string;
+  avatar_small?: string;
+  converse?: string;
+  avatar_url?: string;
+  contentHash?: string;
+  description?: string;
+  ens?: string;
+  ens_primary?: string;
+  github?: string;
+  resolverAddress?: string;
+  twitter?: string;
+  url?: string;
+  wallets?: {
+    eth?: string;
+  };
+}
+
+let infoCache: InfoCache = new Map();
+
+export const clearInfoCache = () => {
+  infoCache.clear();
+};
+export const getUserInfo = async (
+  key: string,
+  clientAddress?: string,
+): Promise<UserInfo | null> => {
+  let data: UserInfo = infoCache.get(key) || {
+    ensDomain: undefined,
+    address: undefined,
+    converseUsername: undefined,
+    ensInfo: undefined,
+  };
+  //console.log("Getting user info", key, clientAddress);
+  if (isAddress(clientAddress || "")) {
+    data.address = clientAddress;
+  } else if (isAddress(key || "")) {
+    data.address = key;
+  } else if (key.includes(".eth")) {
+    data.ensDomain = key;
+  } else if (key == "@user" || key == "@me" || key == "@bot") {
+    data.address = clientAddress;
+    data.ensDomain = key.replace("@", "") + ".eth";
+    data.converseUsername = key.replace("@", "");
+  } else if (key == "@alix") {
+    data.address = "0x3a044b218BaE80E5b9E16609443A192129A67BeA";
+    data.converseUsername = "alix";
+  } else if (key == "@bo") {
+    data.address = "0xbc3246461ab5e1682baE48fa95172CDf0689201a";
+    data.converseUsername = "bo";
+  } else {
+    data.converseUsername = key;
+  }
+
+  let keyToUse = data.address || data.ensDomain || data.converseUsername;
+  let cacheData = keyToUse && infoCache.get(keyToUse);
+  if (cacheData) {
+    //console.log("Getting user info", keyToUse, cacheData);
+    return cacheData;
+  } else {
+    //console.log("Getting user info", keyToUse, data);
   }
-  if (!converseUsername) {
-    const response = await fetch(`${endpointURL}/profile/${address}`, {
+
+  if (keyToUse?.includes(".eth")) {
+    const response = await fetch(`https://ensdata.net/${keyToUse}`);
+    const ensData: EnsData = (await response.json()) as EnsData;
+    //console.log("Ens data", ensData);
+    if (ensData) {
+      data.ensInfo = ensData;
+      data.ensDomain = ensData?.ens;
+      data.address = ensData?.address;
+    }
+  } else if (keyToUse) {
+    keyToUse = keyToUse.replace("@", "");
+    const response = await fetch(`${converseEndpointURL}/profile/${keyToUse}`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Accept: "application/json",
       },
-      body: JSON.stringify({ address: address }),
+      body: JSON.stringify({
+        peer: keyToUse,
+      }),
     });
-    const data = (await response.json()) as { name: string };
-    converseUsername = data?.name;
-    converseUsername = converseUsername.replace(".converse.xyz", "");
+    const converseData = (await response.json()) as ConverseProfile;
+    if (process.env.MSG_LOG)
+      console.log("Converse data", keyToUse, converseData);
+    data.converseUsername =
+      converseData?.formattedName || converseData?.name || undefined;
+    data.address = converseData?.address || undefined;
+    data.avatar = converseData?.avatar || undefined;
   }
-  console.log("User info fetched for", {
-    address,
-    converseUsername,
-    ensDomain,
-  });
-  return { converseUsername: converseUsername, ensDomain: ensDomain };
-}
-
-export const getInfoCache = async (
-  key: string, // This can be either domain or address
-  infoCache: InfoCache,
-): Promise<{ domain: string; info: EnsData; infoCache: InfoCache }> => {
-  if (infoCache[key]) {
-    let data = {
-      domain: key,
-      info: infoCache[key].info,
-      infoCache: infoCache,
-    };
-    return data;
-  }
-  try {
-    const response = await fetch(`https://ensdata.net/${key}`);
-    const data: EnsData = (await response.json()) as EnsData;
-
-    // Assuming the data contains both domain and address
-    const domain = data?.ens;
-    const address = data?.address;
-
-    // Store data in cache by both domain and address
-    if (domain) infoCache[domain as string] = { info: data };
-    if (address) infoCache[address as string] = { info: data };
-
-    return { info: data, infoCache: infoCache, domain: domain as string };
-  } catch (error) {
-    console.error(error);
-    return { info: {}, infoCache: infoCache, domain: "" };
-  }
-};
-export const generateCoolAlternatives = (domain: string) => {
-  const suffixes = ["lfg", "cool", "degen", "moon", "base", "gm"];
-  const alternatives = suffixes.map((suffix) => {
-    const randomPosition = Math.random() < 0.5;
-    return randomPosition ? `${suffix}${domain}.eth` : `${domain}${suffix}.eth`;
-  });
-  return alternatives.join(",");
+  if (data.address) infoCache.set(data.address, data);
+  return data;
 };
 export const isOnXMTP = async (
   client: Client,