create-message-kit 1.1.9 → 1.1.10-beta.2

package/templates/agent/src/handler.ts

@@ -1,174 +0,0 @@
-import { HandlerContext, SkillResponse } from "@xmtp/message-kit";
-import { getUserInfo, clearInfoCache, isOnXMTP } from "@xmtp/message-kit";
-import { clearMemory } from "@xmtp/message-kit";
-
-export const frameUrl = "https://ens.steer.fun/";
-export const ensUrl = "https://app.ens.domains/";
-export const txpayUrl = "https://txpay.vercel.app";
-
-export async function handleEns(
-  context: HandlerContext,
-): Promise<SkillResponse | undefined> {
-  const {
-    message: {
-      sender,
-      content: { skill, params },
-    },
-  } = context;
-
-  if (skill == "reset") {
-    clearMemory();
-    return { code: 200, message: "Conversation reset." };
-  } else if (skill == "renew") {
-    // Destructure and validate parameters for the ens
-    const { domain } = params;
-    // Check if the user holds the domain
-    if (!domain) {
-      return {
-        code: 400,
-        message: "Missing required parameters. Please provide domain.",
-      };
-    }
-
-    const data = await getUserInfo(domain);
-
-    if (!data?.address || data?.address !== sender?.address) {
-      return {
-        code: 403,
-        message:
-          "Looks like this domain is not registered to you. Only the owner can renew it.",
-      };
-    }
-
-    // Generate URL for the ens
-    let url_ens = frameUrl + "frames/manage?name=" + domain;
-    return { code: 200, message: `${url_ens}` };
-  } else if (skill == "register") {
-    // Destructure and validate parameters for the ens
-    const { domain } = params;
-
-    if (!domain) {
-      return {
-        code: 400,
-        message: "Missing required parameters. Please provide domain.",
-      };
-    }
-    // Generate URL for the ens
-    let url_ens = ensUrl + domain;
-    context.send(`${url_ens}`);
-    return { code: 200, message: `${url_ens}` };
-  } else if (skill == "info") {
-    const { domain } = params;
-
-    const data = await getUserInfo(domain);
-    if (!data?.ensDomain) {
-      return {
-        code: 404,
-        message: "Domain not found.",
-      };
-    }
-
-    const formattedData = {
-      Address: data?.address,
-      "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}`,
-    };
-
-    let message = "Domain information:\n\n";
-    for (const [key, value] of Object.entries(formattedData)) {
-      if (value) {
-        message += `${key}: ${value}\n`;
-      }
-    }
-    message += `\n\nWould you like to tip the domain owner for getting there first 🤣?`;
-    message = message.trim();
-    if (await isOnXMTP(context.client, context.v2client, sender?.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 (skill == "check") {
-    const { domain } = params;
-
-    if (!domain) {
-      return {
-        code: 400,
-        message: "Please provide a domain name to check.",
-      };
-    }
-
-    const data = await getUserInfo(domain);
-    if (!data?.address) {
-      let message = `Looks like ${domain} is available! Here you can 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!`;
-      await context.executeSkill("/cool " + domain);
-      return {
-        code: 404,
-        message,
-      };
-    }
-  } else if (skill == "tip") {
-    const { address } = params;
-    if (!address) {
-      return {
-        code: 400,
-        message: "Please provide an address to tip.",
-      };
-    }
-    const data = await getUserInfo(address);
-
-    let sendUrl = `${txpayUrl}/?&amount=1&token=USDC&receiver=${address}`;
-
-    return {
-      code: 200,
-      message: sendUrl,
-    };
-  } else if (skill == "cool") {
-    const { domain } = params;
-    //What about these cool alternatives?\
-    return {
-      code: 200,
-      message: `${generateCoolAlternatives(domain)}`,
-    };
-  } else {
-    return { code: 400, message: "Skill not found." };
-  }
-}
-
-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() {
-  clearMemory();
-  clearInfoCache();
-}

package/templates/agent/src/skills.ts

@@ -1,88 +0,0 @@
-import { handleEns } from "./handler.js";
-import type { SkillGroup } from "@xmtp/message-kit";
-
-export const skills: SkillGroup[] = [
-  {
-    name: "Ens Domain Bot",
-    tag: "@ens",
-    description: "Register ENS domains.",
-    skills: [
-      {
-        skill: "/register [domain]",
-        handler: handleEns,
-        description:
-          "Register a new ENS domain. Returns a URL to complete the registration process.",
-        examples: ["/register vitalik.eth"],
-        params: {
-          domain: {
-            type: "string",
-          },
-        },
-      },
-      {
-        skill: "/info [domain]",
-        handler: handleEns,
-        description:
-          "Get detailed information about an ENS domain including owner, expiry date, and resolver.",
-        examples: ["/info nick.eth"],
-        params: {
-          domain: {
-            type: "string",
-          },
-        },
-      },
-      {
-        skill: "/renew [domain]",
-        handler: handleEns,
-        description:
-          "Extend the registration period of your ENS domain. Returns a URL to complete the renewal.",
-        examples: ["/renew fabri.base.eth"],
-        params: {
-          domain: {
-            type: "string",
-          },
-        },
-      },
-      {
-        skill: "/check [domain]",
-        handler: handleEns,
-        examples: ["/check vitalik.eth", "/check fabri.base.eth"],
-        description: "Check if a domain is available.",
-        params: {
-          domain: {
-            type: "string",
-          },
-        },
-      },
-      {
-        skill: "/cool [domain]",
-        examples: ["/cool vitalik.eth"],
-        handler: handleEns,
-        description: "Get cool alternatives for a .eth domain.",
-        params: {
-          domain: {
-            type: "string",
-          },
-        },
-      },
-      {
-        skill: "/reset",
-        examples: ["/reset"],
-        handler: handleEns,
-        description: "Reset the conversation.",
-        params: {},
-      },
-      {
-        skill: "/tip [address]",
-        description: "Show a URL for tipping a domain owner.",
-        handler: handleEns,
-        examples: ["/tip 0x1234567890123456789012345678901234567890"],
-        params: {
-          address: {
-            type: "string",
-          },
-        },
-      },
-    ],
-  },
-];

package/templates/ens-agent-pro/.env.example

@@ -1,2 +0,0 @@
-KEY= # the private key of the wallet
-OPEN_AI_API_KEY= # sk-proj-...

package/templates/ens-agent-pro/src/index.ts

@@ -1,90 +0,0 @@
-import { run, HandlerContext } from "@xmtp/message-kit";
-import { ChatOpenAI } from "@langchain/openai";
-import { createOpenAIFunctionsAgent, AgentExecutor } from "langchain/agents";
-import { tools } from "./skills.js";
-import { systemPrompt } from "./prompt.js";
-import { ChatPromptTemplate } from "@langchain/core/prompts";
-
-// Initialize OpenAI chat model
-const model = new ChatOpenAI({
-  temperature: 0.7,
-  modelName: "gpt-4o",
-  openAIApiKey: process.env.OPEN_AI_API_KEY,
-});
-
-// Create the prompt template with required variables
-const prompt = ChatPromptTemplate.fromMessages([
-  ["system", systemPrompt],
-]).partial({
-  tools: tools.map((tool) => `${tool.name}: ${tool.description}`).join("\n"),
-  tool_names: tools.map((tool) => tool.name).join(", "),
-});
-
-// Initialize chat history storage
-const chatHistory = new Map<string, { role: string; content: string }[]>();
-
-// Initialize the agent and executor
-const initializeAgent = async () => {
-  const agent = await createOpenAIFunctionsAgent({
-    llm: model,
-    tools: tools as any,
-    prompt: await prompt,
-  });
-
-  return new AgentExecutor({
-    agent,
-    tools: tools as any,
-    returnIntermediateSteps: false,
-    verbose: true, // Set to true for checking the agent's thought process
-  });
-};
-
-// Create executor instance
-const executor = await initializeAgent();
-
-run(
-  async (context: HandlerContext) => {
-    const {
-      message: {
-        content: { text },
-        sender,
-      },
-    } = context;
-
-    console.log("Received message:", text);
-
-    // Get or initialize chat history for this sender
-    if (!chatHistory.has(sender.address)) {
-      chatHistory.set(sender.address, []);
-    }
-    const userHistory: any = chatHistory.get(sender.address)!;
-
-    // Add user message to history
-    userHistory.push({ role: "user", content: context.message.content.text });
-
-    try {
-      // Execute agent with user's message and chat history
-      const result = await executor.invoke({
-        input: text,
-        chat_history: userHistory,
-      });
-
-      console.log("Agent response:", result.output);
-      const output = result.output.replace(/\*/g, "");
-
-      // Add assistant's response to history
-      userHistory.push({ role: "assistant", content: output });
-
-      await context.send(output);
-    } catch (error) {
-      console.error("Error:", error);
-      // Add error message to history
-      userHistory.push({
-        role: "assistant",
-        content: "An error occurred while processing your request.",
-      });
-      await context.send("An error occurred while processing your request.");
-    }
-  },
-  { skills: [] },
-);

package/templates/ens-agent-pro/src/prompt.ts

@@ -1,19 +0,0 @@
-export const systemPrompt = `You are a helpful AI assistant that can use various tools to help users.
-
-You have access to the following tools:
-{tools}
-
-Tool Names: {tool_names}
-
-Instructions:
-1. DO NOT respond in markdown. ALWAYS respond in plain text.
-2. Use tools when appropriate
-3. Be friendly and helpful
-4. Ask for clarification if you don't understand the user's request
-5. For tipping, always confirm the amount with the user once
-
-Previous conversation history:
-{chat_history}
-
-User Input: {input}
-{agent_scratchpad}`; 

package/templates/ens-agent-pro/src/skills.ts

@@ -1,233 +0,0 @@
-import { DynamicStructuredTool } from "langchain/tools";
-import { getUserInfo } from "@xmtp/message-kit";
-import { clearMemory } from "@xmtp/message-kit";
-import { isAddress } from "viem";
-import { z } from "zod";
-
-const frameUrl = "https://ens.steer.fun/";
-const ensUrl = "https://app.ens.domains/";
-const txpayUrl = "https://txpay.vercel.app";
-const converseUrl = "https://converse.xyz/profile/";
-
-// Add interface for Converse API response
-interface ConverseProfile {
-  address: string;
-  avatar?: string;
-  formattedName?: string;
-  name?: string;
-  onXmtp: boolean;
-}
-
-// Add function to check XMTP status
-async function checkXMTPStatus(address: string): Promise<boolean> {
-  try {
-    const response = await fetch(converseUrl + address, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-      },
-      body: JSON.stringify({ address }),
-    });
-
-    if (!response.ok) {
-      console.error(`Failed to check XMTP status: ${response.status}`);
-      return false;
-    }
-
-    const data = (await response.json()) as ConverseProfile;
-    return data.onXmtp;
-  } catch (error) {
-    console.error("Error checking XMTP status:", error);
-    return false;
-  }
-}
-
-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`,
-    );
-  }
-
-  return alternatives
-    .map(
-      (alternative: string, index: number) => `${index + 1}. ${alternative} ✨`,
-    )
-    .join("\n");
-};
-
-// Export tools array with all tools
-export const tools = [
-  new DynamicStructuredTool({
-    name: "reset_ens_conversation",
-    description: "Reset the ENS conversation and clear memory",
-    schema: z.object({}),
-    func: async () => {
-      clearMemory();
-      return "Conversation reset successfully.";
-    },
-  }),
-
-  new DynamicStructuredTool({
-    name: "renew_ens_domain",
-    description:
-      "Generate renewal URL for an ENS domain. Only works if sender owns the domain",
-    schema: z.object({
-      domain: z.string().describe("The ENS domain to renew"),
-    }),
-    func: async ({ domain }) => {
-      const data = await getUserInfo(domain);
-      if (!data?.address) {
-        return "Domain not found or not registered.";
-      }
-      return `${frameUrl}frames/manage?name=${domain}`;
-    },
-  }),
-
-  new DynamicStructuredTool({
-    name: "register_ens_domain",
-    description: "Get URL to register a new ENS domain",
-    schema: z.object({
-      domain: z.string().describe("The ENS domain to register"),
-    }),
-    func: async ({ domain }) => {
-      if (!domain) return "Please provide a domain name";
-      return `${ensUrl}${domain}`;
-    },
-  }),
-
-  new DynamicStructuredTool({
-    name: "get_ens_info",
-    description:
-      "Get detailed information about an ENS domain including owner, avatar, description, etc",
-    schema: z.object({
-      domain: z.string().describe("The ENS domain to get information about"),
-    }),
-    func: async ({ domain }) => {
-      const data = await getUserInfo(domain);
-      if (!data?.ensDomain) {
-        return "Domain not found.";
-      }
-
-      const formattedData = {
-        Address: data?.address,
-        "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}`,
-      };
-
-      let message = "Domain information:\n\n";
-      for (const [key, value] of Object.entries(formattedData)) {
-        if (value) {
-          message += `${key}: ${value}\n`;
-        }
-      }
-      message +=
-        "\nWould you like to tip the domain owner for getting there first? 🤣";
-
-      // Check XMTP status if we have an address
-      if (data.address) {
-        const isOnXMTP = await checkXMTPStatus(data.address);
-        if (isOnXMTP) {
-          message += `\n\nAh, this domain is on XMTP! You can message it directly: https://converse.xyz/dm/${domain}`;
-        }
-      }
-
-      return message;
-    },
-  }),
-
-  new DynamicStructuredTool({
-    name: "check_ens_availability",
-    description: "Check if an ENS domain is available for registration",
-    schema: z.object({
-      domain: z
-        .string()
-        .transform((str) => str.replace(/^["'](.+)["']$/, "$1")) // Remove quotes if present
-        .transform((str) => str.toLowerCase())
-        .describe("The ENS domain to check availability for"),
-    }),
-    func: async ({ domain }) => {
-      if (!domain) return "Please provide a domain name to check.";
-
-      if (domain.includes(".") && !domain.endsWith(".eth")) {
-        return "Invalid ENS domain. Only .eth domains are supported.";
-      }
-
-      if (!domain.includes(".")) {
-        domain = `${domain}.eth`;
-      }
-
-      const data = await getUserInfo(domain);
-      if (!data?.address) {
-        return `Looks like ${domain} is available! Here you can register it: ${ensUrl}${domain} or would you like to see some cool alternatives?`;
-      } else {
-        const alternatives = generateCoolAlternatives(domain);
-        return `Looks like ${domain} is already registered!\n\nHere are some cool alternatives:\n${alternatives}`;
-      }
-    },
-  }),
-
-  new DynamicStructuredTool({
-    name: "get_ens_alternatives",
-    description: "Generate cool alternative names for an ENS domain",
-    schema: z.object({
-      domain: z
-        .string()
-        .describe("The ENS domain to generate alternatives for"),
-    }),
-    func: async ({ domain }) => {
-      if (!domain) return "Please provide a domain name.";
-      return `What about these cool alternatives?\n\n${generateCoolAlternatives(domain)}`;
-    },
-  }),
-
-  new DynamicStructuredTool({
-    name: "get_ens_tip_url",
-    description:
-      "Generate a URL to tip an ENS domain owner in USDC. Works with both ENS domains and Ethereum addresses.",
-    schema: z.object({
-      addressOrDomain: z
-        .string()
-        .describe("The ENS domain or Ethereum address to tip"),
-      amount: z
-        .number()
-        .optional()
-        .default(1)
-        .describe("The amount of USDC to tip"),
-    }),
-    func: async ({ addressOrDomain, amount }) => {
-      if (!addressOrDomain) {
-        return "Please provide an address or ENS domain to tip.";
-      }
-
-      let address: string | undefined;
-
-      if (isAddress(addressOrDomain)) {
-        address = addressOrDomain;
-      } else {
-        const data = await getUserInfo(addressOrDomain);
-        address = data?.address;
-      }
-
-      if (!address) {
-        return "Could not resolve address for tipping. Please provide a valid ENS domain or Ethereum address.";
-      }
-
-      let sendUrl = `${txpayUrl}/?&amount=${amount}&token=USDC&receiver=${address}`;
-      return sendUrl;
-    },
-  }),
-];

package/templates/group/src/handler/payment.ts

@@ -1,29 +0,0 @@
-import { getUserInfo, HandlerContext } from "@xmtp/message-kit";
-
-export async function handler(context: HandlerContext) {
-  const {
-    message: {
-      content: { skill, params },
-    },
-  } = context;
-  const txpayUrl = "https://txpay.vercel.app";
-
-  if (skill === "pay") {
-    const { amount: amountSend, token: tokenSend, username } = params;
-    console.log("username", username);
-    let senderInfo = await getUserInfo(username);
-    if (!amountSend || !tokenSend || !senderInfo) {
-      context.reply(
-        "Missing required parameters. Please provide amount, token, and username.",
-      );
-      return {
-        code: 400,
-        message:
-          "Missing required parameters. Please provide amount, token, and username.",
-      };
-    }
-
-    let sendUrl = `${txpayUrl}/?&amount=${amountSend}&token=${tokenSend}&receiver=${senderInfo.address}`;
-    await context.send(`${sendUrl}`);
-  }
-}

package/templates/group/src/handler/tipping.ts

@@ -1,40 +0,0 @@
-import {
-  HandlerContext,
-  AbstractedMember,
-  SkillResponse,
-} from "@xmtp/message-kit";
-import { getUserInfo } from "@xmtp/message-kit";
-
-export async function handler(context: HandlerContext) {
-  const {
-    message: {
-      content: {
-        skill,
-        params: { amount, username },
-      },
-      sender,
-    },
-  } = context;
-  let receivers: AbstractedMember[] = [];
-
-  if (skill === "tip") {
-    receivers = await Promise.all(
-      username.map((username: string) => getUserInfo(username)),
-    );
-  }
-  if (!sender || receivers.length === 0 || amount === 0) {
-    context.reply("Sender or receiver or amount not found.");
-  }
-  const receiverAddresses = receivers.map((receiver) => receiver.address);
-
-  context.sendTo(
-    `You received ${amount} tokens from ${sender.address}.`,
-    receiverAddresses,
-  );
-
-  // Notify sender of the transaction details
-  context.sendTo(
-    `You sent ${amount * receiverAddresses.length} tokens in total.`,
-    [sender.address],
-  );
-}