message test

Author: humanagent

packages/agent-starter/src/lib/types.ts

@@ -31,24 +31,26 @@ export interface UserReturnType {
   wallet: ReturnType<typeof createWalletClient>;
 }
 
-export type xmtpConfig = {
-  path?: string;
-  hideInitLogMessage?: boolean;
-} & ClientOptions;
-
 export type Agent = {
   name?: string;
   walletKey?: string;
   encryptionKey?: string;
   onMessage?: (message: Message) => Promise<void>;
-  config?: xmtpConfig;
+  config?: ClientOptions;
 };
 
 export type Conversation = {
   id: string;
   createdAt: Date;
   topic?: string;
-  members?: User[];
+  members?: {
+    address: string;
+    inboxId: string;
+    installationIds: string[];
+    accountAddresses: string[];
+    username?: string;
+    ensDomain?: string;
+  }[];
   admins?: string[];
   name?: string;
   superAdmins?: string[];
@@ -57,7 +59,6 @@ export type Conversation = {
 export type Message = {
   id: string; // Unique identifier for the message
   sent: Date; // Date when the message was sent
-  isDM: boolean; // Whether the message is a direct message
   content: {
     text?: string | undefined; // Text content of the message
     reply?: string | undefined; // Reply content if the message is a reply
@@ -67,19 +68,17 @@ export type Message = {
     reference?: string | undefined; // Reference ID for the message
   };
   group?: Conversation; // Group the message belongs to
-  sender: User; // Sender of the message
+  sender: {
+    address: string;
+    inboxId: string;
+    installationIds: string[];
+    accountAddresses: string[];
+    username?: string;
+    ensDomain?: string;
+  }; // Sender of the message
   typeId: string; // Type identifier for the message
   client: {
     address: string;
     inboxId: string;
   };
 };
-
-export interface User {
-  address: string;
-  inboxId: string;
-  installationIds: string[];
-  accountAddresses: string[];
-  username?: string;
-  ensDomain?: string;
-}

packages/agent-starter/src/lib/xmtp.ts

@@ -37,13 +37,7 @@ import {
   AgentMessageCodec,
   ContentTypeAgentMessage,
 } from "../content-types/agent-message.js";
-import type {
-  Agent,
-  clientMessage,
-  Message,
-  User,
-  UserReturnType,
-} from "./types.js";
+import type { Agent, clientMessage, Message, UserReturnType } from "./types.js";
 
 dotenv.config();
 
@@ -92,7 +86,7 @@ export class XMTP {
 
     const volumePath =
       process.env.RAILWAY_VOLUME_MOUNT_PATH ??
-      this.agent?.config?.path ??
+      this.agent?.config?.dbPath ??
       ".data/xmtp";
 
     if (!fs.existsSync(volumePath)) {
@@ -484,6 +478,7 @@ async function streamMessages(
             ) {
               continue;
             }
+
             const parsedMessage = await parseMessage(
               message,
               conversation,
@@ -587,7 +582,16 @@ export async function parseMessage(
     };
   }
   const date = message.sentAt;
-  let sender: User | undefined = undefined;
+  let sender:
+    | {
+        inboxId: string;
+        address: string;
+        accountAddresses: string[];
+        installationIds: string[];
+        username?: string;
+        ensDomain?: string;
+      }
+    | undefined = undefined;
 
   await conversation?.sync();
   const members = await conversation?.members();
@@ -596,14 +600,26 @@ export async function parseMessage(
     address: member.accountAddresses[0],
     accountAddresses: member.accountAddresses,
     installationIds: member.installationIds,
-  })) as User[];
+  })) as {
+    inboxId: string;
+    address: string;
+    accountAddresses: string[];
+    installationIds: string[];
+  }[];
 
   sender = membersArray.find(
-    (member: User) => member.inboxId === message.senderInboxId,
+    (member: { inboxId: string }) => member.inboxId === message.senderInboxId,
   );
   return {
     id: message.id,
-    sender,
+    sender: {
+      inboxId: sender?.inboxId || "",
+      address: sender?.address || "",
+      accountAddresses: sender?.accountAddresses || [],
+      installationIds: sender?.installationIds || [],
+      username: sender?.username || "",
+      ensDomain: sender?.ensDomain || "",
+    },
     group: {
       id: conversation?.id,
       createdAt: conversation?.createdAt,

packages/agent-starter/tests/Client.test.ts

@@ -1,6 +1,7 @@
-import { createUser, XMTP, xmtpClient } from "@xmtp/agent-starter";
 import { generatePrivateKey } from "viem/accounts";
 import { describe, expect, test } from "vitest";
+import type { Message } from "../src/lib/types";
+import { createUser, XMTP, xmtpClient } from "../src/lib/xmtp";
 
 describe("Client Private Key Configuration Tests", () => {
   test("creates a client with a random generated key", async () => {
@@ -52,4 +53,46 @@ describe("Client Private Key Configuration Tests", () => {
       expect((error as Error).message).toContain("invalid private key");
     }
   }, 15000); // Added 15 second timeout
+
+  test("Creates a key with a agent name", async () => {
+    const agentName = "bob1";
+    const xmtp = await xmtpClient({
+      name: agentName,
+      onMessage: async (message: Message) => {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        console.log(
+          "message received",
+          message.content.text,
+          "from",
+          message.sender.address,
+        );
+      },
+    });
+    const xmtp2 = await xmtpClient({
+      name: "alice1",
+      onMessage: async (message: Message) => {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        console.log(
+          "message received",
+          message.content.text,
+          "from",
+          message.sender.address,
+        );
+      },
+    });
+
+    const message1 = await xmtp.send({
+      message: "Hello, Alice!",
+      receivers: [xmtp2.inboxId || ""],
+      metadata: {},
+    });
+    const message2 = await xmtp2.send({
+      message: "Hello, Bob!",
+      receivers: [xmtp.inboxId || ""],
+      metadata: {},
+    });
+
+    expect(message1).toBeDefined();
+    expect(message2).toBeDefined();
+  }, 15000);
 });

packages/agent-starter/tests/Message.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "vitest";
+import type { Message } from "../src/lib/types";
+import { xmtpClient } from "../src/lib/xmtp";
+
+describe("Client Private Key Configuration Tests", async () => {
+  const xmtp = await xmtpClient({
+    name: "bob2",
+    onMessage: async (message: Message) => {
+      console.log(
+        "Bob received message:",
+        message.content.text,
+        "from",
+        message.sender.address,
+      );
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      expect(message.content.text).toBe("Hello, Alice!");
+      expect(message.sender.address).toBe(xmtp2.address);
+    },
+  });
+  console.log("Bob's client initialized");
+
+  const xmtp2 = await xmtpClient({
+    name: "alice2",
+    onMessage: async (message: Message) => {
+      console.log(
+        "Alice received message:",
+        message.content.text,
+        "from",
+        message.sender.address,
+      );
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      expect(message.content.text).toBe("Hello, Bob!");
+      expect(message.sender.address).toBe(xmtp.address);
+    },
+  });
+
+  test("Send a message to a client", async () => {
+    console.log("Bob's address:", xmtp.address);
+    console.log("Alice's address:", xmtp2.address);
+    const message = await xmtp.send({
+      message: "Hello, Alice!",
+      receivers: [xmtp2.address as string],
+      metadata: {},
+    });
+    const message2 = await xmtp2.send({
+      message: "Hello, Bob!",
+      receivers: [xmtp.address as string],
+      metadata: {},
+    });
+    console.log("Message sent:", message);
+    console.log("Message sent:", message2);
+  }, 25000);
+});