@elizaos/plugin-twitter 1.0.0-beta.23 → 1.0.0-beta.24

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   EventType as EventType4,
   Role,
   Service,
-  createUniqueUuid as createUniqueUuid8,
+  createUniqueUuid as createUniqueUuid7,
   logger as logger10
 } from "@elizaos/core";
 
@@ -6606,8 +6606,6 @@ var SttTtsPlugin2 = class {
 };
 
 // src/utils.ts
-import fs from "node:fs";
-import path from "node:path";
 import {
   ChannelType as ChannelType2,
   ModelType as ModelType2,
@@ -6615,27 +6613,6 @@ import {
   createUniqueUuid as createUniqueUuid2,
   logger as logger3
 } from "@elizaos/core";
-async function fetchMediaData(attachments) {
-  return Promise.all(
-    attachments.map(async (attachment) => {
-      if (/^(http|https):\/\//.test(attachment.url)) {
-        const response = await fetch(attachment.url);
-        if (!response.ok) {
-          throw new Error(`Failed to fetch file: ${attachment.url}`);
-        }
-        const mediaBuffer = Buffer.from(await response.arrayBuffer());
-        const mediaType = attachment.contentType || "image/png";
-        return { data: mediaBuffer, mediaType };
-      }
-      if (fs.existsSync(attachment.url)) {
-        const mediaBuffer = await fs.promises.readFile(path.resolve(attachment.url));
-        const mediaType = attachment.contentType || "image/png";
-        return { data: mediaBuffer, mediaType };
-      }
-      throw new Error(`File not found: ${attachment.url}. Make sure the path is correct.`);
-    })
-  );
-}
 async function generateFiller(runtime, fillerType) {
   try {
     const prompt = composePrompt({
@@ -7821,22 +7798,29 @@ var _ClientBase = class _ClientBase {
       const mentionsResponse = await this.requestQueue.add(
         () => this.twitterClient.fetchSearchTweets(`@${username}`, 100, 1 /* Latest */)
       );
-      return mentionsResponse.tweets.map((tweet) => ({
-        id: tweet.id,
-        type: tweet.isQuoted ? "quote" : tweet.retweetedStatus ? "retweet" : "like",
-        userId: tweet.userId,
-        username: tweet.username,
-        name: tweet.name || tweet.username,
-        targetTweetId: tweet.inReplyToStatusId || tweet.quotedStatusId,
-        targetTweet: tweet.quotedStatus || tweet,
-        quoteTweet: tweet.isQuoted ? tweet : void 0,
-        retweetId: tweet.retweetedStatus?.id
-      }));
+      return mentionsResponse.tweets.map((tweet) => this.formatTweetToInteraction(tweet));
     } catch (error) {
       logger6.error("Error fetching Twitter interactions:", error);
       return [];
     }
   }
+  formatTweetToInteraction(tweet) {
+    if (!tweet) return null;
+    const isQuote = tweet.isQuoted;
+    const isRetweet = !!tweet.retweetedStatus;
+    const type = isQuote ? "quote" : isRetweet ? "retweet" : "like";
+    return {
+      id: tweet.id,
+      type,
+      userId: tweet.userId,
+      username: tweet.username,
+      name: tweet.name || tweet.username,
+      targetTweetId: tweet.inReplyToStatusId || tweet.quotedStatusId,
+      targetTweet: tweet.quotedStatus || tweet,
+      quoteTweet: isQuote ? tweet : void 0,
+      retweetId: tweet.retweetedStatus?.id
+    };
+  }
 };
 _ClientBase._twitterClients = {};
 var ClientBase = _ClientBase;
@@ -7852,13 +7836,6 @@ import {
   createUniqueUuid as createUniqueUuid5,
   logger as logger7
 } from "@elizaos/core";
-
-// src/types.ts
-var ServiceType = {
-  TWITTER: "twitter"
-};
-
-// src/interactions.ts
 var convertToCoreTweet = (tweet) => ({
   id: tweet.id,
   text: tweet.text,
@@ -7923,256 +7900,224 @@ var TwitterInteractionClient = class {
       } else if (!searchResult.previous && !searchResult.next) {
         await this.runtime.setCache(cursorKey, null);
       }
-      logger7.log("Completed checking mentioned tweets:", mentionCandidates.length);
-      let uniqueTweetCandidates = [...mentionCandidates];
-      uniqueTweetCandidates = uniqueTweetCandidates.sort((a, b) => a.id.localeCompare(b.id)).filter((tweet) => tweet.userId !== this.client.profile.id);
-      for (const tweet of uniqueTweetCandidates) {
-        if (!this.client.lastCheckedTweetId || BigInt(tweet.id) > this.client.lastCheckedTweetId) {
-          const tweetId = createUniqueUuid5(this.runtime, tweet.id);
-          const existingResponse = await this.runtime.getMemoryById(tweetId);
-          if (existingResponse) {
-            logger7.log(`Already responded to tweet ${tweet.id}, skipping`);
-            continue;
-          }
-          logger7.log("New Tweet found", tweet.permanentUrl);
-          const entityId = createUniqueUuid5(
-            this.runtime,
-            tweet.userId === this.client.profile.id ? this.runtime.agentId : tweet.userId
-          );
-          const worldId = createUniqueUuid5(this.runtime, tweet.userId);
-          const roomId = createUniqueUuid5(this.runtime, tweet.conversationId);
-          await this.runtime.ensureWorldExists({
-            id: worldId,
-            name: `${tweet.name}'s Twitter`,
-            agentId: this.runtime.agentId,
-            serverId: tweet.userId,
-            metadata: {
-              ownership: { ownerId: tweet.userId },
-              twitter: {
-                username: tweet.username,
-                id: tweet.userId,
-                name: tweet.name
-              }
+      await this.processMentionTweets(mentionCandidates);
+      await this.client.cacheLatestCheckedTweetId();
+      logger7.log("Finished checking Twitter interactions");
+    } catch (error) {
+      logger7.error("Error handling Twitter interactions:", error);
+    }
+  }
+  /**
+   * Processes all incoming tweets that mention the bot.
+   * For each new tweet:
+   *  - Ensures world, room, and connection exist
+   *  - Saves the tweet as memory
+   *  - Emits thread-related events (THREAD_CREATED / THREAD_UPDATED)
+   *  - Delegates tweet content to `handleTweet` for reply generation
+   *
+   * Note: MENTION_RECEIVED is currently disabled (see TODO below)
+   */
+  async processMentionTweets(mentionCandidates) {
+    logger7.log("Completed checking mentioned tweets:", mentionCandidates.length);
+    let uniqueTweetCandidates = [...mentionCandidates];
+    uniqueTweetCandidates = uniqueTweetCandidates.sort((a, b) => a.id.localeCompare(b.id)).filter((tweet) => tweet.userId !== this.client.profile.id);
+    for (const tweet of uniqueTweetCandidates) {
+      if (!this.client.lastCheckedTweetId || BigInt(tweet.id) > this.client.lastCheckedTweetId) {
+        const tweetId = createUniqueUuid5(this.runtime, tweet.id);
+        const existingResponse = await this.runtime.getMemoryById(tweetId);
+        if (existingResponse) {
+          logger7.log(`Already responded to tweet ${tweet.id}, skipping`);
+          continue;
+        }
+        logger7.log("New Tweet found", tweet.permanentUrl);
+        const entityId = createUniqueUuid5(
+          this.runtime,
+          tweet.userId === this.client.profile.id ? this.runtime.agentId : tweet.userId
+        );
+        const worldId = createUniqueUuid5(this.runtime, tweet.userId);
+        const roomId = createUniqueUuid5(this.runtime, tweet.conversationId);
+        await this.runtime.ensureWorldExists({
+          id: worldId,
+          name: `${tweet.name}'s Twitter`,
+          agentId: this.runtime.agentId,
+          serverId: tweet.userId,
+          metadata: {
+            ownership: { ownerId: tweet.userId },
+            twitter: {
+              username: tweet.username,
+              id: tweet.userId,
+              name: tweet.name
             }
-          });
-          await this.runtime.ensureConnection({
-            entityId,
-            roomId,
-            userName: tweet.username,
-            name: tweet.name,
-            source: "twitter",
-            type: ChannelType5.GROUP,
-            channelId: tweet.conversationId,
-            serverId: tweet.userId,
-            worldId
-          });
-          await this.runtime.ensureRoomExists({
-            id: roomId,
-            name: `Conversation with ${tweet.name}`,
+          }
+        });
+        await this.runtime.ensureConnection({
+          entityId,
+          roomId,
+          userName: tweet.username,
+          name: tweet.name,
+          source: "twitter",
+          type: ChannelType5.GROUP,
+          channelId: tweet.conversationId,
+          serverId: tweet.userId,
+          worldId
+        });
+        await this.runtime.ensureRoomExists({
+          id: roomId,
+          name: `Conversation with ${tweet.name}`,
+          source: "twitter",
+          type: ChannelType5.GROUP,
+          channelId: tweet.conversationId,
+          serverId: tweet.userId,
+          worldId
+        });
+        const memory = {
+          id: tweetId,
+          agentId: this.runtime.agentId,
+          content: {
+            text: tweet.text,
+            url: tweet.permanentUrl,
+            imageUrls: tweet.photos?.map((photo) => photo.url) || [],
+            inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid5(this.runtime, tweet.inReplyToStatusId) : void 0,
             source: "twitter",
-            type: ChannelType5.GROUP,
-            channelId: tweet.conversationId,
-            serverId: tweet.userId,
-            worldId
-          });
-          const memory = {
-            id: tweetId,
-            agentId: this.runtime.agentId,
-            content: {
-              text: tweet.text,
-              url: tweet.permanentUrl,
-              imageUrls: tweet.photos?.map((photo) => photo.url) || [],
-              inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid5(this.runtime, tweet.inReplyToStatusId) : void 0,
-              source: "twitter",
-              channelType: ChannelType5.GROUP,
-              tweet
+            channelType: ChannelType5.GROUP,
+            tweet
+          },
+          entityId,
+          roomId,
+          createdAt: tweet.timestamp * 1e3
+        };
+        await this.runtime.createMemory(memory, "messages");
+        if (tweet.thread.length > 1) {
+          const threadPayload = {
+            runtime: this.runtime,
+            tweets: convertToCoreTweets(tweet.thread),
+            user: {
+              id: tweet.userId,
+              username: tweet.username,
+              name: tweet.name
             },
-            entityId,
-            roomId,
-            createdAt: tweet.timestamp * 1e3
+            source: "twitter"
           };
-          await this.runtime.createMemory(memory, "messages");
-          if (tweet.text.includes(`@${twitterUsername}`)) {
-            const messagePayload = {
-              runtime: this.runtime,
-              message: {
-                ...memory,
-                source: "twitter"
-              },
-              source: "twitter",
-              callback: async (response) => {
-                logger7.info("Received message response:", response);
-                return [];
-              }
-            };
-            const mentionPayload = {
-              runtime: this.runtime,
-              message: {
-                ...memory,
-                source: "twitter"
-              },
-              tweet: convertToCoreTweet(tweet),
-              user: {
-                id: tweet.userId,
-                username: tweet.username,
-                name: tweet.name
-              },
-              source: "twitter",
-              callback: async (response) => {
-                logger7.info("Received mention response:", response);
-                return [];
-              }
-            };
-            this.runtime.emitEvent("TWITTER_MENTION_RECEIVED" /* MENTION_RECEIVED */, mentionPayload);
-          }
-          if (tweet.thread.length > 1) {
-            const threadPayload = {
-              runtime: this.runtime,
-              tweets: convertToCoreTweets(tweet.thread),
-              user: {
-                id: tweet.userId,
-                username: tweet.username,
-                name: tweet.name
-              },
-              source: "twitter"
-            };
-            if (tweet.thread[tweet.thread.length - 1].id === tweet.id) {
-              this.runtime.emitEvent("TWITTER_THREAD_UPDATED" /* THREAD_UPDATED */, {
-                ...threadPayload,
-                newTweet: convertToCoreTweet(tweet)
-              });
-            } else if (tweet.thread[0].id === tweet.id) {
-              this.runtime.emitEvent("TWITTER_THREAD_CREATED" /* THREAD_CREATED */, threadPayload);
-            }
+          if (tweet.thread[tweet.thread.length - 1].id === tweet.id) {
+            this.runtime.emitEvent("TWITTER_THREAD_UPDATED" /* THREAD_UPDATED */, {
+              ...threadPayload,
+              newTweet: convertToCoreTweet(tweet)
+            });
+          } else if (tweet.thread[0].id === tweet.id) {
+            this.runtime.emitEvent("TWITTER_THREAD_CREATED" /* THREAD_CREATED */, threadPayload);
           }
-          await this.handleTweet({
-            tweet,
-            message: memory,
-            thread: tweet.thread
-          });
-          this.client.lastCheckedTweetId = BigInt(tweet.id);
         }
+        await this.handleTweet({
+          tweet,
+          message: memory,
+          thread: tweet.thread
+        });
+        this.client.lastCheckedTweetId = BigInt(tweet.id);
       }
-      const interactions = await this.client.fetchInteractions();
-      const handleInteraction = async (interaction) => {
-        if (interaction?.targetTweet?.conversationId) {
-          const memory = this.createMemoryObject(
-            interaction.type,
-            `${interaction.id}-${interaction.type}`,
-            interaction.userId,
-            interaction.targetTweet.conversationId
-          );
-          await this.runtime.createMemory(memory, "messages");
-          const reactionMessage = {
-            id: createUniqueUuid5(this.runtime, interaction.targetTweetId),
-            content: {
-              text: interaction.targetTweet.text,
-              source: "twitter"
-            },
-            entityId: createUniqueUuid5(this.runtime, interaction.targetTweet.userId),
-            roomId: createUniqueUuid5(this.runtime, interaction.targetTweet.conversationId),
-            agentId: this.runtime.agentId
+    }
+  }
+  /**
+   * Handles Twitter interactions such as likes, retweets, and quotes.
+   * For each interaction:
+   *  - Creates a memory object
+   *  - Emits platform-specific events (LIKE_RECEIVED, RETWEET_RECEIVED, QUOTE_RECEIVED)
+   *  - Emits a generic REACTION_RECEIVED event with metadata
+   */
+  async handleInteraction(interaction) {
+    if (interaction?.targetTweet?.conversationId) {
+      const memory = this.createMemoryObject(
+        interaction.type,
+        `${interaction.id}-${interaction.type}`,
+        interaction.userId,
+        interaction.targetTweet.conversationId
+      );
+      await this.runtime.createMemory(memory, "messages");
+      const reactionMessage = {
+        id: createUniqueUuid5(this.runtime, interaction.targetTweetId),
+        content: {
+          text: interaction.targetTweet.text,
+          source: "twitter"
+        },
+        entityId: createUniqueUuid5(this.runtime, interaction.targetTweet.userId),
+        roomId: createUniqueUuid5(this.runtime, interaction.targetTweet.conversationId),
+        agentId: this.runtime.agentId
+      };
+      const basePayload = {
+        runtime: this.runtime,
+        user: {
+          id: interaction.userId,
+          username: interaction.username,
+          name: interaction.name
+        },
+        source: "twitter"
+      };
+      switch (interaction.type) {
+        case "like": {
+          const likePayload = {
+            ...basePayload,
+            tweet: interaction.targetTweet
           };
-          const basePayload = {
-            runtime: this.runtime,
-            user: {
-              id: interaction.userId,
-              username: interaction.username,
-              name: interaction.name
+          this.runtime.emitEvent("TWITTER_LIKE_RECEIVED" /* LIKE_RECEIVED */, likePayload);
+          this.runtime.emitEvent(EventType2.REACTION_RECEIVED, {
+            ...basePayload,
+            reaction: {
+              type: "like",
+              entityId: createUniqueUuid5(this.runtime, interaction.userId)
             },
-            source: "twitter"
+            message: reactionMessage,
+            callback: async () => {
+              return [];
+            }
+          });
+          break;
+        }
+        case "retweet": {
+          const retweetPayload = {
+            ...basePayload,
+            tweet: interaction.targetTweet,
+            retweetId: interaction.retweetId
           };
-          switch (interaction.type) {
-            case "like": {
-              const likePayload = {
-                ...basePayload,
-                tweet: interaction.targetTweet
-              };
-              this.runtime.emitEvent("TWITTER_LIKE_RECEIVED" /* LIKE_RECEIVED */, likePayload);
-              this.runtime.emitEvent(EventType2.REACTION_RECEIVED, {
-                ...basePayload,
-                reaction: {
-                  type: "like",
-                  entityId: createUniqueUuid5(this.runtime, interaction.userId)
-                },
-                message: reactionMessage,
-                callback: async () => {
-                  return [];
-                }
-              });
-              break;
+          this.runtime.emitEvent("TWITTER_RETWEET_RECEIVED" /* RETWEET_RECEIVED */, retweetPayload);
+          this.runtime.emitEvent(EventType2.REACTION_RECEIVED, {
+            ...basePayload,
+            reaction: {
+              type: "retweet",
+              entityId: createUniqueUuid5(this.runtime, interaction.userId)
+            },
+            message: reactionMessage,
+            callback: async () => {
+              return [];
             }
-            case "retweet": {
-              const retweetPayload = {
-                ...basePayload,
-                tweet: interaction.targetTweet,
-                retweetId: interaction.retweetId
-              };
-              this.runtime.emitEvent("TWITTER_RETWEET_RECEIVED" /* RETWEET_RECEIVED */, retweetPayload);
-              this.runtime.emitEvent(EventType2.REACTION_RECEIVED, {
-                ...basePayload,
-                reaction: {
-                  type: "retweet",
-                  entityId: createUniqueUuid5(this.runtime, interaction.userId)
-                },
-                message: reactionMessage,
-                callback: async () => {
-                  return [];
-                }
-              });
-              break;
+          });
+          break;
+        }
+        case "quote": {
+          const quotePayload = {
+            ...basePayload,
+            message: reactionMessage,
+            quotedTweet: interaction.targetTweet,
+            quoteTweet: interaction.quoteTweet || interaction.targetTweet,
+            callback: async () => [],
+            reaction: {
+              type: "quote",
+              entityId: createUniqueUuid5(this.runtime, interaction.userId)
             }
-            case "quote": {
-              const quotePayload = {
-                ...basePayload,
-                message: reactionMessage,
-                quotedTweet: interaction.targetTweet,
-                quoteTweet: interaction.quoteTweet || interaction.targetTweet,
-                callback: async () => [],
-                reaction: {
-                  type: "quote",
-                  entityId: createUniqueUuid5(this.runtime, interaction.userId)
-                }
-              };
-              this.runtime.emitEvent("TWITTER_QUOTE_RECEIVED" /* QUOTE_RECEIVED */, quotePayload);
-              this.runtime.emitEvent(EventType2.REACTION_RECEIVED, {
-                ...basePayload,
-                reaction: {
-                  type: "quote",
-                  entityId: createUniqueUuid5(this.runtime, interaction.userId)
-                },
-                message: reactionMessage,
-                callback: async () => {
-                  return [];
-                }
-              });
-              break;
+          };
+          this.runtime.emitEvent("TWITTER_QUOTE_RECEIVED" /* QUOTE_RECEIVED */, quotePayload);
+          this.runtime.emitEvent(EventType2.REACTION_RECEIVED, {
+            ...basePayload,
+            reaction: {
+              type: "quote",
+              entityId: createUniqueUuid5(this.runtime, interaction.userId)
+            },
+            message: reactionMessage,
+            callback: async () => {
+              return [];
             }
-          }
-        }
-      };
-      const processInteractions = async (interactions2) => {
-        for (const interaction of interactions2) {
-          if (interaction?.targetTweet?.conversationId) {
-            await handleInteraction(interaction);
-          }
-        }
-      };
-      const processFollowerChange = async (change, profileId) => {
-        if (change?.type && change?.userId && profileId) {
-          const followerMemory = this.createMemoryObject(
-            change.type,
-            `${change.type}-${change.userId}`,
-            change.userId,
-            profileId
-          );
-          await this.runtime.createMemory(followerMemory, "follower-changes");
+          });
+          break;
         }
-      };
-      await this.client.cacheLatestCheckedTweetId();
-      logger7.log("Finished checking Twitter interactions");
-    } catch (error) {
-      logger7.error("Error handling Twitter interactions:", error);
+      }
     }
   }
   /**
@@ -8228,48 +8173,9 @@ var TwitterInteractionClient = class {
       currentPost,
       formattedConversation
     };
-    const tweetId = message.id || createUniqueUuid5(this.runtime, tweet.id);
-    const tweetExists = (await this.runtime.getMemoryById(tweetId))?.id === tweetId;
-    if (!tweetExists) {
-      logger7.log("tweet does not exist, saving");
-      const entityId = createUniqueUuid5(this.runtime, tweet.userId);
-      const roomId = createUniqueUuid5(this.runtime, tweet.conversationId);
-      await this.runtime.ensureConnection({
-        entityId,
-        roomId,
-        userName: tweet.username,
-        name: tweet.name,
-        source: "twitter",
-        type: ChannelType5.GROUP
-      });
-      await this.runtime.ensureRoomExists({
-        id: roomId,
-        name: `Conversation with ${tweet.name}`,
-        source: "twitter",
-        type: ChannelType5.GROUP,
-        channelId: tweet.conversationId,
-        worldId: createUniqueUuid5(this.runtime, tweet.userId)
-      });
-      const memory = {
-        id: tweetId,
-        agentId: this.runtime.agentId,
-        content: {
-          text: tweet.text,
-          url: tweet.permanentUrl,
-          imageUrls: tweet.photos?.map((photo) => photo.url) || [],
-          inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid5(this.runtime, tweet.inReplyToStatusId) : void 0,
-          source: "twitter",
-          channelType: ChannelType5.GROUP
-        },
-        entityId,
-        roomId,
-        createdAt: tweet.timestamp * 1e3
-      };
-      this.client.saveRequestMessage(memory, state);
-    }
-    const callback = async (response, tweetId2) => {
+    const callback = async (response, tweetId) => {
       try {
-        const tweetToReplyTo = tweetId2 || tweet.id;
+        const tweetToReplyTo = tweetId || tweet.id;
         if (this.isDryRun) {
           logger7.info(`[DRY RUN] Would have replied to ${tweet.username} with: ${response.text}`);
           return [];
@@ -8741,287 +8647,80 @@ var TwitterPostClient = class {
 };
 
 // src/tests.ts
-import {
-  ModelType as ModelType5,
-  createUniqueUuid as createUniqueUuid7,
-  logger as logger9,
-  stringToUuid
-} from "@elizaos/core";
-var TEST_IMAGE_URL = "https://github.com/elizaOS/awesome-eliza/blob/main/assets/eliza-logo.jpg?raw=true";
-var TEST_IMAGE = {
-  id: "mock-image-id",
-  text: "mock image",
-  description: "mock image descirption",
-  source: "mock image source",
-  url: TEST_IMAGE_URL,
-  title: "mock image",
-  contentType: "image/jpeg",
-  alt_text: "mock image"
-};
-var TwitterTestSuite = class {
-  /**
-   * Constructor for TestSuite class.
-   * Initializes an array of test functions to be executed.
-   */
+import { logger as logger9 } from "@elizaos/core";
+var ClientBaseTestSuite = class {
   constructor() {
-    this.name = "twitter";
-    this.twitterClient = null;
+    this.name = "twitter-client-base";
     this.tests = [
-      {
-        name: "Initialize Twitter Client",
-        fn: this.testInitializingClient.bind(this)
-      },
-      { name: "Fetch Profile", fn: this.testFetchProfile.bind(this) },
-      {
-        name: "Fetch Search Tweets",
-        fn: this.testFetchSearchTweets.bind(this)
-      },
-      {
-        name: "Fetch Home Timeline",
-        fn: this.testFetchHomeTimeline.bind(this)
-      },
-      { name: "Fetch Own Posts", fn: this.testFetchOwnPosts.bind(this) },
-      { name: "Post Tweet", fn: this.testPostTweet.bind(this) },
-      { name: "Post Tweet With Image", fn: this.testPostImageTweet.bind(this) },
-      { name: "Generate New Tweet", fn: this.testGenerateNewTweet.bind(this) },
-      {
-        name: "Handle Tweet Response",
-        fn: this.testHandleTweetResponse.bind(this)
-      }
+      { name: "Create instance with correct configuration", fn: this.testInstanceCreation.bind(this) },
+      { name: "Initialize with correct post intervals", fn: this.testPostIntervals.bind(this) }
     ];
-  }
-  /**
-   * Asynchronously initializes the Twitter client for the provided agent runtime.
-   *
-   * @param {IAgentRuntime} runtime - The agent runtime to use for initializing the Twitter client.
-   * @throws {Error} If the Twitter client manager is not found or if the Twitter client fails to initialize.
-   */
-  async testInitializingClient(runtime) {
-    try {
-      const manager = runtime.getService(ServiceType.TWITTER);
-      if (!manager) {
-        throw new Error("Twitter client manager not found");
-      }
-      const clientId = stringToUuid("default");
-      this.twitterClient = manager.clients.get(manager.getClientKey(clientId, runtime.agentId));
-      if (this.twitterClient) {
-        logger9.debug("TwitterClient initialized successfully.");
-      } else {
-        throw new Error("TwitterClient failed to initialize.");
+    this.mockRuntime = {
+      env: {
+        TWITTER_USERNAME: "testuser",
+        TWITTER_DRY_RUN: "true",
+        TWITTER_POST_INTERVAL_MIN: "90",
+        TWITTER_POST_INTERVAL_MAX: "180",
+        TWITTER_ENABLE_ACTION_PROCESSING: "true",
+        TWITTER_POST_IMMEDIATELY: "false"
+      },
+      getEnv: (key) => this.mockRuntime.env[key] || null,
+      getSetting: (key) => this.mockRuntime.env[key] || null,
+      character: {
+        style: {
+          all: ["Test style 1", "Test style 2"],
+          post: ["Post style 1", "Post style 2"]
+        }
       }
-    } catch (error) {
-      throw new Error(`Error in initializing Twitter client: ${error}`);
-    }
+    };
+    this.mockConfig = {
+      TWITTER_USERNAME: "testuser",
+      TWITTER_DRY_RUN: true,
+      TWITTER_SPACES_ENABLE: false,
+      TWITTER_TARGET_USERS: [],
+      TWITTER_PASSWORD: "hashedpassword",
+      TWITTER_EMAIL: "test@example.com",
+      TWITTER_2FA_SECRET: "",
+      TWITTER_RETRY_LIMIT: 5,
+      TWITTER_POLL_INTERVAL: 120,
+      TWITTER_ENABLE_POST_GENERATION: true,
+      TWITTER_POST_INTERVAL_MIN: 90,
+      TWITTER_POST_INTERVAL_MAX: 180,
+      TWITTER_POST_IMMEDIATELY: false
+    };
   }
-  /**
-   * Asynchronously fetches the profile of a user from Twitter using the given runtime.
-   *
-   * @param {IAgentRuntime} runtime The runtime to use for fetching the profile.
-   * @returns {Promise<void>} A Promise that resolves when the profile is successfully fetched, or rejects with an error.
-   */
-  async testFetchProfile(runtime) {
-    try {
-      const username = runtime.getSetting("TWITTER_USERNAME");
-      const profile = await this.twitterClient.client.fetchProfile(username);
-      if (!profile || !profile.id) {
-        throw new Error("Profile fetch failed.");
-      }
-      logger9.log("Successfully fetched Twitter profile:", profile);
-    } catch (error) {
-      throw new Error(`Error fetching Twitter profile: ${error}`);
+  async testInstanceCreation() {
+    const client = new ClientBase(this.mockRuntime, this.mockConfig);
+    if (!client) throw new Error("ClientBase instance creation failed.");
+    if (this.mockRuntime.getSetting("TWITTER_USERNAME") !== "testuser") {
+      throw new Error("TWITTER_USERNAME setting mismatch.");
     }
-  }
-  /**
-   * Asynchronously fetches search tweets from the Twitter API.
-   *
-   * @param {IAgentRuntime} _runtime - The runtime object used to access certain functionalities.
-   * @returns {Promise<void>} - A Promise that resolves once the search tweets have been successfully fetched.
-   * @throws {Error} - If there is an error while fetching the search tweets.
-   */
-  async testFetchSearchTweets(_runtime) {
-    try {
-      const tweets = await this.twitterClient.client.fetchSearchTweets(
-        `@${this.twitterClient.client.profile?.username}`,
-        5,
-        1 /* Latest */
-      );
-      logger9.debug(`Successfully fetched ${tweets.tweets.length} search tweets.`);
-    } catch (error) {
-      throw new Error(`Error fetching search tweets: ${error}`);
+    if (client.state.TWITTER_USERNAME !== "testuser") {
+      throw new Error("Client state TWITTER_USERNAME mismatch.");
     }
-  }
-  /**
-   * Asynchronously fetches the home timeline from the Twitter client.
-   *
-   * @param {IAgentRuntime} _runtime - The agent runtime object.
-   * @throws {Error} If there are no tweets in the home timeline.
-   * @throws {Error} If an error occurs while fetching the home timeline.
-   */
-  async testFetchHomeTimeline(_runtime) {
-    try {
-      const timeline = await this.twitterClient.client.fetchHomeTimeline(5);
-      if (!timeline || timeline.length === 0) {
-        throw new Error("No tweets in home timeline.");
-      }
-      logger9.log(`Successfully fetched ${timeline.length} tweets from home timeline.`);
-    } catch (error) {
-      throw new Error(`Error fetching home timeline: ${error}`);
+    if (this.mockRuntime.getSetting("TWITTER_DRY_RUN") !== "true") {
+      throw new Error("TWITTER_DRY_RUN setting mismatch.");
     }
-  }
-  /**
-   * Fetches own posts using the Twitter client.
-   *
-   * @param {IAgentRuntime} _runtime - The Agent Runtime object.
-   * @throws {Error} If no own posts are found or if there is an error fetching the posts.
-   */
-  async testFetchOwnPosts(_runtime) {
-    try {
-      const posts = await this.twitterClient.client.fetchOwnPosts(5);
-      if (!posts || posts.length === 0) {
-        throw new Error("No own posts found.");
-      }
-      logger9.log(`Successfully fetched ${posts.length} own posts.`);
-    } catch (error) {
-      throw new Error(`Error fetching own posts: ${error}`);
+    if (client.state.TWITTER_DRY_RUN !== true) {
+      throw new Error("Client state TWITTER_DRY_RUN mismatch.");
     }
+    logger9.success("ClientBase instance created with correct configuration.");
   }
-  /**
-   * Asynchronously posts a test tweet using the Twitter API.
-   *
-   * @param {IAgentRuntime} runtime - The agent runtime object.
-   * @returns {Promise<void>} A Promise that resolves when the tweet is successfully posted.
-   * @throws {Error} If there is an error posting the tweet.
-   */
-  async testPostTweet(runtime) {
-    try {
-      const roomId = createUniqueUuid7(runtime, "twitter_mock_room");
-      const postClient = this.twitterClient.post;
-      const tweetText = await this.generateRandomTweetContent(runtime);
-      await postClient.postTweet(
-        runtime,
-        this.twitterClient.client,
-        tweetText,
-        roomId,
-        tweetText,
-        "test-username"
-      );
-      logger9.success("Successfully posted a test tweet.");
-    } catch (error) {
-      throw new Error(`Error posting a tweet: ${error}`);
+  async testPostIntervals() {
+    const client = new ClientBase(this.mockRuntime, this.mockConfig);
+    if (this.mockRuntime.getSetting("TWITTER_POST_INTERVAL_MIN") !== "90") {
+      throw new Error("TWITTER_POST_INTERVAL_MIN setting mismatch.");
     }
-  }
-  /**
-   * Asynchronously posts an image tweet on Twitter using the provided runtime and tweet content.
-   *
-   * @param {IAgentRuntime} runtime - The runtime environment for the action.
-   * @returns {Promise<void>} A Promise that resolves when the tweet is successfully posted.
-   * @throws {Error} If there is an error posting the tweet.
-   */
-  async testPostImageTweet(runtime) {
-    try {
-      const roomId = createUniqueUuid7(runtime, "twitter_mock_room");
-      const postClient = this.twitterClient.post;
-      const tweetText = await this.generateRandomTweetContent(runtime, "image_post");
-      const mediaData = await fetchMediaData([TEST_IMAGE]);
-      await postClient.postTweet(
-        runtime,
-        this.twitterClient.client,
-        tweetText,
-        roomId,
-        tweetText,
-        "test-username",
-        mediaData
-      );
-      logger9.success("Successfully posted a test tweet.");
-    } catch (error) {
-      throw new Error(`Error posting a tweet: ${error}`);
+    if (client.state.TWITTER_POST_INTERVAL_MIN !== 90) {
+      throw new Error("Client state TWITTER_POST_INTERVAL_MIN mismatch.");
     }
-  }
-  /**
-   * Asynchronously generates a new tweet using the provided agent runtime.
-   *
-   * @param {IAgentRuntime} _runtime - The agent runtime used to generate the new tweet.
-   * @returns {Promise<void>} - A promise that resolves once the tweet has been successfully generated.
-   * @throws {Error} - If there is an error generating the new tweet.
-   */
-  async testGenerateNewTweet(_runtime) {
-    try {
-      const postClient = this.twitterClient.post;
-      await postClient.generateNewTweet();
-      logger9.success("Successfully generated a new tweet.");
-    } catch (error) {
-      throw new Error(`Error generating new tweet: ${error}`);
+    if (this.mockRuntime.getSetting("TWITTER_POST_INTERVAL_MAX") !== "180") {
+      throw new Error("TWITTER_POST_INTERVAL_MAX setting mismatch.");
     }
-  }
-  /**
-   * Asynchronously handles a fake tweet response using the given runtime.
-   *
-   * @param {IAgentRuntime} runtime - The runtime object for the agent
-   * @returns {Promise<void>} - A promise that resolves when the tweet response is handled
-   * @throws {Error} - If there is an error handling the tweet response
-   */
-  async testHandleTweetResponse(runtime) {
-    try {
-      const testTweet = {
-        id: "12345",
-        text: "@testUser What do you think about AI?",
-        username: "randomUser",
-        entityId: "randomUserId",
-        timestamp: Date.now() / 1e3,
-        conversationId: "67890",
-        permanentUrl: "https://twitter.com/randomUser/status/12345",
-        photos: [TEST_IMAGE],
-        hashtags: [],
-        mentions: [],
-        thread: [],
-        urls: [],
-        videos: []
-      };
-      await this.twitterClient.interaction.handleTweet({
-        tweet: testTweet,
-        message: {
-          content: { text: testTweet.text, source: "twitter" },
-          agentId: runtime.agentId,
-          entityId: createUniqueUuid7(runtime, testTweet.entityId),
-          roomId: createUniqueUuid7(runtime, testTweet.conversationId)
-        },
-        thread: []
-      });
-      logger9.success("Correct response decision.");
-    } catch (error) {
-      throw new Error(`Error handling tweet response: ${error}`);
+    if (client.state.TWITTER_POST_INTERVAL_MAX !== 180) {
+      throw new Error("Client state TWITTER_POST_INTERVAL_MAX mismatch.");
     }
-  }
-  /**
-   * Generates a random tweet content based on the given context.
-   *
-   * @param {IAgentRuntime} runtime - The runtime environment.
-   * @param {string} [context] - The context to determine the type of tweet content to generate. Optional.
-   * @returns {Promise<string>} The generated tweet content.
-   */
-  async generateRandomTweetContent(runtime, context) {
-    let prompt;
-    if (context === "image_post") {
-      prompt = `Generate a short, engaging tweet to accompany an image. 
-      It should feel natural and fit the tone of social media.
-      Keep it brief (under 150 characters).
-      It can be witty, descriptive, or thought-provoking.
-      Avoid generic captions like "Look at this" or "Nice picture."`;
-    } else {
-      prompt = `Generate a natural and engaging tweet. 
-      It should feel human, casual, and slightly thought-provoking. 
-      Keep it under 280 characters. 
-      Avoid generic bot-like statements. 
-      Make it sound like something a real person would tweet. 
-      Here\u2019s an example format:
-      - A random thought about life, technology, or human nature.
-      - A short, witty observation about the current moment.
-      - A lighthearted take on everyday situations.
-      Do not include hashtags or emojis.`;
-    }
-    return await runtime.useModel(ModelType5.TEXT_SMALL, {
-      prompt
-    });
+    logger9.success("ClientBase initialized with correct post intervals.");
   }
 };
 
@@ -9093,7 +8792,7 @@ var _TwitterService = class _TwitterService extends Service {
       const profile = client.client.profile;
       const twitterId = profile.id;
       const username = profile.username;
-      const worldId = createUniqueUuid8(runtime, twitterId);
+      const worldId = createUniqueUuid7(runtime, twitterId);
       const world = {
         id: worldId,
         name: `${username}'s Twitter`,
@@ -9110,7 +8809,7 @@ var _TwitterService = class _TwitterService extends Service {
           }
         }
       };
-      const homeTimelineRoomId = createUniqueUuid8(runtime, `${twitterId}-home`);
+      const homeTimelineRoomId = createUniqueUuid7(runtime, `${twitterId}-home`);
       const homeTimelineRoom = {
         id: homeTimelineRoomId,
         name: `${username}'s Timeline`,
@@ -9120,7 +8819,7 @@ var _TwitterService = class _TwitterService extends Service {
         serverId: twitterId,
         worldId
       };
-      const mentionsRoomId = createUniqueUuid8(runtime, `${twitterId}-mentions`);
+      const mentionsRoomId = createUniqueUuid7(runtime, `${twitterId}-mentions`);
       const mentionsRoom = {
         id: mentionsRoomId,
         name: `${username}'s Mentions`,
@@ -9130,7 +8829,7 @@ var _TwitterService = class _TwitterService extends Service {
         serverId: twitterId,
         worldId
       };
-      const twitterUserId = createUniqueUuid8(runtime, twitterId);
+      const twitterUserId = createUniqueUuid7(runtime, twitterId);
       const twitterUser = {
         id: twitterUserId,
         names: [profile.screenName || username],
@@ -9218,7 +8917,7 @@ var twitterPlugin = {
   description: "Twitter client with per-server instance management",
   services: [TwitterService],
   actions: [spaceJoin_default],
-  tests: [new TwitterTestSuite()]
+  tests: [new ClientBaseTestSuite()]
 };
 var index_default = twitterPlugin;
 export {