@elizaos/plugin-twitter 1.2.13 → 1.2.15

package/dist/index.js

@@ -5,10 +5,10 @@ var __export = (target, all) => {
 };
 
 // src/index.ts
-import { logger as logger10 } from "@elizaos/core";
+import { logger as logger11 } from "@elizaos/core";
 
 // src/services/twitter.service.ts
-import { Service, logger as logger8 } from "@elizaos/core";
+import { Service, logger as logger9 } from "@elizaos/core";
 
 // src/interactions.ts
 import {
@@ -16,7 +16,7 @@ import {
   EventType,
   ModelType,
   createUniqueUuid as createUniqueUuid2,
-  logger as logger3
+  logger as logger4
 } from "@elizaos/core";
 
 // src/client/auth.ts
@@ -2014,6 +2014,9 @@ var parseActionResponseFromText = (text) => {
   return { actions };
 };
 
+// src/environment.ts
+import { logger as logger3 } from "@elizaos/core";
+
 // src/utils/settings.ts
 function getSetting(runtime, key, defaultValue) {
   if (runtime && typeof runtime.getSetting === "function") {
@@ -6079,11 +6082,24 @@ var twitterEnvSchema = external_exports.object({
   // likes, retweets, quotes
   // Timing configuration (all in minutes)
   TWITTER_POST_INTERVAL: external_exports.string().default("120"),
-  // minutes between posts
+  // minutes between posts (deprecated, kept for backwards compatibility)
+  TWITTER_POST_INTERVAL_MIN: external_exports.string().default("90"),
+  // minimum minutes between posts
+  TWITTER_POST_INTERVAL_MAX: external_exports.string().default("150"),
+  // maximum minutes between posts
   TWITTER_ENGAGEMENT_INTERVAL: external_exports.string().default("30"),
-  // minutes between all interactions
+  // minutes between all interactions (deprecated, kept for backwards compatibility)
+  TWITTER_ENGAGEMENT_INTERVAL_MIN: external_exports.string().default("20"),
+  // minimum minutes between engagements
+  TWITTER_ENGAGEMENT_INTERVAL_MAX: external_exports.string().default("40"),
+  // maximum minutes between engagements
+  TWITTER_DISCOVERY_INTERVAL_MIN: external_exports.string().default("15"),
+  // minimum minutes between discovery cycles
+  TWITTER_DISCOVERY_INTERVAL_MAX: external_exports.string().default("30"),
+  // maximum minutes between discovery cycles
   // Limits
-  TWITTER_MAX_ENGAGEMENTS_PER_RUN: external_exports.string().default("10"),
+  TWITTER_MAX_ENGAGEMENTS_PER_RUN: external_exports.string().default("5"),
+  // Reduced from 10 to be less aggressive
   TWITTER_MAX_TWEET_LENGTH: external_exports.string().default("280"),
   // standard tweet length
   // Advanced
@@ -6145,16 +6161,52 @@ async function validateTwitterConfig(runtime, config = {}) {
           120
         )
       ),
+      TWITTER_POST_INTERVAL_MIN: String(
+        safeParseInt(
+          config.TWITTER_POST_INTERVAL_MIN ?? getSetting(runtime, "TWITTER_POST_INTERVAL_MIN"),
+          90
+        )
+      ),
+      TWITTER_POST_INTERVAL_MAX: String(
+        safeParseInt(
+          config.TWITTER_POST_INTERVAL_MAX ?? getSetting(runtime, "TWITTER_POST_INTERVAL_MAX"),
+          150
+        )
+      ),
       TWITTER_ENGAGEMENT_INTERVAL: String(
         safeParseInt(
           config.TWITTER_ENGAGEMENT_INTERVAL ?? getSetting(runtime, "TWITTER_ENGAGEMENT_INTERVAL"),
           30
         )
       ),
+      TWITTER_ENGAGEMENT_INTERVAL_MIN: String(
+        safeParseInt(
+          config.TWITTER_ENGAGEMENT_INTERVAL_MIN ?? getSetting(runtime, "TWITTER_ENGAGEMENT_INTERVAL_MIN"),
+          20
+        )
+      ),
+      TWITTER_ENGAGEMENT_INTERVAL_MAX: String(
+        safeParseInt(
+          config.TWITTER_ENGAGEMENT_INTERVAL_MAX ?? getSetting(runtime, "TWITTER_ENGAGEMENT_INTERVAL_MAX"),
+          40
+        )
+      ),
+      TWITTER_DISCOVERY_INTERVAL_MIN: String(
+        safeParseInt(
+          config.TWITTER_DISCOVERY_INTERVAL_MIN ?? getSetting(runtime, "TWITTER_DISCOVERY_INTERVAL_MIN"),
+          15
+        )
+      ),
+      TWITTER_DISCOVERY_INTERVAL_MAX: String(
+        safeParseInt(
+          config.TWITTER_DISCOVERY_INTERVAL_MAX ?? getSetting(runtime, "TWITTER_DISCOVERY_INTERVAL_MAX"),
+          30
+        )
+      ),
       TWITTER_MAX_ENGAGEMENTS_PER_RUN: String(
         safeParseInt(
           config.TWITTER_MAX_ENGAGEMENTS_PER_RUN ?? getSetting(runtime, "TWITTER_MAX_ENGAGEMENTS_PER_RUN"),
-          10
+          5
         )
       ),
       TWITTER_MAX_TWEET_LENGTH: String(
@@ -6186,6 +6238,49 @@ async function validateTwitterConfig(runtime, config = {}) {
     throw error;
   }
 }
+function getRandomInterval(runtime, type) {
+  let minInterval;
+  let maxInterval;
+  let fallbackInterval;
+  switch (type) {
+    case "post":
+      const postMin = getSetting(runtime, "TWITTER_POST_INTERVAL_MIN");
+      const postMax = getSetting(runtime, "TWITTER_POST_INTERVAL_MAX");
+      minInterval = postMin ? safeParseInt(postMin, 0) : void 0;
+      maxInterval = postMax ? safeParseInt(postMax, 0) : void 0;
+      fallbackInterval = safeParseInt(
+        getSetting(runtime, "TWITTER_POST_INTERVAL"),
+        120
+      );
+      break;
+    case "engagement":
+      const engagementMin = getSetting(runtime, "TWITTER_ENGAGEMENT_INTERVAL_MIN");
+      const engagementMax = getSetting(runtime, "TWITTER_ENGAGEMENT_INTERVAL_MAX");
+      minInterval = engagementMin ? safeParseInt(engagementMin, 0) : void 0;
+      maxInterval = engagementMax ? safeParseInt(engagementMax, 0) : void 0;
+      fallbackInterval = safeParseInt(
+        getSetting(runtime, "TWITTER_ENGAGEMENT_INTERVAL"),
+        30
+      );
+      break;
+    case "discovery":
+      const discoveryMin = getSetting(runtime, "TWITTER_DISCOVERY_INTERVAL_MIN");
+      const discoveryMax = getSetting(runtime, "TWITTER_DISCOVERY_INTERVAL_MAX");
+      minInterval = discoveryMin ? safeParseInt(discoveryMin, 0) : void 0;
+      maxInterval = discoveryMax ? safeParseInt(discoveryMax, 0) : void 0;
+      fallbackInterval = 20;
+      break;
+    default:
+      throw new Error(`Unknown interval type: ${type}`);
+  }
+  if (minInterval !== void 0 && maxInterval !== void 0 && minInterval < maxInterval) {
+    const randomInterval = Math.random() * (maxInterval - minInterval) + minInterval;
+    logger3.debug(`Random ${type} interval: ${randomInterval.toFixed(1)} minutes (between ${minInterval}-${maxInterval})`);
+    return randomInterval;
+  }
+  logger3.debug(`Using fixed ${type} interval: ${fallbackInterval} minutes`);
+  return fallbackInterval;
+}
 
 // src/interactions.ts
 var TwitterInteractionClient = class {
@@ -6213,15 +6308,13 @@ var TwitterInteractionClient = class {
     this.isRunning = true;
     const handleTwitterInteractionsLoop = () => {
       if (!this.isRunning) {
-        logger3.info("Twitter interaction client stopped, exiting loop");
+        logger4.info("Twitter interaction client stopped, exiting loop");
         return;
       }
-      const engagementIntervalMinutes = parseInt(
-        this.state?.TWITTER_ENGAGEMENT_INTERVAL || getSetting(this.runtime, "TWITTER_ENGAGEMENT_INTERVAL") || process.env.TWITTER_ENGAGEMENT_INTERVAL || "30"
-      );
+      const engagementIntervalMinutes = getRandomInterval(this.runtime, "engagement");
       const interactionInterval = engagementIntervalMinutes * 60 * 1e3;
-      logger3.info(
-        `Twitter interaction client will check every ${engagementIntervalMinutes} minutes`
+      logger4.info(
+        `Twitter interaction client will check in ${engagementIntervalMinutes.toFixed(1)} minutes`
       );
       this.handleTwitterInteractions();
       if (this.isRunning) {
@@ -6234,14 +6327,14 @@ var TwitterInteractionClient = class {
    * Stops the Twitter interaction client
    */
   async stop() {
-    logger3.log("Stopping Twitter interaction client...");
+    logger4.log("Stopping Twitter interaction client...");
     this.isRunning = false;
   }
   /**
    * Asynchronously handles Twitter interactions by checking for mentions and target user posts.
    */
   async handleTwitterInteractions() {
-    logger3.log("Checking Twitter interactions");
+    logger4.log("Checking Twitter interactions");
     const twitterUsername = this.client.profile?.username;
     try {
       const repliesEnabled = (getSetting(this.runtime, "TWITTER_ENABLE_REPLIES") ?? process.env.TWITTER_ENABLE_REPLIES) !== "false";
@@ -6253,9 +6346,9 @@ var TwitterInteractionClient = class {
         await this.handleTargetUserPosts(targetUsersConfig);
       }
       await this.client.cacheLatestCheckedTweetId();
-      logger3.log("Finished checking Twitter interactions");
+      logger4.log("Finished checking Twitter interactions");
     } catch (error) {
-      logger3.error("Error handling Twitter interactions:", error);
+      logger4.error("Error handling Twitter interactions:", error);
     }
   }
   /**
@@ -6279,7 +6372,7 @@ var TwitterInteractionClient = class {
       }
       await this.processMentionTweets(mentionCandidates);
     } catch (error) {
-      logger3.error("Error handling mentions:", error);
+      logger4.error("Error handling mentions:", error);
     }
   }
   /**
@@ -6291,7 +6384,7 @@ var TwitterInteractionClient = class {
       if (targetUsers.length === 0 && !targetUsersConfig.includes("*")) {
         return;
       }
-      logger3.info(
+      logger4.info(
         `Checking posts from target users: ${targetUsers.join(", ") || "everyone (*)"}`
       );
       for (const targetUser of targetUsers) {
@@ -6305,7 +6398,7 @@ var TwitterInteractionClient = class {
             1 /* Latest */
           );
           if (searchResult.tweets.length > 0) {
-            logger3.info(
+            logger4.info(
               `Found ${searchResult.tweets.length} posts from @${normalizedUsername}`
             );
             await this.processTargetUserTweets(
@@ -6314,14 +6407,14 @@ var TwitterInteractionClient = class {
             );
           }
         } catch (error) {
-          logger3.error(`Error searching posts from @${targetUser}:`, error);
+          logger4.error(`Error searching posts from @${targetUser}:`, error);
         }
       }
       if (targetUsersConfig.includes("*")) {
         await this.processTimelineForEngagement();
       }
     } catch (error) {
-      logger3.error("Error handling target user posts:", error);
+      logger4.error("Error handling target user posts:", error);
     }
   }
   /**
@@ -6334,7 +6427,7 @@ var TwitterInteractionClient = class {
     let engagementCount = 0;
     for (const tweet of tweets) {
       if (engagementCount >= maxEngagementsPerRun) {
-        logger3.info(`Reached max engagements limit (${maxEngagementsPerRun})`);
+        logger4.info(`Reached max engagements limit (${maxEngagementsPerRun})`);
         break;
       }
       const tweetId = createUniqueUuid2(this.runtime, tweet.id);
@@ -6349,7 +6442,7 @@ var TwitterInteractionClient = class {
       }
       const shouldEngage = await this.shouldEngageWithTweet(tweet);
       if (shouldEngage) {
-        logger3.info(
+        logger4.info(
           `Engaging with tweet from @${username}: ${tweet.text.substring(0, 50)}...`
         );
         await this.ensureTweetContext(tweet);
@@ -6375,13 +6468,13 @@ var TwitterInteractionClient = class {
         return tweetAge < 12 * 60 * 60 * 1e3;
       });
       if (relevantTweets.length > 0) {
-        logger3.info(
+        logger4.info(
           `Found ${relevantTweets.length} relevant tweets from timeline`
         );
         await this.processTargetUserTweets(relevantTweets, "timeline");
       }
     } catch (error) {
-      logger3.error("Error processing timeline for engagement:", error);
+      logger4.error("Error processing timeline for engagement:", error);
     }
   }
   /**
@@ -6434,7 +6527,7 @@ Response (YES/NO):`;
       });
       return response.trim().toUpperCase().includes("YES");
     } catch (error) {
-      logger3.error("Error determining engagement:", error);
+      logger4.error("Error determining engagement:", error);
       return false;
     }
   }
@@ -6460,6 +6553,15 @@ Response (YES/NO):`;
       }
     });
     const roomId = createUniqueUuid2(this.runtime, conversationId);
+    await this.runtime.ensureRoomExists({
+      id: roomId,
+      name: `Twitter conversation ${conversationId}`,
+      source: "twitter",
+      type: ChannelType.FEED,
+      channelId: conversationId,
+      serverId: userId,
+      worldId
+    });
     const entityId = createUniqueUuid2(this.runtime, userId);
     await this.runtime.ensureConnection({
       entityId,
@@ -6509,7 +6611,7 @@ Response (YES/NO):`;
       });
       return result.text && result.text.length > 0;
     } catch (error) {
-      logger3.error("Error engaging with tweet:", error);
+      logger4.error("Error engaging with tweet:", error);
       return false;
     }
   }
@@ -6524,7 +6626,7 @@ Response (YES/NO):`;
    * Note: MENTION_RECEIVED is currently disabled (see TODO below)
    */
   async processMentionTweets(mentionCandidates) {
-    logger3.log(
+    logger4.log(
       "Completed checking mentioned tweets:",
       mentionCandidates.length
     );
@@ -6538,7 +6640,7 @@ Response (YES/NO):`;
           targetUsersConfig
         );
         if (!shouldTarget) {
-          logger3.log(
+          logger4.log(
             `Skipping tweet from @${tweet.username} - not in target users list`
           );
         }
@@ -6552,7 +6654,7 @@ Response (YES/NO):`;
       0,
       maxInteractionsPerRun
     );
-    logger3.info(
+    logger4.info(
       `Processing ${tweetsToProcess.length} of ${uniqueTweetCandidates.length} mention tweets (max: ${maxInteractionsPerRun})`
     );
     for (const tweet of tweetsToProcess) {
@@ -6560,7 +6662,7 @@ Response (YES/NO):`;
         const tweetId = createUniqueUuid2(this.runtime, tweet.id);
         const existingResponse = await this.runtime.getMemoryById(tweetId);
         if (existingResponse) {
-          logger3.log(`Already responded to tweet ${tweet.id}, skipping`);
+          logger4.log(`Already responded to tweet ${tweet.id}, skipping`);
           continue;
         }
         const conversationRoomId = createUniqueUuid2(
@@ -6577,22 +6679,22 @@ Response (YES/NO):`;
           (memory2) => memory2.content.inReplyTo === tweetId || memory2.content.inReplyTo === tweet.id
         );
         if (hasExistingReply) {
-          logger3.log(
+          logger4.log(
             `Already responded to tweet ${tweet.id} (found in conversation history), skipping`
           );
           continue;
         }
-        logger3.log("New Tweet found", tweet.id);
+        logger4.log("New Tweet found", tweet.id);
         const userId = tweet.userId;
         const conversationId = tweet.conversationId || tweet.id;
         const roomId = createUniqueUuid2(this.runtime, conversationId);
         const username = tweet.username;
-        logger3.log("----");
-        logger3.log(`User: ${username} (${userId})`);
-        logger3.log(`Tweet: ${tweet.id}`);
-        logger3.log(`Conversation: ${conversationId}`);
-        logger3.log(`Room: ${roomId}`);
-        logger3.log("----");
+        logger4.log("----");
+        logger4.log(`User: ${username} (${userId})`);
+        logger4.log(`Tweet: ${tweet.id}`);
+        logger4.log(`Conversation: ${conversationId}`);
+        logger4.log(`Room: ${roomId}`);
+        logger4.log("----");
         const worldId = createUniqueUuid2(this.runtime, userId);
         await this.runtime.ensureWorldExists({
           id: worldId,
@@ -6617,6 +6719,15 @@ Response (YES/NO):`;
           type: ChannelType.FEED,
           worldId
         });
+        await this.runtime.ensureRoomExists({
+          id: roomId,
+          name: `Twitter conversation ${conversationId}`,
+          source: "twitter",
+          type: ChannelType.FEED,
+          channelId: conversationId,
+          serverId: userId,
+          worldId
+        });
         const memory = {
           id: tweetId,
           entityId,
@@ -6630,7 +6741,7 @@ Response (YES/NO):`;
           roomId,
           createdAt: tweet.timestamp * 1e3
         };
-        logger3.log("Saving tweet memory...");
+        logger4.log("Saving tweet memory...");
         await this.runtime.createMemory(memory, "messages");
         if (tweet.thread && tweet.thread.length > 0) {
           const threadStartId = tweet.thread[0].id;
@@ -6813,23 +6924,23 @@ Response (YES/NO):`;
     thread
   }) {
     if (!message.content.text) {
-      logger3.log("Skipping Tweet with no text", tweet.id);
+      logger4.log("Skipping Tweet with no text", tweet.id);
       return { text: "", actions: ["IGNORE"] };
     }
     const callback = async (response2, tweetId) => {
       try {
         if (!response2.text) {
-          logger3.warn("No text content in response, skipping tweet reply");
+          logger4.warn("No text content in response, skipping tweet reply");
           return [];
         }
         const tweetToReplyTo = tweetId || tweet.id;
         if (this.isDryRun) {
-          logger3.info(
+          logger4.info(
             `[DRY RUN] Would have replied to ${tweet.username} with: ${response2.text}`
           );
           return [];
         }
-        logger3.info(`Replying to tweet ${tweetToReplyTo}`);
+        logger4.info(`Replying to tweet ${tweetToReplyTo}`);
         const tweetResult = await sendTweet(
           this.client,
           response2.text,
@@ -6855,7 +6966,7 @@ Response (YES/NO):`;
         await this.runtime.createMemory(responseMemory, "messages");
         return [responseMemory];
       } catch (error) {
-        logger3.error("Error in tweet reply callback:", error);
+        logger4.error("Error in tweet reply callback:", error);
         return [];
       }
     };
@@ -6894,8 +7005,9 @@ Response (YES/NO):`;
 
 // src/post.ts
 import {
+  ChannelType as ChannelType2,
   createUniqueUuid as createUniqueUuid3,
-  logger as logger4,
+  logger as logger5,
   ModelType as ModelType2
 } from "@elizaos/core";
 var TwitterPostClient = class {
@@ -6914,39 +7026,40 @@ var TwitterPostClient = class {
     this.runtime = runtime;
     const dryRunSetting = this.state?.TWITTER_DRY_RUN ?? getSetting(this.runtime, "TWITTER_DRY_RUN") ?? process.env.TWITTER_DRY_RUN;
     this.isDryRun = dryRunSetting === true || dryRunSetting === "true" || typeof dryRunSetting === "string" && dryRunSetting.toLowerCase() === "true";
-    logger4.log("Twitter Post Client Configuration:");
-    logger4.log(`- Dry Run Mode: ${this.isDryRun ? "Enabled" : "Disabled"}`);
-    const postIntervalMinutes = parseInt(
-      this.state?.TWITTER_POST_INTERVAL || getSetting(this.runtime, "TWITTER_POST_INTERVAL") || process.env.TWITTER_POST_INTERVAL || "120"
+    logger5.log("Twitter Post Client Configuration:");
+    logger5.log(`- Dry Run Mode: ${this.isDryRun ? "Enabled" : "Disabled"}`);
+    const postIntervalMin = parseInt(
+      this.state?.TWITTER_POST_INTERVAL_MIN || getSetting(this.runtime, "TWITTER_POST_INTERVAL_MIN") || process.env.TWITTER_POST_INTERVAL_MIN || "90"
+    );
+    const postIntervalMax = parseInt(
+      this.state?.TWITTER_POST_INTERVAL_MAX || getSetting(this.runtime, "TWITTER_POST_INTERVAL_MAX") || process.env.TWITTER_POST_INTERVAL_MAX || "150"
     );
-    logger4.log(`- Post Interval: ${postIntervalMinutes} minutes`);
+    logger5.log(`- Post Interval: ${postIntervalMin}-${postIntervalMax} minutes (randomized)`);
   }
   /**
    * Stops the Twitter post client
    */
   async stop() {
-    logger4.log("Stopping Twitter post client...");
+    logger5.log("Stopping Twitter post client...");
     this.isRunning = false;
   }
   /**
    * Starts the Twitter post client, setting up a loop to periodically generate new tweets.
    */
   async start() {
-    logger4.log("Starting Twitter post client...");
+    logger5.log("Starting Twitter post client...");
     this.isRunning = true;
     const generateNewTweetLoop = async () => {
       if (!this.isRunning) {
-        logger4.log("Twitter post client stopped, exiting loop");
+        logger5.log("Twitter post client stopped, exiting loop");
         return;
       }
-      const postIntervalMinutes = parseInt(
-        this.state?.TWITTER_POST_INTERVAL || getSetting(this.runtime, "TWITTER_POST_INTERVAL") || process.env.TWITTER_POST_INTERVAL || "120"
-      );
+      const postIntervalMinutes = getRandomInterval(this.runtime, "post");
       const interval = postIntervalMinutes * 60 * 1e3;
-      logger4.info(`Next tweet scheduled in ${postIntervalMinutes} minutes`);
+      logger5.info(`Next tweet scheduled in ${postIntervalMinutes.toFixed(1)} minutes`);
       await new Promise((resolve) => setTimeout(resolve, interval));
       if (!this.isRunning) {
-        logger4.log("Twitter post client stopped during wait, exiting loop");
+        logger5.log("Twitter post client stopped during wait, exiting loop");
         return;
       }
       await this.generateNewTweet();
@@ -6957,7 +7070,7 @@ var TwitterPostClient = class {
     await new Promise((resolve) => setTimeout(resolve, 1e3));
     const postImmediately = this.state?.TWITTER_POST_IMMEDIATELY || getSetting(this.runtime, "TWITTER_POST_IMMEDIATELY") || process.env.TWITTER_POST_IMMEDIATELY;
     if (postImmediately === "true" || postImmediately === true) {
-      logger4.info(
+      logger5.info(
         "TWITTER_POST_IMMEDIATELY is true, generating initial tweet now"
       );
       await this.generateNewTweet();
@@ -6969,19 +7082,19 @@ var TwitterPostClient = class {
    * This approach aligns with our platform-independent architecture.
    */
   async generateNewTweet() {
-    logger4.info("Attempting to generate new tweet...");
+    logger5.info("Attempting to generate new tweet...");
     if (this.isPosting) {
-      logger4.info("Already posting a tweet, skipping concurrent attempt");
+      logger5.info("Already posting a tweet, skipping concurrent attempt");
       return;
     }
     this.isPosting = true;
     try {
       const userId = this.client.profile?.id;
       if (!userId) {
-        logger4.error("Cannot generate tweet: Twitter profile not available");
+        logger5.error("Cannot generate tweet: Twitter profile not available");
         return;
       }
-      logger4.info(
+      logger5.info(
         `Generating tweet for user: ${this.client.profile?.username} (${userId})`
       );
       const worldId = createUniqueUuid3(this.runtime, userId);
@@ -6993,7 +7106,7 @@ var TwitterPostClient = class {
         content: { text: "", type: "post" },
         createdAt: Date.now()
       }).catch((error) => {
-        logger4.warn("Error composing state, using minimal state:", error);
+        logger5.warn("Error composing state, using minimal state:", error);
         return {
           agentId: this.runtime.agentId,
           recentMemories: [],
@@ -7041,15 +7154,15 @@ Generate a single tweet that sounds like YOU would actually write it:`;
       );
       const tweetText = generatedContent.trim();
       if (!tweetText || tweetText.length === 0) {
-        logger4.error("Generated empty tweet content");
+        logger5.error("Generated empty tweet content");
         return;
       }
       if (tweetText.includes("Error: Missing")) {
-        logger4.error("Error in generated content:", tweetText);
+        logger5.error("Error in generated content:", tweetText);
         return;
       }
       if (tweetText.length > 280) {
-        logger4.warn(`Generated tweet too long (${tweetText.length} chars), truncating...`);
+        logger5.warn(`Generated tweet too long (${tweetText.length} chars), truncating...`);
         const sentences = tweetText.match(/[^.!?]+[.!?]+/g) || [tweetText];
         let truncated = "";
         for (const sentence of sentences) {
@@ -7060,39 +7173,72 @@ Generate a single tweet that sounds like YOU would actually write it:`;
           }
         }
         const finalTweet = truncated.trim() || tweetText.substring(0, 277) + "...";
-        logger4.info(`Truncated tweet: ${finalTweet}`);
+        logger5.info(`Truncated tweet: ${finalTweet}`);
         if (this.isDryRun) {
-          logger4.info(`[DRY RUN] Would post tweet: ${finalTweet}`);
+          logger5.info(`[DRY RUN] Would post tweet: ${finalTweet}`);
           return;
         }
         const result2 = await this.postToTwitter(finalTweet, []);
         if (result2 === null) {
-          logger4.info("Skipped posting duplicate tweet");
+          logger5.info("Skipped posting duplicate tweet");
           return;
         }
         const tweetId2 = result2.id;
-        logger4.info(`Tweet posted successfully! ID: ${tweetId2}`);
-        logger4.info("Tweet posted successfully (memory saving disabled due to room constraints)");
+        logger5.info(`Tweet posted successfully! ID: ${tweetId2}`);
+        logger5.info("Tweet posted successfully (memory saving disabled due to room constraints)");
         return;
       }
-      logger4.info(`Generated tweet: ${tweetText}`);
+      logger5.info(`Generated tweet: ${tweetText}`);
       if (this.isDryRun) {
-        logger4.info(`[DRY RUN] Would post tweet: ${tweetText}`);
+        logger5.info(`[DRY RUN] Would post tweet: ${tweetText}`);
         return;
       }
       const result = await this.postToTwitter(tweetText, []);
       if (result === null) {
-        logger4.info("Skipped posting duplicate tweet");
+        logger5.info("Skipped posting duplicate tweet");
         return;
       }
       const tweetId = result.id;
-      logger4.info(`Tweet posted successfully! ID: ${tweetId}`);
+      logger5.info(`Tweet posted successfully! ID: ${tweetId}`);
       if (result) {
         const postedTweetId = createUniqueUuid3(this.runtime, tweetId);
-        logger4.info("Tweet posted successfully (memory saving temporarily disabled)");
+        await this.runtime.ensureWorldExists({
+          id: worldId,
+          name: `${this.client.profile?.username}'s Twitter`,
+          agentId: this.runtime.agentId,
+          serverId: userId
+        });
+        await this.runtime.ensureRoomExists({
+          id: roomId,
+          name: `${this.client.profile?.username}'s Timeline`,
+          source: "twitter",
+          type: ChannelType2.FEED,
+          channelId: `${userId}-home`,
+          serverId: userId,
+          worldId
+        });
+        const postedMemory = {
+          id: postedTweetId,
+          entityId: this.runtime.agentId,
+          agentId: this.runtime.agentId,
+          roomId,
+          content: {
+            text: tweetText,
+            source: "twitter",
+            channelType: ChannelType2.FEED,
+            type: "post",
+            metadata: {
+              tweetId,
+              postedAt: Date.now()
+            }
+          },
+          createdAt: Date.now()
+        };
+        await this.runtime.createMemory(postedMemory, "messages");
+        logger5.info("Tweet posted and saved to memory successfully");
       }
     } catch (error) {
-      logger4.error("Error generating tweet:", error);
+      logger5.error("Error generating tweet:", error);
     } finally {
       this.isPosting = false;
     }
@@ -7111,7 +7257,7 @@ Generate a single tweet that sounds like YOU would actually write it:`;
       if (lastPost) {
         const lastTweet = await this.client.getTweet(lastPost.id);
         if (lastTweet && lastTweet.text === text) {
-          logger4.warn(
+          logger5.warn(
             "Tweet is a duplicate of the last post. Skipping to avoid duplicate."
           );
           return null;
@@ -7121,11 +7267,11 @@ Generate a single tweet that sounds like YOU would actually write it:`;
       if (mediaData && mediaData.length > 0) {
         for (const media of mediaData) {
           try {
-            logger4.warn(
+            logger5.warn(
               "Media upload not currently supported with the modern Twitter API"
             );
           } catch (error) {
-            logger4.error("Error uploading media:", error);
+            logger5.error("Error uploading media:", error);
           }
         }
       }
@@ -7140,7 +7286,7 @@ Generate a single tweet that sounds like YOU would actually write it:`;
       );
       return result;
     } catch (error) {
-      logger4.error("Error posting to Twitter:", error);
+      logger5.error("Error posting to Twitter:", error);
       throw error;
     }
   }
@@ -7154,7 +7300,7 @@ import {
   ModelType as ModelType3,
   parseKeyValueXml
 } from "@elizaos/core";
-import { logger as logger5 } from "@elizaos/core";
+import { logger as logger6 } from "@elizaos/core";
 
 // src/templates.ts
 var twitterActionTemplate = `
@@ -7234,18 +7380,18 @@ var TwitterTimelineClient = class {
     this.timelineType = timelineMode === "following" /* Following */ ? "following" /* Following */ : "foryou" /* ForYou */;
   }
   async start() {
-    logger5.info("Starting Twitter timeline client...");
+    logger6.info("Starting Twitter timeline client...");
     this.isRunning = true;
     const handleTwitterTimelineLoop = () => {
       if (!this.isRunning) {
-        logger5.info("Twitter timeline client stopped, exiting loop");
+        logger6.info("Twitter timeline client stopped, exiting loop");
         return;
       }
       const engagementIntervalMinutes = parseInt(
         this.state?.TWITTER_ENGAGEMENT_INTERVAL || getSetting(this.runtime, "TWITTER_ENGAGEMENT_INTERVAL") || process.env.TWITTER_ENGAGEMENT_INTERVAL || "30"
       );
       const actionInterval = engagementIntervalMinutes * 60 * 1e3;
-      logger5.info(
+      logger6.info(
         `Timeline client will check every ${engagementIntervalMinutes} minutes`
       );
       this.handleTimeline();
@@ -7256,7 +7402,7 @@ var TwitterTimelineClient = class {
     handleTwitterTimelineLoop();
   }
   async stop() {
-    logger5.info("Stopping Twitter timeline client...");
+    logger6.info("Stopping Twitter timeline client...");
     this.isRunning = false;
   }
   async getTimeline(count) {
@@ -7286,9 +7432,9 @@ var TwitterTimelineClient = class {
     };
   }
   async handleTimeline() {
-    logger5.info("Starting Twitter timeline processing...");
+    logger6.info("Starting Twitter timeline processing...");
     const tweets = await this.getTimeline(20);
-    logger5.info(`Fetched ${tweets.length} tweets from timeline`);
+    logger6.info(`Fetched ${tweets.length} tweets from timeline`);
     const maxActionsPerCycle = parseInt(
       getSetting(this.runtime, "TWITTER_MAX_ENGAGEMENTS_PER_RUN") || process.env.TWITTER_MAX_ENGAGEMENTS_PER_RUN || "10"
     );
@@ -7298,7 +7444,7 @@ var TwitterTimelineClient = class {
         const tweetId = this.createTweetId(this.runtime, tweet);
         const memory = await this.runtime.getMemoryById(tweetId);
         if (memory) {
-          logger5.log(`Already processed tweet ID: ${tweet.id}`);
+          logger6.log(`Already processed tweet ID: ${tweet.id}`);
           continue;
         }
         const roomId = createUniqueUuid4(this.runtime, tweet.conversationId);
@@ -7322,7 +7468,7 @@ Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appro
         );
         const parsedResponse = parseActionResponseFromText(actionResponse);
         if (!parsedResponse) {
-          logger5.debug(`No action response generated for tweet ${tweet.id}`);
+          logger6.debug(`No action response generated for tweet ${tweet.id}`);
           continue;
         }
         tweetDecisions.push({
@@ -7333,7 +7479,7 @@ Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appro
         });
         if (tweetDecisions.length >= maxActionsPerCycle) break;
       } catch (error) {
-        logger5.error(`Error processing tweet ${tweet.id}:`, error);
+        logger6.error(`Error processing tweet ${tweet.id}:`, error);
       }
     }
     const rankByActionRelevance = (arr) => {
@@ -7351,7 +7497,7 @@ Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appro
       });
     };
     const prioritizedTweets = rankByActionRelevance(tweetDecisions);
-    logger5.info(`Processing ${prioritizedTweets.length} tweets with actions`);
+    logger6.info(`Processing ${prioritizedTweets.length} tweets with actions`);
     if (prioritizedTweets.length > 0) {
       const actionSummary = prioritizedTweets.map((td) => {
         const actions = [];
@@ -7361,11 +7507,11 @@ Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appro
         if (td.actionResponse.reply) actions.push("REPLY");
         return `Tweet ${td.tweet.id}: ${actions.join(", ")}`;
       });
-      logger5.info(`Actions to execute:
+      logger6.info(`Actions to execute:
 ${actionSummary.join("\n")}`);
     }
     await this.processTimelineActions(prioritizedTweets);
-    logger5.info("Timeline processing complete");
+    logger6.info("Timeline processing complete");
   }
   async processTimelineActions(tweetDecisions) {
     const results = [];
@@ -7377,6 +7523,15 @@ ${actionSummary.join("\n")}`);
     } of tweetDecisions) {
       const tweetId = this.createTweetId(this.runtime, tweet);
       const executedActions = [];
+      await this.runtime.ensureRoomExists({
+        id: roomId,
+        name: `Twitter conversation ${tweet.conversationId}`,
+        source: "twitter",
+        type: ChannelType3.GROUP,
+        channelId: tweet.conversationId,
+        serverId: tweet.userId,
+        worldId: createUniqueUuid4(this.runtime, tweet.userId)
+      });
       await this.runtime.createMemory(
         {
           id: tweetId,
@@ -7417,7 +7572,7 @@ ${actionSummary.join("\n")}`);
         }
         results.push({ tweetId: tweet.id, actionResponse, executedActions });
       } catch (error) {
-        logger5.error(`Error processing actions for tweet ${tweet.id}:`, error);
+        logger6.error(`Error processing actions for tweet ${tweet.id}:`, error);
       }
     }
     return results;
@@ -7461,25 +7616,25 @@ ${actionSummary.join("\n")}`);
   async handleLikeAction(tweet) {
     try {
       if (this.isDryRun) {
-        logger5.log(`[DRY RUN] Would have liked tweet ${tweet.id}`);
+        logger6.log(`[DRY RUN] Would have liked tweet ${tweet.id}`);
         return;
       }
       await this.twitterClient.likeTweet(tweet.id);
-      logger5.log(`Liked tweet ${tweet.id}`);
+      logger6.log(`Liked tweet ${tweet.id}`);
     } catch (error) {
-      logger5.error(`Error liking tweet ${tweet.id}:`, error);
+      logger6.error(`Error liking tweet ${tweet.id}:`, error);
     }
   }
   async handleRetweetAction(tweet) {
     try {
       if (this.isDryRun) {
-        logger5.log(`[DRY RUN] Would have retweeted tweet ${tweet.id}`);
+        logger6.log(`[DRY RUN] Would have retweeted tweet ${tweet.id}`);
         return;
       }
       await this.twitterClient.retweet(tweet.id);
-      logger5.log(`Retweeted tweet ${tweet.id}`);
+      logger6.log(`Retweeted tweet ${tweet.id}`);
     } catch (error) {
-      logger5.error(`Error retweeting tweet ${tweet.id}:`, error);
+      logger6.error(`Error retweeting tweet ${tweet.id}:`, error);
     }
   }
   async handleQuoteAction(tweet) {
@@ -7498,7 +7653,7 @@ ${tweet.text}`;
       const responseObject = parseKeyValueXml(quoteResponse);
       if (responseObject.post) {
         if (this.isDryRun) {
-          logger5.log(
+          logger6.log(
             `[DRY RUN] Would have quoted tweet ${tweet.id} with: ${responseObject.post}`
           );
           return;
@@ -7512,9 +7667,9 @@ ${tweet.text}`;
         const body = await result.json();
         const tweetResult = body?.data?.create_tweet?.tweet_results?.result || body?.data || body;
         if (tweetResult) {
-          logger5.log("Successfully posted quote tweet");
+          logger6.log("Successfully posted quote tweet");
         } else {
-          logger5.error("Quote tweet creation failed:", body);
+          logger6.error("Quote tweet creation failed:", body);
         }
         const tweetId = tweetResult?.id || Date.now().toString();
         const responseId = createUniqueUuid4(this.runtime, tweetId);
@@ -7532,7 +7687,7 @@ ${tweet.text}`;
         await this.runtime.createMemory(responseMemory, "messages");
       }
     } catch (error) {
-      logger5.error("Error in quote tweet generation:", error);
+      logger6.error("Error in quote tweet generation:", error);
     }
   }
   async handleReplyAction(tweet) {
@@ -7551,7 +7706,7 @@ ${tweet.text}`;
       const responseObject = parseKeyValueXml(replyResponse);
       if (responseObject.post) {
         if (this.isDryRun) {
-          logger5.log(
+          logger6.log(
             `[DRY RUN] Would have replied to tweet ${tweet.id} with: ${responseObject.post}`
           );
           return;
@@ -7563,7 +7718,7 @@ ${tweet.text}`;
           tweet.id
         );
         if (result) {
-          logger5.log("Successfully posted reply tweet");
+          logger6.log("Successfully posted reply tweet");
           const responseId = createUniqueUuid4(this.runtime, result.id);
           const responseMemory = {
             id: responseId,
@@ -7580,7 +7735,7 @@ ${tweet.text}`;
         }
       }
     } catch (error) {
-      logger5.error("Error in reply tweet generation:", error);
+      logger6.error("Error in reply tweet generation:", error);
     }
   }
 };
@@ -7588,7 +7743,7 @@ ${tweet.text}`;
 // src/discovery.ts
 import {
   createUniqueUuid as createUniqueUuid5,
-  logger as logger6,
+  logger as logger7,
   ModelType as ModelType4
 } from "@elizaos/core";
 var TwitterDiscoveryClient = class {
@@ -7602,7 +7757,7 @@ var TwitterDiscoveryClient = class {
     const dryRunSetting = state?.TWITTER_DRY_RUN ?? getSetting(this.runtime, "TWITTER_DRY_RUN") ?? process.env.TWITTER_DRY_RUN;
     this.isDryRun = dryRunSetting === true || dryRunSetting === "true" || typeof dryRunSetting === "string" && dryRunSetting.toLowerCase() === "true";
     this.config = this.buildDiscoveryConfig();
-    logger6.info("Twitter Discovery Config:", {
+    logger7.info("Twitter Discovery Config:", {
       topics: this.config.topics,
       isDryRun: this.isDryRun,
       minFollowerCount: this.config.minFollowerCount,
@@ -7640,7 +7795,7 @@ var TwitterDiscoveryClient = class {
         topics = this.extractTopicsFromBio(character.bio);
       }
     } else {
-      logger6.warn(
+      logger7.warn(
         "Character not available in runtime, using default topics for discovery"
       );
     }
@@ -7656,14 +7811,15 @@ var TwitterDiscoveryClient = class {
         getSetting(
           this.runtime,
           "TWITTER_MAX_ENGAGEMENTS_PER_RUN"
-        ) || process.env.TWITTER_MAX_ENGAGEMENTS_PER_RUN || "10"
+        ) || process.env.TWITTER_MAX_ENGAGEMENTS_PER_RUN || "5"
+        // Reduced from 10 to 5
       ),
-      likeThreshold: 0.3,
-      // Lowered from 0.6
-      replyThreshold: 0.5,
-      // Lowered from 0.8
-      quoteThreshold: 0.7
-      // Lowered from 0.85
+      likeThreshold: 0.5,
+      // Increased from 0.3 (be more selective)
+      replyThreshold: 0.7,
+      // Increased from 0.5 (be more selective)
+      quoteThreshold: 0.85
+      // Increased from 0.7 (be more selective)
     };
   }
   extractTopicsFromBio(bio) {
@@ -7684,46 +7840,41 @@ var TwitterDiscoveryClient = class {
     return [...new Set(words)].slice(0, 5);
   }
   async start() {
-    logger6.info("Starting Twitter Discovery Client...");
+    logger7.info("Starting Twitter Discovery Client...");
     this.isRunning = true;
     const discoveryLoop = async () => {
       if (!this.isRunning) {
-        logger6.info("Discovery client stopped, exiting loop");
+        logger7.info("Discovery client stopped, exiting loop");
         return;
       }
       try {
         await this.runDiscoveryCycle();
       } catch (error) {
-        logger6.error("Discovery cycle error:", error);
+        logger7.error("Discovery cycle error:", error);
       }
-      const baseInterval = parseInt(
-        getSetting(this.runtime, "TWITTER_DISCOVERY_INTERVAL") || process.env.TWITTER_DISCOVERY_INTERVAL || "30"
-      );
-      const variance = Math.random() * 20 - 10;
-      const nextInterval = (baseInterval + variance) * 60 * 1e3;
-      logger6.info(
-        `Next discovery cycle in ${(baseInterval + variance).toFixed(1)} minutes`
+      const discoveryIntervalMinutes = getRandomInterval(this.runtime, "discovery");
+      const nextInterval = discoveryIntervalMinutes * 60 * 1e3;
+      logger7.log(
+        `Next discovery cycle in ${discoveryIntervalMinutes.toFixed(1)} minutes`
       );
-      if (this.isRunning) {
-        setTimeout(discoveryLoop, nextInterval);
-      }
+      setTimeout(discoveryLoop, nextInterval);
     };
     setTimeout(discoveryLoop, 5e3);
   }
   async stop() {
-    logger6.info("Stopping Twitter Discovery Client...");
+    logger7.info("Stopping Twitter Discovery Client...");
     this.isRunning = false;
   }
   async runDiscoveryCycle() {
-    logger6.info("Starting Twitter discovery cycle...");
+    logger7.info("Starting Twitter discovery cycle...");
     const discoveries = await this.discoverContent();
     const { tweets, accounts } = discoveries;
-    logger6.info(
+    logger7.info(
       `Discovered ${tweets.length} tweets and ${accounts.length} accounts`
     );
     const followedCount = await this.processAccounts(accounts);
     const engagementCount = await this.processTweets(tweets);
-    logger6.info(
+    logger7.info(
       `Discovery cycle complete: ${followedCount} follows, ${engagementCount} engagements`
     );
   }
@@ -7735,7 +7886,7 @@ var TwitterDiscoveryClient = class {
       allTweets.push(...topicContent.tweets);
       topicContent.accounts.forEach((acc) => allAccounts.set(acc.user.id, acc));
     } catch (error) {
-      logger6.error("Failed to discover from topics:", error);
+      logger7.error("Failed to discover from topics:", error);
     }
     try {
       const threadContent = await this.discoverFromThreads();
@@ -7744,7 +7895,7 @@ var TwitterDiscoveryClient = class {
         (acc) => allAccounts.set(acc.user.id, acc)
       );
     } catch (error) {
-      logger6.error("Failed to discover from threads:", error);
+      logger7.error("Failed to discover from threads:", error);
     }
     try {
       const popularContent = await this.discoverFromPopularAccounts();
@@ -7753,7 +7904,7 @@ var TwitterDiscoveryClient = class {
         (acc) => allAccounts.set(acc.user.id, acc)
       );
     } catch (error) {
-      logger6.error("Failed to discover from popular accounts:", error);
+      logger7.error("Failed to discover from popular accounts:", error);
     }
     const sortedTweets = allTweets.sort((a, b) => b.relevanceScore - a.relevanceScore).slice(0, 50);
     const sortedAccounts = Array.from(allAccounts.values()).sort(
@@ -7762,14 +7913,14 @@ var TwitterDiscoveryClient = class {
     return { tweets: sortedTweets, accounts: sortedAccounts };
   }
   async discoverFromTopics() {
-    logger6.debug("Discovering from character topics...");
+    logger7.debug("Discovering from character topics...");
     const tweets = [];
     const accounts = /* @__PURE__ */ new Map();
     for (const topic of this.config.topics.slice(0, 5)) {
       try {
         const searchTopic = this.sanitizeTopic(topic);
         const popularQuery = `${searchTopic} -is:retweet -is:reply lang:en`;
-        logger6.debug(`Searching popular tweets for topic: ${topic}`);
+        logger7.debug(`Searching popular tweets for topic: ${topic}`);
         const popularResults = await this.twitterClient.fetchSearchTweets(
           popularQuery,
           20,
@@ -7779,44 +7930,66 @@ var TwitterDiscoveryClient = class {
           if ((tweet.likes || 0) < 10) continue;
           const scored = this.scoreTweet(tweet, "topic");
           tweets.push(scored);
+          const authorUsername = tweet.username;
+          const authorName = tweet.name || tweet.username;
+          const estimatedFollowers = Math.max(
+            1e3,
+            // minimum estimate
+            (tweet.likes || 0) * 100
+            // rough estimate: 100 followers per like
+          );
+          const account = this.scoreAccount({
+            id: tweet.userId,
+            username: authorUsername,
+            name: authorName,
+            followersCount: estimatedFollowers
+          });
+          if (account.qualityScore > 0.3) {
+            accounts.set(tweet.userId, account);
+          }
         }
-        const verifiedQuery = `${searchTopic} -is:retweet lang:en is:verified`;
-        logger6.debug(`Searching verified accounts for topic: ${topic}`);
-        const verifiedResults = await this.twitterClient.fetchSearchTweets(
-          verifiedQuery,
-          10,
+        const engagedQuery = `${searchTopic} -is:retweet lang:en`;
+        logger7.debug(`Searching engaged tweets for topic: ${topic}`);
+        const engagedResults = await this.twitterClient.fetchSearchTweets(
+          engagedQuery,
+          15,
           1 /* Latest */
         );
-        for (const tweet of verifiedResults.tweets) {
+        for (const tweet of engagedResults.tweets) {
+          if ((tweet.likes || 0) < 5) continue;
           const scored = this.scoreTweet(tweet, "topic");
           tweets.push(scored);
           const authorUsername = tweet.username;
           const authorName = tweet.name || tweet.username;
+          const estimatedFollowers = Math.max(
+            500,
+            // minimum for engaged tweets
+            (tweet.likes || 0) * 50
+          );
           const account = this.scoreAccount({
             id: tweet.userId,
             username: authorUsername,
             name: authorName,
-            followersCount: 1e3
-            // Default estimate for verified accounts
+            followersCount: estimatedFollowers
           });
-          if (account.qualityScore > 0.5) {
+          if (account.qualityScore > 0.2) {
             accounts.set(tweet.userId, account);
           }
         }
       } catch (error) {
-        logger6.error(`Failed to search topic ${topic}:`, error);
+        logger7.error(`Failed to search topic ${topic}:`, error);
       }
     }
     return { tweets, accounts: Array.from(accounts.values()) };
   }
   async discoverFromThreads() {
-    logger6.debug("Discovering from conversation threads...");
+    logger7.debug("Discovering from conversation threads...");
     const tweets = [];
     const accounts = /* @__PURE__ */ new Map();
     const topicQuery = this.config.topics.slice(0, 3).map((t) => this.sanitizeTopic(t)).join(" OR ");
     try {
       const viralQuery = `(${topicQuery}) -is:retweet has:mentions`;
-      logger6.debug(`Searching viral threads with query: ${viralQuery}`);
+      logger7.debug(`Searching viral threads with query: ${viralQuery}`);
       const searchResults = await this.twitterClient.fetchSearchTweets(
         viralQuery,
         15,
@@ -7839,19 +8012,19 @@ var TwitterDiscoveryClient = class {
         }
       }
     } catch (error) {
-      logger6.error("Failed to discover threads:", error);
+      logger7.error("Failed to discover threads:", error);
     }
     return { tweets, accounts: Array.from(accounts.values()) };
   }
   async discoverFromPopularAccounts() {
-    logger6.debug("Discovering from popular accounts in topics...");
+    logger7.debug("Discovering from popular accounts in topics...");
     const tweets = [];
     const accounts = /* @__PURE__ */ new Map();
     for (const topic of this.config.topics.slice(0, 3)) {
       try {
         const searchTopic = this.sanitizeTopic(topic);
         const influencerQuery = `${searchTopic} -is:retweet lang:en`;
-        logger6.debug(`Searching for influencers in topic: ${topic}`);
+        logger7.debug(`Searching for influencers in topic: ${topic}`);
         const results = await this.twitterClient.fetchSearchTweets(
           influencerQuery,
           10,
@@ -7878,7 +8051,7 @@ var TwitterDiscoveryClient = class {
           }
         }
       } catch (error) {
-        logger6.error(
+        logger7.error(
           `Failed to discover popular accounts for ${topic}:`,
           error
         );
@@ -7942,18 +8115,35 @@ var TwitterDiscoveryClient = class {
   }
   async processAccounts(accounts) {
     let followedCount = 0;
-    for (const scoredAccount of accounts) {
+    const sortedAccounts = accounts.sort((a, b) => {
+      const scoreA = a.qualityScore + a.relevanceScore;
+      const scoreB = b.qualityScore + b.relevanceScore;
+      return scoreB - scoreA;
+    });
+    for (const scoredAccount of sortedAccounts) {
       if (followedCount >= this.config.maxFollowsPerCycle) break;
+      if (scoredAccount.user.followersCount < this.config.minFollowerCount) {
+        logger7.debug(
+          `Skipping @${scoredAccount.user.username} - below minimum follower count (${scoredAccount.user.followersCount} < ${this.config.minFollowerCount})`
+        );
+        continue;
+      }
+      if (scoredAccount.qualityScore < 0.2) {
+        logger7.debug(
+          `Skipping @${scoredAccount.user.username} - quality score too low (${scoredAccount.qualityScore.toFixed(2)})`
+        );
+        continue;
+      }
       try {
         const isFollowing = await this.checkIfFollowing(scoredAccount.user.id);
         if (isFollowing) continue;
         if (this.isDryRun) {
-          logger6.info(
+          logger7.info(
             `[DRY RUN] Would follow @${scoredAccount.user.username} (quality: ${scoredAccount.qualityScore.toFixed(2)}, relevance: ${scoredAccount.relevanceScore.toFixed(2)})`
           );
         } else {
           await this.twitterClient.followUser(scoredAccount.user.id);
-          logger6.info(
+          logger7.info(
             `Followed @${scoredAccount.user.username} (quality: ${scoredAccount.qualityScore.toFixed(2)}, relevance: ${scoredAccount.relevanceScore.toFixed(2)})`
           );
           await this.saveFollowMemory(scoredAccount.user);
@@ -7961,7 +8151,7 @@ var TwitterDiscoveryClient = class {
         followedCount++;
         await this.delay(2e3 + Math.random() * 3e3);
       } catch (error) {
-        logger6.error(
+        logger7.error(
           `Failed to follow @${scoredAccount.user.username}:`,
           error
         );
@@ -7981,7 +8171,7 @@ var TwitterDiscoveryClient = class {
         );
         const existingMemory = await this.runtime.getMemoryById(tweetMemoryId);
         if (existingMemory) {
-          logger6.debug(
+          logger7.debug(
             `Already engaged with tweet ${scoredTweet.tweet.id}, skipping`
           );
           continue;
@@ -7989,12 +8179,12 @@ var TwitterDiscoveryClient = class {
         switch (scoredTweet.engagementType) {
           case "like":
             if (this.isDryRun) {
-              logger6.info(
+              logger7.info(
                 `[DRY RUN] Would like tweet: ${scoredTweet.tweet.id} (score: ${scoredTweet.relevanceScore.toFixed(2)})`
               );
             } else {
               await this.twitterClient.likeTweet(scoredTweet.tweet.id);
-              logger6.info(
+              logger7.info(
                 `Liked tweet: ${scoredTweet.tweet.id} (score: ${scoredTweet.relevanceScore.toFixed(2)})`
               );
             }
@@ -8002,7 +8192,7 @@ var TwitterDiscoveryClient = class {
           case "reply":
             const replyText = await this.generateReply(scoredTweet.tweet);
             if (this.isDryRun) {
-              logger6.info(
+              logger7.info(
                 `[DRY RUN] Would reply to tweet ${scoredTweet.tweet.id} with: "${replyText}"`
               );
             } else {
@@ -8010,13 +8200,13 @@ var TwitterDiscoveryClient = class {
                 replyText,
                 scoredTweet.tweet.id
               );
-              logger6.info(`Replied to tweet: ${scoredTweet.tweet.id}`);
+              logger7.info(`Replied to tweet: ${scoredTweet.tweet.id}`);
             }
             break;
           case "quote":
             const quoteText = await this.generateQuote(scoredTweet.tweet);
             if (this.isDryRun) {
-              logger6.info(
+              logger7.info(
                 `[DRY RUN] Would quote tweet ${scoredTweet.tweet.id} with: "${quoteText}"`
               );
             } else {
@@ -8024,7 +8214,7 @@ var TwitterDiscoveryClient = class {
                 quoteText,
                 scoredTweet.tweet.id
               );
-              logger6.info(`Quoted tweet: ${scoredTweet.tweet.id}`);
+              logger7.info(`Quoted tweet: ${scoredTweet.tweet.id}`);
             }
             break;
         }
@@ -8035,7 +8225,7 @@ var TwitterDiscoveryClient = class {
         engagementCount++;
         await this.delay(3e3 + Math.random() * 5e3);
       } catch (error) {
-        logger6.error(
+        logger7.error(
           `Failed to engage with tweet ${scoredTweet.tweet.id}:`,
           error
         );
@@ -8120,43 +8310,12 @@ Quote tweet:`;
     return response.trim();
   }
   async saveEngagementMemory(tweet, engagementType) {
-    const memoryId = await this.runtime.createMemory(
-      {
-        id: createUniqueUuid5(this.runtime, tweet.id),
-        entityId: createUniqueUuid5(this.runtime, tweet.userId),
-        content: {
-          text: `${engagementType} tweet from @${tweet.username}: ${tweet.text}`,
-          metadata: {
-            tweetId: tweet.id,
-            engagementType,
-            source: "discovery",
-            isDryRun: this.isDryRun
-          }
-        },
-        roomId: createUniqueUuid5(this.runtime, tweet.conversationId)
-      },
-      "messages"
-    );
+    logger7.debug(`[Discovery] Would save engagement memory for ${engagementType} on tweet ${tweet.id}`);
+    return;
   }
   async saveFollowMemory(user) {
-    const memoryId = await this.runtime.createMemory(
-      {
-        entityId: createUniqueUuid5(this.runtime, user.id),
-        content: {
-          text: `followed twitter user ${user.id} @${user.username}`,
-          metadata: {
-            userId: user.id,
-            username: user.username,
-            name: user.name,
-            followersCount: user.followersCount,
-            source: "discovery",
-            isDryRun: this.isDryRun
-          }
-        },
-        roomId: createUniqueUuid5(this.runtime, `twitter-follows`)
-      },
-      "messages"
-    );
+    logger7.debug(`[Discovery] Would save follow memory for @${user.username}`);
+    return;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -8167,7 +8326,7 @@ Quote tweet:`;
 import {
   ChannelType as ChannelType4,
   createUniqueUuid as createUniqueUuid6,
-  logger as logger7
+  logger as logger8
 } from "@elizaos/core";
 var RequestQueue = class {
   constructor() {
@@ -8212,7 +8371,7 @@ var RequestQueue = class {
         await request();
         this.retryAttempts.delete(request);
       } catch (error) {
-        logger7.error("Error processing request:", error);
+        logger8.error("Error processing request:", error);
         const retryCount = (this.retryAttempts.get(request) || 0) + 1;
         if (retryCount < this.maxRetries) {
           this.retryAttempts.set(request, retryCount);
@@ -8220,7 +8379,7 @@ var RequestQueue = class {
           await this.exponentialBackoff(retryCount);
           break;
         } else {
-          logger7.error(
+          logger8.error(
             `Max retries (${this.maxRetries}) exceeded for request, skipping`
           );
           this.retryAttempts.delete(request);
@@ -8278,7 +8437,7 @@ var _ClientBase = class _ClientBase {
    */
   async cacheTweet(tweet) {
     if (!tweet) {
-      logger7.warn("Tweet is undefined, skipping cache");
+      logger8.warn("Tweet is undefined, skipping cache");
       return;
     }
     this.runtime.setCache(`twitter/tweets/${tweet.id}`, tweet);
@@ -8343,7 +8502,7 @@ var _ClientBase = class _ClientBase {
     let lastError = null;
     while (retryCount < maxRetries) {
       try {
-        logger7.log("Initializing Twitter API v2 client");
+        logger8.log("Initializing Twitter API v2 client");
         await this.twitterClient.login(
           "",
           // username not needed for API v2
@@ -8359,18 +8518,18 @@ var _ClientBase = class _ClientBase {
           accessTokenSecret
         );
         if (await this.twitterClient.isLoggedIn()) {
-          logger7.info("Successfully authenticated with Twitter API v2");
+          logger8.info("Successfully authenticated with Twitter API v2");
           break;
         }
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
-        logger7.error(
+        logger8.error(
           `Authentication attempt ${retryCount + 1} failed: ${lastError.message}`
         );
         retryCount++;
         if (retryCount < maxRetries) {
           const delay = 2 ** retryCount * 1e3;
-          logger7.info(`Retrying in ${delay / 1e3} seconds...`);
+          logger8.info(`Retrying in ${delay / 1e3} seconds...`);
           await new Promise((resolve) => setTimeout(resolve, delay));
         }
       }
@@ -8382,13 +8541,13 @@ var _ClientBase = class _ClientBase {
     }
     const profile = await this.twitterClient.me();
     if (profile) {
-      logger7.log("Twitter user ID:", profile.userId);
-      logger7.log("Twitter loaded:", JSON.stringify(profile, null, 10));
+      logger8.log("Twitter user ID:", profile.userId);
+      logger8.log("Twitter loaded:", JSON.stringify(profile, null, 10));
       const agentId = this.runtime.agentId;
       const entity = await this.runtime.getEntityById(agentId);
       const entityMetadata = entity?.metadata;
       if (entityMetadata?.twitter?.userName !== profile.username) {
-        logger7.log(
+        logger8.log(
           "Updating Agents known X/twitter handle",
           profile.username,
           "was",
@@ -8427,7 +8586,7 @@ var _ClientBase = class _ClientBase {
     await this.populateTimeline();
   }
   async fetchOwnPosts(count) {
-    logger7.debug("fetching own posts");
+    logger8.debug("fetching own posts");
     const homeTimeline = await this.twitterClient.getUserTweets(
       this.profile.id,
       count
@@ -8438,7 +8597,7 @@ var _ClientBase = class _ClientBase {
    * Fetch timeline for twitter account, optionally only from followed accounts
    */
   async fetchHomeTimeline(count, following) {
-    logger7.debug("fetching home timeline");
+    logger8.debug("fetching home timeline");
     const homeTimeline = following ? await this.twitterClient.fetchFollowingTimeline(count, []) : await this.twitterClient.fetchHomeTimeline(count, []);
     return homeTimeline;
   }
@@ -8461,16 +8620,16 @@ var _ClientBase = class _ClientBase {
         );
         return result ?? { tweets: [] };
       } catch (error) {
-        logger7.error("Error fetching search tweets:", error);
+        logger8.error("Error fetching search tweets:", error);
         return { tweets: [] };
       }
     } catch (error) {
-      logger7.error("Error fetching search tweets:", error);
+      logger8.error("Error fetching search tweets:", error);
       return { tweets: [] };
     }
   }
   async populateTimeline() {
-    logger7.debug("populating timeline...");
+    logger8.debug("populating timeline...");
     const cachedTimeline = await this.getCachedTimeline();
     if (cachedTimeline) {
       const existingMemories2 = await this.runtime.getMemoriesByRoomIds({
@@ -8490,7 +8649,7 @@ var _ClientBase = class _ClientBase {
           (tweet) => tweet.userId !== this.profile.id && !existingMemoryIds2.has(createUniqueUuid6(this.runtime, tweet.id))
         );
         for (const tweet of tweetsToSave2) {
-          logger7.log("Saving Tweet", tweet.id);
+          logger8.log("Saving Tweet", tweet.id);
           if (tweet.userId === this.profile.id) {
             continue;
           }
@@ -8538,7 +8697,7 @@ var _ClientBase = class _ClientBase {
           );
           await this.cacheTweet(tweet);
         }
-        logger7.log(
+        logger8.log(
           `Populated ${tweetsToSave2.length} missing tweets from the cache.`
         );
         return;
@@ -8567,11 +8726,11 @@ var _ClientBase = class _ClientBase {
     const tweetsToSave = allTweets.filter(
       (tweet) => tweet.userId !== this.profile.id && !existingMemoryIds.has(createUniqueUuid6(this.runtime, tweet.id))
     );
-    logger7.debug({
+    logger8.debug({
       processingTweets: tweetsToSave.map((tweet) => tweet.id).join(",")
     });
     for (const tweet of tweetsToSave) {
-      logger7.log("Saving Tweet", tweet.id);
+      logger8.log("Saving Tweet", tweet.id);
       if (tweet.userId === this.profile.id) {
         continue;
       }
@@ -8631,7 +8790,7 @@ var _ClientBase = class _ClientBase {
         unique: false
       });
       if (recentMessage.length > 0 && recentMessage[0].content === message.content) {
-        logger7.debug("Message already saved", recentMessage[0].id);
+        logger8.debug("Message already saved", recentMessage[0].id);
       } else {
         await this.runtime.createMemory(message, "messages");
       }
@@ -8704,7 +8863,7 @@ var _ClientBase = class _ClientBase {
       });
       return profile;
     } catch (error) {
-      logger7.error("Error fetching Twitter profile:", error);
+      logger8.error("Error fetching Twitter profile:", error);
       throw error;
     }
   }
@@ -8725,7 +8884,7 @@ var _ClientBase = class _ClientBase {
         (tweet) => this.formatTweetToInteraction(tweet)
       );
     } catch (error) {
-      logger7.error("Error fetching Twitter interactions:", error);
+      logger8.error("Error fetching Twitter interactions:", error);
       return [];
     }
   }
@@ -8755,42 +8914,42 @@ var TwitterClientInstance = class {
   constructor(runtime, state) {
     this.client = new ClientBase(runtime, state);
     const postEnabledSetting = getSetting(runtime, "TWITTER_ENABLE_POST") ?? process.env.TWITTER_ENABLE_POST;
-    logger8.debug(
+    logger9.debug(
       `TWITTER_ENABLE_POST setting value: ${JSON.stringify(postEnabledSetting)}, type: ${typeof postEnabledSetting}`
     );
     const postEnabled = postEnabledSetting === "true" || postEnabledSetting === true;
     if (postEnabled) {
-      logger8.info("Twitter posting is ENABLED - creating post client");
+      logger9.info("Twitter posting is ENABLED - creating post client");
       this.post = new TwitterPostClient(this.client, runtime, state);
     } else {
-      logger8.info(
+      logger9.info(
         "Twitter posting is DISABLED - set TWITTER_ENABLE_POST=true to enable automatic posting"
       );
     }
     const repliesEnabled = (getSetting(runtime, "TWITTER_ENABLE_REPLIES") ?? process.env.TWITTER_ENABLE_REPLIES) !== "false";
     if (repliesEnabled) {
-      logger8.info("Twitter replies/interactions are ENABLED");
+      logger9.info("Twitter replies/interactions are ENABLED");
       this.interaction = new TwitterInteractionClient(
         this.client,
         runtime,
         state
       );
     } else {
-      logger8.info("Twitter replies/interactions are DISABLED");
+      logger9.info("Twitter replies/interactions are DISABLED");
     }
     const actionsEnabled = (getSetting(runtime, "TWITTER_ENABLE_ACTIONS") ?? process.env.TWITTER_ENABLE_ACTIONS) === "true";
     if (actionsEnabled) {
-      logger8.info("Twitter timeline actions are ENABLED");
+      logger9.info("Twitter timeline actions are ENABLED");
       this.timeline = new TwitterTimelineClient(this.client, runtime, state);
     } else {
-      logger8.info("Twitter timeline actions are DISABLED");
+      logger9.info("Twitter timeline actions are DISABLED");
     }
     const discoveryEnabled = (getSetting(runtime, "TWITTER_ENABLE_DISCOVERY") ?? process.env.TWITTER_ENABLE_DISCOVERY) === "true" || actionsEnabled && (getSetting(runtime, "TWITTER_ENABLE_DISCOVERY") ?? process.env.TWITTER_ENABLE_DISCOVERY) !== "false";
     if (discoveryEnabled) {
-      logger8.info("Twitter discovery service is ENABLED");
+      logger9.info("Twitter discovery service is ENABLED");
       this.discovery = new TwitterDiscoveryClient(this.client, runtime, state);
     } else {
-      logger8.info(
+      logger9.info(
         "Twitter discovery service is DISABLED - set TWITTER_ENABLE_DISCOVERY=true to enable"
       );
     }
@@ -8807,28 +8966,28 @@ var _TwitterService = class _TwitterService extends Service {
     service.runtime = runtime;
     try {
       await validateTwitterConfig(runtime);
-      logger8.log("\u2705 Twitter configuration validated successfully");
+      logger9.log("\u2705 Twitter configuration validated successfully");
       service.twitterClient = new TwitterClientInstance(runtime, {});
       await service.twitterClient.client.init();
       if (service.twitterClient.post) {
-        logger8.log("\u{1F4EE} Starting Twitter post client...");
+        logger9.log("\u{1F4EE} Starting Twitter post client...");
         await service.twitterClient.post.start();
       }
       if (service.twitterClient.interaction) {
-        logger8.log("\u{1F4AC} Starting Twitter interaction client...");
+        logger9.log("\u{1F4AC} Starting Twitter interaction client...");
         await service.twitterClient.interaction.start();
       }
       if (service.twitterClient.timeline) {
-        logger8.log("\u{1F4CA} Starting Twitter timeline client...");
+        logger9.log("\u{1F4CA} Starting Twitter timeline client...");
         await service.twitterClient.timeline.start();
       }
       if (service.twitterClient.discovery) {
-        logger8.log("\u{1F50D} Starting Twitter discovery client...");
+        logger9.log("\u{1F50D} Starting Twitter discovery client...");
         await service.twitterClient.discovery.start();
       }
-      logger8.log("\u2705 Twitter service started successfully");
+      logger9.log("\u2705 Twitter service started successfully");
     } catch (error) {
-      logger8.error("\u{1F6A8} Failed to start Twitter service:", error);
+      logger9.error("\u{1F6A8} Failed to start Twitter service:", error);
       throw error;
     }
     return service;
@@ -8846,7 +9005,7 @@ var _TwitterService = class _TwitterService extends Service {
     if (this.twitterClient?.discovery) {
       await this.twitterClient.discovery.stop();
     }
-    logger8.log("Twitter service stopped");
+    logger9.log("Twitter service stopped");
   }
 };
 _TwitterService.serviceType = "twitter";
@@ -8854,7 +9013,7 @@ var TwitterService = _TwitterService;
 
 // src/actions/postTweet.ts
 import {
-  logger as logger9,
+  logger as logger10,
   ModelType as ModelType5
 } from "@elizaos/core";
 var postTweetAction = {
@@ -8867,8 +9026,8 @@ var postTweetAction = {
     "SHARE_ON_TWITTER"
   ],
   validate: async (runtime, message) => {
-    logger9.debug("Validating POST_TWEET action");
-    logger9.debug("Message details:", {
+    logger10.debug("Validating POST_TWEET action");
+    logger10.debug("Message details:", {
       hasContent: !!message.content,
       contentType: message.content?.type,
       hasText: !!message.content?.text,
@@ -8877,20 +9036,24 @@ var postTweetAction = {
       roomId: message.roomId,
       entityId: message.entityId
     });
+    if (message.content?.type === "post" && !message.content?.text) {
+      logger10.debug("Skipping validation for provider context (empty post type)");
+      return false;
+    }
     const text = message.content?.text?.trim();
     if (!text || text.length === 0) {
-      logger9.error("No text content for tweet");
-      logger9.debug("Stack trace:", new Error().stack);
+      logger10.error("No text content for tweet");
+      logger10.debug("Stack trace:", new Error().stack);
       return false;
     }
     if (text.length > 280) {
-      logger9.warn(`Tweet too long: ${text.length} characters`);
+      logger10.warn(`Tweet too long: ${text.length} characters`);
     }
     return true;
   },
   description: "Post a tweet on Twitter",
   handler: async (runtime, message, state, _options, callback) => {
-    logger9.info("Executing POST_TWEET action");
+    logger10.info("Executing POST_TWEET action");
     try {
       const client = new ClientBase(runtime, {});
       if (!client.twitterClient) {
@@ -8898,7 +9061,7 @@ var postTweetAction = {
       }
       let text = message.content?.text?.trim();
       if (!text) {
-        logger9.error("No text content for tweet");
+        logger10.error("No text content for tweet");
         if (callback) {
           callback({
             text: "I need something to tweet! Please provide the text.",
@@ -8908,7 +9071,7 @@ var postTweetAction = {
         return;
       }
       if (text.length > 280) {
-        logger9.info(`Truncating tweet from ${text.length} to 280 characters`);
+        logger10.info(`Truncating tweet from ${text.length} to 280 characters`);
         const sentences = text.match(/[^.!?]+[.!?]+/g) || [text];
         let truncated = "";
         for (const sentence of sentences) {
@@ -8919,7 +9082,7 @@ var postTweetAction = {
           }
         }
         text = truncated.trim() || text.substring(0, 277) + "...";
-        logger9.info(`Truncated tweet: ${text}`);
+        logger10.info(`Truncated tweet: ${text}`);
       }
       if (!client.profile) {
         throw new Error(
@@ -8975,7 +9138,7 @@ Tweet:`;
           tweetId = Date.now().toString();
         }
         const tweetUrl = `https://twitter.com/${client.profile.username}/status/${tweetId}`;
-        logger9.info(`Successfully posted tweet: ${tweetId}`);
+        logger10.info(`Successfully posted tweet: ${tweetId}`);
         await runtime.createMemory(
           {
             entityId: runtime.agentId,
@@ -9005,7 +9168,7 @@ View it here: ${tweetUrl}`,
         throw new Error("Failed to post tweet - no response data");
       }
     } catch (error) {
-      logger9.error("Error posting tweet:", error);
+      logger10.error("Error posting tweet:", error);
       if (callback) {
         await callback({
           text: `Sorry, I couldn't post the tweet. Error: ${error.message}`,
@@ -9071,7 +9234,7 @@ var TwitterPlugin = {
   actions: [postTweetAction],
   services: [TwitterService],
   init: async (_config, runtime) => {
-    logger10.log("\u{1F527} Initializing Twitter plugin...");
+    logger11.log("\u{1F527} Initializing Twitter plugin...");
     const hasGetSetting = runtime && typeof runtime.getSetting === "function";
     const apiKey = hasGetSetting ? runtime.getSetting("TWITTER_API_KEY") : process.env.TWITTER_API_KEY;
     const apiSecretKey = hasGetSetting ? runtime.getSetting("TWITTER_API_SECRET_KEY") : process.env.TWITTER_API_SECRET_KEY;
@@ -9083,14 +9246,14 @@ var TwitterPlugin = {
       if (!apiSecretKey) missing.push("TWITTER_API_SECRET_KEY");
       if (!accessToken) missing.push("TWITTER_ACCESS_TOKEN");
       if (!accessTokenSecret) missing.push("TWITTER_ACCESS_TOKEN_SECRET");
-      logger10.warn(
+      logger11.warn(
         `Twitter API credentials not configured - Twitter functionality will be limited. Missing: ${missing.join(", ")}`
       );
-      logger10.warn(
+      logger11.warn(
         "To enable Twitter functionality, please provide the missing credentials in your .env file"
       );
     } else {
-      logger10.log("\u2705 Twitter credentials found");
+      logger11.log("\u2705 Twitter credentials found");
     }
   }
 };