@elizaos/plugin-twitter 1.2.10 → 1.2.12

package/dist/index.js

@@ -452,7 +452,10 @@ async function followUser(username, auth) {
     if (!meResponse.data) {
       throw new Error("Failed to get authenticated user");
     }
-    const result = await client.v2.follow(meResponse.data.id, userResponse.data.id);
+    const result = await client.v2.follow(
+      meResponse.data.id,
+      userResponse.data.id
+    );
     return new Response(JSON.stringify(result), {
       status: result.data?.following ? 200 : 400,
       headers: new Headers({ "Content-Type": "application/json" })
@@ -748,7 +751,9 @@ async function fetchTweetsAndReplies(userId, maxTweets, cursor, auth) {
       next: response.meta.next_token
     };
   } catch (error) {
-    throw new Error(`Failed to fetch tweets and replies: ${error?.message || error}`);
+    throw new Error(
+      `Failed to fetch tweets and replies: ${error?.message || error}`
+    );
   }
 }
 async function createCreateTweetRequestV2(text, auth, tweetId, options) {
@@ -822,9 +827,15 @@ function parseTweetV2ToV1(tweetV2, includes) {
     isReply: tweetV2.referenced_tweets?.some((ref) => ref.type === "replied_to") ?? false,
     isRetweet: tweetV2.referenced_tweets?.some((ref) => ref.type === "retweeted") ?? false,
     isQuoted: tweetV2.referenced_tweets?.some((ref) => ref.type === "quoted") ?? false,
-    inReplyToStatusId: tweetV2.referenced_tweets?.find((ref) => ref.type === "replied_to")?.id,
-    quotedStatusId: tweetV2.referenced_tweets?.find((ref) => ref.type === "quoted")?.id,
-    retweetedStatusId: tweetV2.referenced_tweets?.find((ref) => ref.type === "retweeted")?.id
+    inReplyToStatusId: tweetV2.referenced_tweets?.find(
+      (ref) => ref.type === "replied_to"
+    )?.id,
+    quotedStatusId: tweetV2.referenced_tweets?.find(
+      (ref) => ref.type === "quoted"
+    )?.id,
+    retweetedStatusId: tweetV2.referenced_tweets?.find(
+      (ref) => ref.type === "retweeted"
+    )?.id
   };
   if (includes?.polls?.length) {
     const poll = includes.polls[0];
@@ -976,7 +987,12 @@ async function* getTweets(user, maxTweets, auth) {
   let cursor;
   let totalFetched = 0;
   while (totalFetched < maxTweets) {
-    const response = await fetchTweets(userId, maxTweets - totalFetched, cursor, auth);
+    const response = await fetchTweets(
+      userId,
+      maxTweets - totalFetched,
+      cursor,
+      auth
+    );
     for (const tweet of response.tweets) {
       yield tweet;
       totalFetched++;
@@ -990,7 +1006,12 @@ async function* getTweetsByUserId(userId, maxTweets, auth) {
   let cursor;
   let totalFetched = 0;
   while (totalFetched < maxTweets) {
-    const response = await fetchTweets(userId, maxTweets - totalFetched, cursor, auth);
+    const response = await fetchTweets(
+      userId,
+      maxTweets - totalFetched,
+      cursor,
+      auth
+    );
     for (const tweet of response.tweets) {
       yield tweet;
       totalFetched++;
@@ -1009,7 +1030,12 @@ async function* getTweetsAndReplies(user, maxTweets, auth) {
   let cursor;
   let totalFetched = 0;
   while (totalFetched < maxTweets) {
-    const response = await fetchTweetsAndReplies(userId, maxTweets - totalFetched, cursor, auth);
+    const response = await fetchTweetsAndReplies(
+      userId,
+      maxTweets - totalFetched,
+      cursor,
+      auth
+    );
     for (const tweet of response.tweets) {
       yield tweet;
       totalFetched++;
@@ -1023,7 +1049,12 @@ async function* getTweetsAndRepliesByUserId(userId, maxTweets, auth) {
   let cursor;
   let totalFetched = 0;
   while (totalFetched < maxTweets) {
-    const response = await fetchTweetsAndReplies(userId, maxTweets - totalFetched, cursor, auth);
+    const response = await fetchTweetsAndReplies(
+      userId,
+      maxTweets - totalFetched,
+      cursor,
+      auth
+    );
     for (const tweet of response.tweets) {
       yield tweet;
       totalFetched++;
@@ -1115,10 +1146,7 @@ async function getTweetV2(id, auth, options = defaultOptions) {
       console.warn(`Tweet data not found for ID: ${id}`);
       return null;
     }
-    const parsedTweet = parseTweetV2ToV1(
-      tweetData.data,
-      tweetData?.includes
-    );
+    const parsedTweet = parseTweetV2ToV1(tweetData.data, tweetData?.includes);
     return parsedTweet;
   } catch (error) {
     console.error(`Error fetching tweet ${id}:`, error);
@@ -1920,7 +1948,7 @@ import {
 } from "@elizaos/core";
 
 // src/constants.ts
-var TWEET_MAX_LENGTH = 4e3;
+var TWEET_MAX_LENGTH = 280;
 
 // src/utils/error-handler.ts
 import { logger } from "@elizaos/core";
@@ -6098,18 +6126,49 @@ async function validateTwitterConfig(runtime, config = {}) {
       TWITTER_API_SECRET_KEY: config.TWITTER_API_SECRET_KEY ?? getSetting(runtime, "TWITTER_API_SECRET_KEY") ?? "",
       TWITTER_ACCESS_TOKEN: config.TWITTER_ACCESS_TOKEN ?? getSetting(runtime, "TWITTER_ACCESS_TOKEN") ?? "",
       TWITTER_ACCESS_TOKEN_SECRET: config.TWITTER_ACCESS_TOKEN_SECRET ?? getSetting(runtime, "TWITTER_ACCESS_TOKEN_SECRET") ?? "",
-      TWITTER_DRY_RUN: String((config.TWITTER_DRY_RUN ?? getSetting(runtime, "TWITTER_DRY_RUN") ?? "false").toLowerCase() === "true"),
+      TWITTER_DRY_RUN: String(
+        (config.TWITTER_DRY_RUN ?? getSetting(runtime, "TWITTER_DRY_RUN") ?? "false").toLowerCase() === "true"
+      ),
       TWITTER_TARGET_USERS: config.TWITTER_TARGET_USERS ?? getSetting(runtime, "TWITTER_TARGET_USERS") ?? "",
-      TWITTER_ENABLE_POST: String((config.TWITTER_ENABLE_POST ?? getSetting(runtime, "TWITTER_ENABLE_POST") ?? "false").toLowerCase() === "true"),
+      TWITTER_ENABLE_POST: String(
+        (config.TWITTER_ENABLE_POST ?? getSetting(runtime, "TWITTER_ENABLE_POST") ?? "false").toLowerCase() === "true"
+      ),
       TWITTER_ENABLE_REPLIES: String(
         config.TWITTER_ENABLE_REPLIES !== void 0 ? config.TWITTER_ENABLE_REPLIES.toLowerCase() === "true" : (getSetting(runtime, "TWITTER_ENABLE_REPLIES") ?? "true").toLowerCase() === "true"
       ),
-      TWITTER_ENABLE_ACTIONS: String((config.TWITTER_ENABLE_ACTIONS ?? getSetting(runtime, "TWITTER_ENABLE_ACTIONS") ?? "false").toLowerCase() === "true"),
-      TWITTER_POST_INTERVAL: String(safeParseInt(config.TWITTER_POST_INTERVAL ?? getSetting(runtime, "TWITTER_POST_INTERVAL"), 120)),
-      TWITTER_ENGAGEMENT_INTERVAL: String(safeParseInt(config.TWITTER_ENGAGEMENT_INTERVAL ?? getSetting(runtime, "TWITTER_ENGAGEMENT_INTERVAL"), 30)),
-      TWITTER_MAX_ENGAGEMENTS_PER_RUN: String(safeParseInt(config.TWITTER_MAX_ENGAGEMENTS_PER_RUN ?? getSetting(runtime, "TWITTER_MAX_ENGAGEMENTS_PER_RUN"), 10)),
-      TWITTER_MAX_TWEET_LENGTH: String(safeParseInt(config.TWITTER_MAX_TWEET_LENGTH ?? getSetting(runtime, "TWITTER_MAX_TWEET_LENGTH"), 280)),
-      TWITTER_RETRY_LIMIT: String(safeParseInt(config.TWITTER_RETRY_LIMIT ?? getSetting(runtime, "TWITTER_RETRY_LIMIT"), 5))
+      TWITTER_ENABLE_ACTIONS: String(
+        (config.TWITTER_ENABLE_ACTIONS ?? getSetting(runtime, "TWITTER_ENABLE_ACTIONS") ?? "false").toLowerCase() === "true"
+      ),
+      TWITTER_POST_INTERVAL: String(
+        safeParseInt(
+          config.TWITTER_POST_INTERVAL ?? getSetting(runtime, "TWITTER_POST_INTERVAL"),
+          120
+        )
+      ),
+      TWITTER_ENGAGEMENT_INTERVAL: String(
+        safeParseInt(
+          config.TWITTER_ENGAGEMENT_INTERVAL ?? getSetting(runtime, "TWITTER_ENGAGEMENT_INTERVAL"),
+          30
+        )
+      ),
+      TWITTER_MAX_ENGAGEMENTS_PER_RUN: String(
+        safeParseInt(
+          config.TWITTER_MAX_ENGAGEMENTS_PER_RUN ?? getSetting(runtime, "TWITTER_MAX_ENGAGEMENTS_PER_RUN"),
+          10
+        )
+      ),
+      TWITTER_MAX_TWEET_LENGTH: String(
+        safeParseInt(
+          config.TWITTER_MAX_TWEET_LENGTH ?? getSetting(runtime, "TWITTER_MAX_TWEET_LENGTH"),
+          280
+        )
+      ),
+      TWITTER_RETRY_LIMIT: String(
+        safeParseInt(
+          config.TWITTER_RETRY_LIMIT ?? getSetting(runtime, "TWITTER_RETRY_LIMIT"),
+          5
+        )
+      )
     };
     if (!validatedConfig.TWITTER_API_KEY || !validatedConfig.TWITTER_API_SECRET_KEY || !validatedConfig.TWITTER_ACCESS_TOKEN || !validatedConfig.TWITTER_ACCESS_TOKEN_SECRET) {
       throw new Error(
@@ -6161,7 +6220,9 @@ var TwitterInteractionClient = class {
         this.state?.TWITTER_ENGAGEMENT_INTERVAL || getSetting(this.runtime, "TWITTER_ENGAGEMENT_INTERVAL") || process.env.TWITTER_ENGAGEMENT_INTERVAL || "30"
       );
       const interactionInterval = engagementIntervalMinutes * 60 * 1e3;
-      logger3.info(`Twitter interaction client will check every ${engagementIntervalMinutes} minutes`);
+      logger3.info(
+        `Twitter interaction client will check every ${engagementIntervalMinutes} minutes`
+      );
       this.handleTwitterInteractions();
       if (this.isRunning) {
         setTimeout(handleTwitterInteractionsLoop, interactionInterval);
@@ -6230,7 +6291,9 @@ var TwitterInteractionClient = class {
       if (targetUsers.length === 0 && !targetUsersConfig.includes("*")) {
         return;
       }
-      logger3.info(`Checking posts from target users: ${targetUsers.join(", ") || "everyone (*)"}`);
+      logger3.info(
+        `Checking posts from target users: ${targetUsers.join(", ") || "everyone (*)"}`
+      );
       for (const targetUser of targetUsers) {
         try {
           const normalizedUsername = targetUser.replace(/^@/, "");
@@ -6242,8 +6305,13 @@ var TwitterInteractionClient = class {
             1 /* Latest */
           );
           if (searchResult.tweets.length > 0) {
-            logger3.info(`Found ${searchResult.tweets.length} posts from @${normalizedUsername}`);
-            await this.processTargetUserTweets(searchResult.tweets, normalizedUsername);
+            logger3.info(
+              `Found ${searchResult.tweets.length} posts from @${normalizedUsername}`
+            );
+            await this.processTargetUserTweets(
+              searchResult.tweets,
+              normalizedUsername
+            );
           }
         } catch (error) {
           logger3.error(`Error searching posts from @${targetUser}:`, error);
@@ -6281,7 +6349,9 @@ var TwitterInteractionClient = class {
       }
       const shouldEngage = await this.shouldEngageWithTweet(tweet);
       if (shouldEngage) {
-        logger3.info(`Engaging with tweet from @${username}: ${tweet.text.substring(0, 50)}...`);
+        logger3.info(
+          `Engaging with tweet from @${username}: ${tweet.text.substring(0, 50)}...`
+        );
         await this.ensureTweetContext(tweet);
         const engaged = await this.engageWithTweet(tweet);
         if (engaged) {
@@ -6305,7 +6375,9 @@ var TwitterInteractionClient = class {
         return tweetAge < 12 * 60 * 60 * 1e3;
       });
       if (relevantTweets.length > 0) {
-        logger3.info(`Found ${relevantTweets.length} relevant tweets from timeline`);
+        logger3.info(
+          `Found ${relevantTweets.length} relevant tweets from timeline`
+        );
         await this.processTargetUserTweets(relevantTweets, "timeline");
       }
     } catch (error) {
@@ -6476,8 +6548,13 @@ Response (YES/NO):`;
     const maxInteractionsPerRun = parseInt(
       getSetting(this.runtime, "TWITTER_MAX_ENGAGEMENTS_PER_RUN") || process.env.TWITTER_MAX_ENGAGEMENTS_PER_RUN || "10"
     );
-    const tweetsToProcess = uniqueTweetCandidates.slice(0, maxInteractionsPerRun);
-    logger3.info(`Processing ${tweetsToProcess.length} of ${uniqueTweetCandidates.length} mention tweets (max: ${maxInteractionsPerRun})`);
+    const tweetsToProcess = uniqueTweetCandidates.slice(
+      0,
+      maxInteractionsPerRun
+    );
+    logger3.info(
+      `Processing ${tweetsToProcess.length} of ${uniqueTweetCandidates.length} mention tweets (max: ${maxInteractionsPerRun})`
+    );
     for (const tweet of tweetsToProcess) {
       if (!this.client.lastCheckedTweetId || BigInt(tweet.id) > this.client.lastCheckedTweetId) {
         const tweetId = createUniqueUuid2(this.runtime, tweet.id);
@@ -6817,19 +6894,21 @@ Response (YES/NO):`;
 
 // src/post.ts
 import {
-  ChannelType as ChannelType2,
   createUniqueUuid as createUniqueUuid3,
-  logger as logger4
+  logger as logger4,
+  ModelType as ModelType2
 } from "@elizaos/core";
 var TwitterPostClient = class {
+  // Add lock to prevent concurrent posting
   /**
-   * Constructor for initializing a new Twitter client with the provided client, runtime, and state
-   * @param {ClientBase} client - The client used for interacting with Twitter API
-   * @param {IAgentRuntime} runtime - The runtime environment for the agent
+   * Creates an instance of TwitterPostClient.
+   * @param {ClientBase} client - The client instance.
+   * @param {IAgentRuntime} runtime - The runtime instance.
    * @param {any} state - The state object containing configuration settings
    */
   constructor(client, runtime, state) {
     this.isRunning = false;
+    this.isPosting = false;
     this.client = client;
     this.state = state;
     this.runtime = runtime;
@@ -6871,11 +6950,11 @@ var TwitterPostClient = class {
       }
     };
     await new Promise((resolve) => setTimeout(resolve, 1e3));
-    const postImmediately = parseInt(
-      this.state?.TWITTER_POST_INTERVAL || getSetting(this.runtime, "TWITTER_POST_INTERVAL") || process.env.TWITTER_POST_INTERVAL || "120"
-    ) === 0;
-    if (postImmediately) {
-      logger4.info("TWITTER_POST_IMMEDIATELY is true, generating initial tweet now");
+    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(
+        "TWITTER_POST_IMMEDIATELY is true, generating initial tweet now"
+      );
       await this.generateNewTweet();
     }
     generateNewTweetLoop();
@@ -6886,78 +6965,124 @@ var TwitterPostClient = class {
    */
   async generateNewTweet() {
     logger4.info("Attempting to generate new tweet...");
+    if (this.isPosting) {
+      logger4.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");
         return;
       }
-      logger4.info(`Generating tweet for user: ${this.client.profile?.username} (${userId})`);
+      logger4.info(
+        `Generating tweet for user: ${this.client.profile?.username} (${userId})`
+      );
       const worldId = createUniqueUuid3(this.runtime, userId);
       const roomId = createUniqueUuid3(this.runtime, `${userId}-home`);
-      const callback = async (content) => {
-        logger4.info("Tweet generation callback triggered");
-        try {
-          if (this.isDryRun) {
-            logger4.info(`[DRY RUN] Would post tweet: ${content.text}`);
-            return [];
-          }
-          if (content.text.includes("Error: Missing")) {
-            logger4.error("Error: Missing some context", content);
-            return [];
-          }
-          logger4.info(`Posting tweet: ${content.text}`);
-          const result = await this.postToTwitter(
-            content.text,
-            content.mediaData
-          );
-          if (result === null) {
-            logger4.info("Skipped posting duplicate tweet");
-            return [];
-          }
-          const tweetId = result.id;
-          logger4.info(`Tweet posted successfully! ID: ${tweetId}`);
-          if (result) {
-            const postedTweetId = createUniqueUuid3(this.runtime, tweetId);
-            const postedMemory = {
-              id: postedTweetId,
-              entityId: this.runtime.agentId,
-              agentId: this.runtime.agentId,
-              roomId,
-              content: {
-                ...content,
-                source: "twitter",
-                channelType: ChannelType2.FEED,
-                type: "post",
-                metadata: {
-                  tweetId,
-                  postedAt: Date.now()
-                }
-              },
-              createdAt: Date.now()
-            };
-            await this.runtime.createMemory(postedMemory, "messages");
-            return [postedMemory];
-          }
-          return [];
-        } catch (error) {
-          logger4.error("Error in tweet generation callback:", error);
-          return [];
-        }
-      };
-      this.runtime.emitEvent(
-        "TWITTER_POST_GENERATED" /* POST_GENERATED */,
+      const state = await this.runtime.composeState({
+        agentId: this.runtime.agentId,
+        entityId: this.runtime.agentId,
+        roomId,
+        content: { text: "", type: "post" },
+        createdAt: Date.now()
+      });
+      const tweetPrompt = `You are ${this.runtime.character.name}.
+${this.runtime.character.bio}
+
+CRITICAL: Generate a tweet that sounds like YOU, not a generic motivational poster or LinkedIn influencer.
+
+${this.runtime.character.messageExamples && this.runtime.character.messageExamples.length > 0 ? `
+Example tweets that capture your voice:
+${this.runtime.character.messageExamples.map(
+        (example) => Array.isArray(example) ? example[1]?.content?.text || "" : example
+      ).filter(Boolean).slice(0, 5).join("\n")}
+` : ""}
+
+Style guidelines:
+- Be authentic, opinionated, and specific - no generic platitudes
+- Use your unique voice and perspective  
+- Share hot takes, unpopular opinions, or specific insights
+- Be conversational, not preachy
+- If you use emojis, use them sparingly and purposefully
+- Length: 50-280 characters (keep it punchy)
+- NO hashtags unless absolutely essential
+- NO generic motivational content
+
+Your interests: ${this.runtime.character.topics?.join(", ") || "technology, crypto, AI"}
+
+${this.runtime.character.style ? `Your style: ${typeof this.runtime.character.style === "object" ? this.runtime.character.style.all?.join(", ") || JSON.stringify(this.runtime.character.style) : this.runtime.character.style}` : ""}
+
+Recent context:
+${state.recentMemories?.slice(0, 3).map((m) => m.content.text).join("\n") || "No recent context"}
+
+Generate a single tweet that sounds like YOU would actually write it:`;
+      const generatedContent = await this.runtime.useModel(
+        ModelType2.TEXT_SMALL,
         {
-          callback,
-          entityId: this.runtime.agentId,
-          userId,
-          roomId,
-          source: "twitter"
+          prompt: tweetPrompt,
+          temperature: 0.9,
+          // Increased for more creativity
+          maxTokens: 100
         }
       );
-      logger4.info("POST_GENERATED event emitted successfully");
+      const tweetText = generatedContent.trim();
+      if (!tweetText || tweetText.length === 0) {
+        logger4.error("Generated empty tweet content");
+        return;
+      }
+      if (tweetText.includes("Error: Missing")) {
+        logger4.error("Error in generated content:", tweetText);
+        return;
+      }
+      if (tweetText.length > 280) {
+        logger4.warn(`Generated tweet too long (${tweetText.length} chars), truncating...`);
+        const sentences = tweetText.match(/[^.!?]+[.!?]+/g) || [tweetText];
+        let truncated = "";
+        for (const sentence of sentences) {
+          if ((truncated + sentence).length <= 280) {
+            truncated += sentence;
+          } else {
+            break;
+          }
+        }
+        const finalTweet = truncated.trim() || tweetText.substring(0, 277) + "...";
+        logger4.info(`Truncated tweet: ${finalTweet}`);
+        if (this.isDryRun) {
+          logger4.info(`[DRY RUN] Would post tweet: ${finalTweet}`);
+          return;
+        }
+        const result2 = await this.postToTwitter(finalTweet, []);
+        if (result2 === null) {
+          logger4.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)");
+        return;
+      }
+      logger4.info(`Generated tweet: ${tweetText}`);
+      if (this.isDryRun) {
+        logger4.info(`[DRY RUN] Would post tweet: ${tweetText}`);
+        return;
+      }
+      const result = await this.postToTwitter(tweetText, []);
+      if (result === null) {
+        logger4.info("Skipped posting duplicate tweet");
+        return;
+      }
+      const tweetId = result.id;
+      logger4.info(`Tweet posted successfully! ID: ${tweetId}`);
+      if (result) {
+        const postedTweetId = createUniqueUuid3(this.runtime, tweetId);
+        logger4.info("Tweet posted successfully (memory saving temporarily disabled)");
+      }
     } catch (error) {
       logger4.error("Error generating tweet:", error);
+    } finally {
+      this.isPosting = false;
     }
   }
   /**
@@ -7014,7 +7139,7 @@ import {
   ChannelType as ChannelType3,
   composePromptFromState,
   createUniqueUuid as createUniqueUuid4,
-  ModelType as ModelType2,
+  ModelType as ModelType3,
   parseKeyValueXml
 } from "@elizaos/core";
 import { logger as logger5 } from "@elizaos/core";
@@ -7026,20 +7151,23 @@ var twitterActionTemplate = `
 {{postDirections}}
 
 Guidelines:
-- ONLY engage with content that DIRECTLY relates to character's core interests
-- Direct mentions are priority IF they are on-topic
-- Skip ALL content that is:
-  - Off-topic or tangentially related
-  - From high-profile accounts unless explicitly relevant
-  - Generic/viral content without specific relevance
-  - Political/controversial unless central to character
-  - Promotional/marketing unless directly relevant
+- Engage with content that relates to character's interests and expertise
+- Direct mentions should be prioritized when relevant
+- Consider engaging with:
+  - Content directly related to your topics
+  - Interesting discussions you can contribute to
+  - Questions you can help answer
+  - Content from users you've interacted with before
+- Skip content that is:
+  - Completely off-topic or spam
+  - Inflammatory or highly controversial (unless it's your area)
+  - Pure marketing/promotional with no value
 
 Actions (respond only with tags):
-[LIKE] - Perfect topic match AND aligns with character (9.8/10)
-[RETWEET] - Exceptional content that embodies character's expertise (9.5/10)
-[QUOTE] - Can add substantial domain expertise (9.5/10)
-[REPLY] - Can contribute meaningful, expert-level insight (9.5/10)
+[LIKE] - Content is relevant and interesting (7/10 or higher)
+[RETWEET] - Content is valuable and worth sharing (8/10 or higher)
+[QUOTE] - You can add meaningful commentary (7.5/10 or higher)
+[REPLY] - You can contribute helpful insights (7/10 or higher)
 `;
 var quoteTweetTemplate = `# Task: Write a quote tweet in the voice, style, and perspective of {{agentName}} @{{twitterUserName}}.
 
@@ -7105,7 +7233,9 @@ var TwitterTimelineClient = class {
         this.state?.TWITTER_ENGAGEMENT_INTERVAL || getSetting(this.runtime, "TWITTER_ENGAGEMENT_INTERVAL") || process.env.TWITTER_ENGAGEMENT_INTERVAL || "30"
       );
       const actionInterval = engagementIntervalMinutes * 60 * 1e3;
-      logger5.info(`Timeline client will check every ${engagementIntervalMinutes} minutes`);
+      logger5.info(
+        `Timeline client will check every ${engagementIntervalMinutes} minutes`
+      );
       this.handleTimeline();
       if (this.isRunning) {
         setTimeout(handleTwitterTimelineLoop, actionInterval);
@@ -7173,7 +7303,7 @@ ${tweet.text}
 
 Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appropriate. Each action must be on its own line. Your response must only include the chosen actions.`;
         const actionResponse = await this.runtime.useModel(
-          ModelType2.TEXT_SMALL,
+          ModelType3.TEXT_SMALL,
           {
             prompt: actionRespondPrompt
           }
@@ -7227,7 +7357,12 @@ ${actionSummary.join("\n")}`);
   }
   async processTimelineActions(tweetDecisions) {
     const results = [];
-    for (const { tweet, actionResponse, tweetState, roomId } of tweetDecisions) {
+    for (const {
+      tweet,
+      actionResponse,
+      tweetState,
+      roomId
+    } of tweetDecisions) {
       const tweetId = this.createTweetId(this.runtime, tweet);
       const executedActions = [];
       await this.runtime.createMemory(
@@ -7345,13 +7480,15 @@ ${actionSummary.join("\n")}`);
       }) + `
 You are responding to this tweet:
 ${tweet.text}`;
-      const quoteResponse = await this.runtime.useModel(ModelType2.TEXT_SMALL, {
+      const quoteResponse = await this.runtime.useModel(ModelType3.TEXT_SMALL, {
         prompt: quotePrompt
       });
       const responseObject = parseKeyValueXml(quoteResponse);
       if (responseObject.post) {
         if (this.isDryRun) {
-          logger5.log(`[DRY RUN] Would have quoted tweet ${tweet.id} with: ${responseObject.post}`);
+          logger5.log(
+            `[DRY RUN] Would have quoted tweet ${tweet.id} with: ${responseObject.post}`
+          );
           return;
         }
         const result = await this.client.requestQueue.add(
@@ -7396,13 +7533,15 @@ ${tweet.text}`;
       }) + `
 You are replying to this tweet:
 ${tweet.text}`;
-      const replyResponse = await this.runtime.useModel(ModelType2.TEXT_SMALL, {
+      const replyResponse = await this.runtime.useModel(ModelType3.TEXT_SMALL, {
         prompt: replyPrompt
       });
       const responseObject = parseKeyValueXml(replyResponse);
       if (responseObject.post) {
         if (this.isDryRun) {
-          logger5.log(`[DRY RUN] Would have replied to tweet ${tweet.id} with: ${responseObject.post}`);
+          logger5.log(
+            `[DRY RUN] Would have replied to tweet ${tweet.id} with: ${responseObject.post}`
+          );
           return;
         }
         const result = await sendTweet(
@@ -7438,7 +7577,7 @@ ${tweet.text}`;
 import {
   createUniqueUuid as createUniqueUuid5,
   logger as logger6,
-  ModelType as ModelType3
+  ModelType as ModelType4
 } from "@elizaos/core";
 var TwitterDiscoveryClient = class {
   constructor(client, runtime, state) {
@@ -7489,7 +7628,9 @@ var TwitterDiscoveryClient = class {
         topics = this.extractTopicsFromBio(character.bio);
       }
     } else {
-      logger6.warn("Character not available in runtime, using default topics for discovery");
+      logger6.warn(
+        "Character not available in runtime, using default topics for discovery"
+      );
     }
     return {
       topics,
@@ -7500,11 +7641,17 @@ var TwitterDiscoveryClient = class {
         getSetting(this.runtime, "TWITTER_MAX_FOLLOWS_PER_CYCLE") || process.env.TWITTER_MAX_FOLLOWS_PER_CYCLE || "5"
       ),
       maxEngagementsPerCycle: parseInt(
-        getSetting(this.runtime, "TWITTER_MAX_ENGAGEMENTS_PER_RUN") || process.env.TWITTER_MAX_ENGAGEMENTS_PER_RUN || "10"
+        getSetting(
+          this.runtime,
+          "TWITTER_MAX_ENGAGEMENTS_PER_RUN"
+        ) || process.env.TWITTER_MAX_ENGAGEMENTS_PER_RUN || "10"
       ),
-      likeThreshold: 0.6,
-      replyThreshold: 0.8,
-      quoteThreshold: 0.85
+      likeThreshold: 0.3,
+      // Lowered from 0.6
+      replyThreshold: 0.5,
+      // Lowered from 0.8
+      quoteThreshold: 0.7
+      // Lowered from 0.85
     };
   }
   extractTopicsFromBio(bio) {
@@ -7512,7 +7659,16 @@ var TwitterDiscoveryClient = class {
       return [];
     }
     const bioText = Array.isArray(bio) ? bio.join(" ") : bio;
-    const words = bioText.toLowerCase().split(/\s+/).filter((word) => word.length > 4).filter((word) => !["about", "helping", "working", "people", "making", "building"].includes(word));
+    const words = bioText.toLowerCase().split(/\s+/).filter((word) => word.length > 4).filter(
+      (word) => ![
+        "about",
+        "helping",
+        "working",
+        "people",
+        "making",
+        "building"
+      ].includes(word)
+    );
     return [...new Set(words)].slice(0, 5);
   }
   async start() {
@@ -7533,7 +7689,9 @@ var TwitterDiscoveryClient = class {
       );
       const variance = Math.random() * 20 - 10;
       const nextInterval = (baseInterval + variance) * 60 * 1e3;
-      logger6.info(`Next discovery cycle in ${(baseInterval + variance).toFixed(1)} minutes`);
+      logger6.info(
+        `Next discovery cycle in ${(baseInterval + variance).toFixed(1)} minutes`
+      );
       if (this.isRunning) {
         setTimeout(discoveryLoop, nextInterval);
       }
@@ -7548,7 +7706,9 @@ var TwitterDiscoveryClient = class {
     logger6.info("Starting Twitter discovery cycle...");
     const discoveries = await this.discoverContent();
     const { tweets, accounts } = discoveries;
-    logger6.info(`Discovered ${tweets.length} tweets and ${accounts.length} accounts`);
+    logger6.info(
+      `Discovered ${tweets.length} tweets and ${accounts.length} accounts`
+    );
     const followedCount = await this.processAccounts(accounts);
     const engagementCount = await this.processTweets(tweets);
     logger6.info(
@@ -7561,9 +7721,7 @@ var TwitterDiscoveryClient = class {
     try {
       const topicContent = await this.discoverFromTopics();
       allTweets.push(...topicContent.tweets);
-      topicContent.accounts.forEach(
-        (acc) => allAccounts.set(acc.user.id, acc)
-      );
+      topicContent.accounts.forEach((acc) => allAccounts.set(acc.user.id, acc));
     } catch (error) {
       logger6.error("Failed to discover from topics:", error);
     }
@@ -7586,7 +7744,9 @@ var TwitterDiscoveryClient = class {
       logger6.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((a, b) => b.qualityScore * b.relevanceScore - a.qualityScore * a.relevanceScore).slice(0, 20);
+    const sortedAccounts = Array.from(allAccounts.values()).sort(
+      (a, b) => b.qualityScore * b.relevanceScore - a.qualityScore * a.relevanceScore
+    ).slice(0, 20);
     return { tweets: sortedTweets, accounts: sortedAccounts };
   }
   async discoverFromTopics() {
@@ -7652,17 +7812,17 @@ var TwitterDiscoveryClient = class {
       );
       for (const tweet of searchResults.tweets) {
         const engagementScore = (tweet.likes || 0) + (tweet.retweets || 0) * 2;
-        if (engagementScore < 50) continue;
+        if (engagementScore < 10) continue;
         const scored = this.scoreTweet(tweet, "thread");
         tweets.push(scored);
         const account = this.scoreAccount({
           id: tweet.userId,
           username: tweet.username,
           name: tweet.name || tweet.username,
-          followersCount: 5e3
-          // Estimate for viral content creators
+          followersCount: 1e3
+          // Reasonable estimate for engaged users
         });
-        if (account.qualityScore > 0.6) {
+        if (account.qualityScore > 0.5) {
           accounts.set(tweet.userId, account);
         }
       }
@@ -7687,7 +7847,7 @@ var TwitterDiscoveryClient = class {
         );
         for (const tweet of results.tweets) {
           const engagement = (tweet.likes || 0) + (tweet.retweets || 0) * 2;
-          if (engagement < 20) continue;
+          if (engagement < 5) continue;
           const scored = this.scoreTweet(tweet, "topic");
           tweets.push(scored);
           const estimatedFollowers = Math.max(
@@ -7706,7 +7866,10 @@ var TwitterDiscoveryClient = class {
           }
         }
       } catch (error) {
-        logger6.error(`Failed to discover popular accounts for ${topic}:`, error);
+        logger6.error(
+          `Failed to discover popular accounts for ${topic}:`,
+          error
+        );
       }
     }
     return { tweets, accounts: Array.from(accounts.values()) };
@@ -7716,12 +7879,15 @@ var TwitterDiscoveryClient = class {
   scoreTweet(tweet, source) {
     let relevanceScore = 0;
     const sourceScores = {
-      topic: 0.5,
-      thread: 0.4
+      topic: 0.4,
+      thread: 0.35
     };
     relevanceScore += sourceScores[source];
     const engagementScore = Math.min(
-      (tweet.likes || 0) / 1e3 + (tweet.retweets || 0) / 500 + (tweet.replies || 0) / 100,
+      (tweet.likes || 0) / 100 + // 100 likes = 0.1 points (was 1000)
+      (tweet.retweets || 0) / 50 + // 50 retweets = 0.1 points (was 500)
+      (tweet.replies || 0) / 20,
+      // 20 replies = 0.1 points (was 100)
       0.3
     );
     relevanceScore += engagementScore;
@@ -7729,7 +7895,7 @@ var TwitterDiscoveryClient = class {
     const topicMatches = this.config.topics.filter(
       (topic) => textLower.includes(topic.toLowerCase())
     ).length;
-    relevanceScore += Math.min(topicMatches * 0.1, 0.3);
+    relevanceScore += Math.min(topicMatches * 0.15, 0.3);
     relevanceScore = Math.min(relevanceScore, 1);
     let engagementType = "skip";
     if (relevanceScore >= this.config.quoteThreshold) {
@@ -7783,7 +7949,10 @@ var TwitterDiscoveryClient = class {
         followedCount++;
         await this.delay(2e3 + Math.random() * 3e3);
       } catch (error) {
-        logger6.error(`Failed to follow @${scoredAccount.user.username}:`, error);
+        logger6.error(
+          `Failed to follow @${scoredAccount.user.username}:`,
+          error
+        );
       }
     }
     return followedCount;
@@ -7794,51 +7963,76 @@ var TwitterDiscoveryClient = class {
       if (engagementCount >= this.config.maxEngagementsPerCycle) break;
       if (scoredTweet.engagementType === "skip") continue;
       try {
-        const tweetMemoryId = createUniqueUuid5(this.runtime, scoredTweet.tweet.id);
+        const tweetMemoryId = createUniqueUuid5(
+          this.runtime,
+          scoredTweet.tweet.id
+        );
         const existingMemory = await this.runtime.getMemoryById(tweetMemoryId);
         if (existingMemory) {
-          logger6.debug(`Already engaged with tweet ${scoredTweet.tweet.id}, skipping`);
+          logger6.debug(
+            `Already engaged with tweet ${scoredTweet.tweet.id}, skipping`
+          );
           continue;
         }
         switch (scoredTweet.engagementType) {
           case "like":
             if (this.isDryRun) {
-              logger6.info(`[DRY RUN] Would like tweet: ${scoredTweet.tweet.id} (score: ${scoredTweet.relevanceScore.toFixed(2)})`);
+              logger6.info(
+                `[DRY RUN] Would like tweet: ${scoredTweet.tweet.id} (score: ${scoredTweet.relevanceScore.toFixed(2)})`
+              );
             } else {
               await this.twitterClient.likeTweet(scoredTweet.tweet.id);
-              logger6.info(`Liked tweet: ${scoredTweet.tweet.id} (score: ${scoredTweet.relevanceScore.toFixed(2)})`);
+              logger6.info(
+                `Liked tweet: ${scoredTweet.tweet.id} (score: ${scoredTweet.relevanceScore.toFixed(2)})`
+              );
             }
             break;
           case "reply":
             const replyText = await this.generateReply(scoredTweet.tweet);
             if (this.isDryRun) {
-              logger6.info(`[DRY RUN] Would reply to tweet ${scoredTweet.tweet.id} with: "${replyText}"`);
+              logger6.info(
+                `[DRY RUN] Would reply to tweet ${scoredTweet.tweet.id} with: "${replyText}"`
+              );
             } else {
-              await this.twitterClient.sendTweet(replyText, scoredTweet.tweet.id);
+              await this.twitterClient.sendTweet(
+                replyText,
+                scoredTweet.tweet.id
+              );
               logger6.info(`Replied to tweet: ${scoredTweet.tweet.id}`);
             }
             break;
           case "quote":
             const quoteText = await this.generateQuote(scoredTweet.tweet);
             if (this.isDryRun) {
-              logger6.info(`[DRY RUN] Would quote tweet ${scoredTweet.tweet.id} with: "${quoteText}"`);
+              logger6.info(
+                `[DRY RUN] Would quote tweet ${scoredTweet.tweet.id} with: "${quoteText}"`
+              );
             } else {
-              await this.twitterClient.sendQuoteTweet(quoteText, scoredTweet.tweet.id);
+              await this.twitterClient.sendQuoteTweet(
+                quoteText,
+                scoredTweet.tweet.id
+              );
               logger6.info(`Quoted tweet: ${scoredTweet.tweet.id}`);
             }
             break;
         }
-        await this.saveEngagementMemory(scoredTweet.tweet, scoredTweet.engagementType);
+        await this.saveEngagementMemory(
+          scoredTweet.tweet,
+          scoredTweet.engagementType
+        );
         engagementCount++;
         await this.delay(3e3 + Math.random() * 5e3);
       } catch (error) {
-        logger6.error(`Failed to engage with tweet ${scoredTweet.tweet.id}:`, error);
+        logger6.error(
+          `Failed to engage with tweet ${scoredTweet.tweet.id}:`,
+          error
+        );
       }
     }
     return engagementCount;
   }
   async checkIfFollowing(userId) {
-    const embedding = await this.runtime.useModel(ModelType3.TEXT_EMBEDDING, {
+    const embedding = await this.runtime.useModel(ModelType4.TEXT_EMBEDDING, {
       text: `followed twitter user ${userId}`
     });
     const followMemories = await this.runtime.searchMemories({
@@ -7874,7 +8068,7 @@ Keep the reply:
 - Respectful and constructive
 
 Reply:`;
-    const response = await this.runtime.useModel(ModelType3.TEXT_SMALL, {
+    const response = await this.runtime.useModel(ModelType4.TEXT_SMALL, {
       prompt,
       max_tokens: 100,
       temperature: 0.8
@@ -7906,7 +8100,7 @@ Create a quote tweet that:
 - Encourages further discussion
 
 Quote tweet:`;
-    const response = await this.runtime.useModel(ModelType3.TEXT_SMALL, {
+    const response = await this.runtime.useModel(ModelType4.TEXT_SMALL, {
       prompt,
       max_tokens: 100,
       temperature: 0.8
@@ -7914,37 +8108,43 @@ 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
-        }
+    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)
       },
-      roomId: createUniqueUuid5(this.runtime, tweet.conversationId)
-    }, "messages");
+      "messages"
+    );
   }
   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
-        }
+    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`)
       },
-      roomId: createUniqueUuid5(this.runtime, `twitter-follows`)
-    }, "messages");
+      "messages"
+    );
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -8008,7 +8208,9 @@ var RequestQueue = class {
           await this.exponentialBackoff(retryCount);
           break;
         } else {
-          logger7.error(`Max retries (${this.maxRetries}) exceeded for request, skipping`);
+          logger7.error(
+            `Max retries (${this.maxRetries}) exceeded for request, skipping`
+          );
           this.retryAttempts.delete(request);
         }
       }
@@ -8541,13 +8743,17 @@ 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(`TWITTER_ENABLE_POST setting value: ${JSON.stringify(postEnabledSetting)}, type: ${typeof postEnabledSetting}`);
+    logger8.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");
       this.post = new TwitterPostClient(this.client, runtime, state);
     } else {
-      logger8.info("Twitter posting is DISABLED - set TWITTER_ENABLE_POST=true to enable automatic posting");
+      logger8.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) {
@@ -8572,7 +8778,9 @@ var TwitterClientInstance = class {
       logger8.info("Twitter discovery service is ENABLED");
       this.discovery = new TwitterDiscoveryClient(this.client, runtime, state);
     } else {
-      logger8.info("Twitter discovery service is DISABLED - set TWITTER_ENABLE_DISCOVERY=true to enable");
+      logger8.info(
+        "Twitter discovery service is DISABLED - set TWITTER_ENABLE_DISCOVERY=true to enable"
+      );
     }
   }
 };
@@ -8635,11 +8843,17 @@ var TwitterService = _TwitterService;
 // src/actions/postTweet.ts
 import {
   logger as logger9,
-  ModelType as ModelType4
+  ModelType as ModelType5
 } from "@elizaos/core";
 var postTweetAction = {
   name: "POST_TWEET",
-  similes: ["TWEET", "SEND_TWEET", "TWITTER_POST", "POST_ON_TWITTER", "SHARE_ON_TWITTER"],
+  similes: [
+    "TWEET",
+    "SEND_TWEET",
+    "TWITTER_POST",
+    "POST_ON_TWITTER",
+    "SHARE_ON_TWITTER"
+  ],
   validate: async (runtime, message) => {
     logger9.debug("Validating POST_TWEET action");
     const text = message.content?.text?.trim();
@@ -8660,32 +8874,70 @@ var postTweetAction = {
       if (!client.twitterClient) {
         await client.init();
       }
+      let text = message.content?.text?.trim();
+      if (!text) {
+        logger9.error("No text content for tweet");
+        if (callback) {
+          callback({
+            text: "I need something to tweet! Please provide the text.",
+            action: "POST_TWEET"
+          });
+        }
+        return;
+      }
+      if (text.length > 280) {
+        logger9.info(`Truncating tweet from ${text.length} to 280 characters`);
+        const sentences = text.match(/[^.!?]+[.!?]+/g) || [text];
+        let truncated = "";
+        for (const sentence of sentences) {
+          if ((truncated + sentence).length <= 280) {
+            truncated += sentence;
+          } else {
+            break;
+          }
+        }
+        text = truncated.trim() || text.substring(0, 277) + "...";
+        logger9.info(`Truncated tweet: ${text}`);
+      }
       if (!client.profile) {
-        throw new Error("Twitter client not properly initialized - no profile found");
+        throw new Error(
+          "Twitter client not properly initialized - no profile found"
+        );
       }
-      const tweetText = message.content?.text?.trim() || "";
-      let finalTweetText = tweetText;
-      if (tweetText.length < 50 || tweetText.toLowerCase().includes("post") || tweetText.toLowerCase().includes("tweet")) {
-        const tweetPrompt = `You are ${runtime.character.name}. Create an interesting tweet based on this context:
+      let finalTweetText = text;
+      if (text.length < 50 || text.toLowerCase().includes("post") || text.toLowerCase().includes("tweet")) {
+        const tweetPrompt = `You are ${runtime.character.name}. 
+${runtime.character.bio || ""}
 
-Context: ${tweetText}
+CRITICAL: Generate a tweet based on the context that sounds like YOU, not generic corporate speak.
 
-Your interests: ${runtime.character.topics?.join(", ") || "technology, AI, web3"}
-Your style: ${runtime.character.style?.all?.join(", ") || "thoughtful, engaging"}
+Context: ${text}
 
-Generate a tweet that:
-- Is under 280 characters
-- Reflects your personality and interests
-- Is engaging and conversational
-- Doesn't use hashtags unless truly relevant
-- Doesn't ask questions at the end
-- Is not generic or promotional
+${runtime.character.messageExamples && runtime.character.messageExamples.length > 0 ? `
+Your voice examples:
+${runtime.character.messageExamples.map(
+          (example) => Array.isArray(example) ? example[1]?.content?.text || "" : example
+        ).filter(Boolean).slice(0, 3).join("\n")}
+` : ""}
+
+Style rules:
+- Be specific, opinionated, authentic
+- No generic motivational content or platitudes
+- Share actual insights, hot takes, or unique perspectives
+- Keep it conversational and punchy
+- Under 280 characters
+- Skip hashtags unless essential
+- Don't end with generic questions
+
+Your interests: ${runtime.character.topics?.join(", ") || "technology, AI, web3"}
+${runtime.character.style ? `Your style: ${typeof runtime.character.style === "object" ? runtime.character.style.all?.join(", ") || "" : runtime.character.style}` : ""}
 
 Tweet:`;
-        const response = await runtime.useModel(ModelType4.TEXT_SMALL, {
+        const response = await runtime.useModel(ModelType5.TEXT_SMALL, {
           prompt: tweetPrompt,
           max_tokens: 100,
-          temperature: 0.8
+          temperature: 0.9
+          // Higher for more creativity
         });
         finalTweetText = response.trim();
       }
@@ -8702,16 +8954,19 @@ Tweet:`;
         }
         const tweetUrl = `https://twitter.com/${client.profile.username}/status/${tweetId}`;
         logger9.info(`Successfully posted tweet: ${tweetId}`);
-        await runtime.createMemory({
-          entityId: runtime.agentId,
-          content: {
-            text: finalTweetText,
-            url: tweetUrl,
-            source: "twitter",
-            action: "POST_TWEET"
+        await runtime.createMemory(
+          {
+            entityId: runtime.agentId,
+            content: {
+              text: finalTweetText,
+              url: tweetUrl,
+              source: "twitter",
+              action: "POST_TWEET"
+            },
+            roomId: message.roomId
           },
-          roomId: message.roomId
-        }, "messages");
+          "messages"
+        );
         if (callback) {
           await callback({
             text: `I've posted a tweet: "${finalTweetText}"
@@ -8723,7 +8978,7 @@ View it here: ${tweetUrl}`,
             }
           });
         }
-        return true;
+        return;
       } else {
         throw new Error("Failed to post tweet - no response data");
       }
@@ -8735,7 +8990,7 @@ View it here: ${tweetUrl}`,
           metadata: { error: error.message }
         });
       }
-      return false;
+      return;
     }
   },
   examples: [