@elizaos/plugin-twitter 1.2.11 → 1.2.13

package/dist/index.js

@@ -1948,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";
@@ -6894,20 +6894,21 @@ Response (YES/NO):`;
 
 // src/post.ts
 import {
-  ChannelType as ChannelType2,
   createUniqueUuid as createUniqueUuid3,
   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;
@@ -6943,9 +6944,14 @@ var TwitterPostClient = class {
       );
       const interval = postIntervalMinutes * 60 * 1e3;
       logger4.info(`Next tweet scheduled in ${postIntervalMinutes} minutes`);
+      await new Promise((resolve) => setTimeout(resolve, interval));
+      if (!this.isRunning) {
+        logger4.log("Twitter post client stopped during wait, exiting loop");
+        return;
+      }
       await this.generateNewTweet();
       if (this.isRunning) {
-        setTimeout(generateNewTweetLoop, interval);
+        generateNewTweetLoop();
       }
     };
     await new Promise((resolve) => setTimeout(resolve, 1e3));
@@ -6964,6 +6970,11 @@ 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) {
@@ -6981,28 +6992,50 @@ var TwitterPostClient = class {
         roomId,
         content: { text: "", type: "post" },
         createdAt: Date.now()
+      }).catch((error) => {
+        logger4.warn("Error composing state, using minimal state:", error);
+        return {
+          agentId: this.runtime.agentId,
+          recentMemories: [],
+          values: {}
+        };
       });
       const tweetPrompt = `You are ${this.runtime.character.name}.
 ${this.runtime.character.bio}
 
-Generate a tweet that:
-- Reflects your personality and interests
-- Is engaging and authentic
-- Is between 50-280 characters
-- Does NOT include hashtags unless they're essential to the message
-- Does NOT include @mentions unless replying to someone
+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 topics of interest: ${this.runtime.character.topics?.join(", ") || "general topics"}
+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, 5).map((m) => m.content.text).join("\n") || "No recent context"}
+${state.recentMemories?.slice(0, 3).map((m) => m.content.text).join("\n") || "No recent context"}
 
-Generate a single tweet:`;
+Generate a single tweet that sounds like YOU would actually write it:`;
       const generatedContent = await this.runtime.useModel(
         ModelType2.TEXT_SMALL,
         {
           prompt: tweetPrompt,
-          temperature: 0.8,
+          temperature: 0.9,
+          // Increased for more creativity
           maxTokens: 100
         }
       );
@@ -7015,6 +7048,33 @@ Generate a single tweet:`;
         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}`);
@@ -7029,28 +7089,12 @@ Generate a single tweet:`;
       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: {
-            text: tweetText,
-            source: "twitter",
-            channelType: ChannelType2.FEED,
-            type: "post",
-            metadata: {
-              tweetId,
-              postedAt: Date.now()
-            }
-          },
-          createdAt: Date.now()
-        };
-        await this.runtime.createMemory(postedMemory, "messages");
-        logger4.info("Tweet posted and saved to memory successfully");
+        logger4.info("Tweet posted successfully (memory saving temporarily disabled)");
       }
     } catch (error) {
       logger4.error("Error generating tweet:", error);
+    } finally {
+      this.isPosting = false;
     }
   }
   /**
@@ -8824,9 +8868,19 @@ var postTweetAction = {
   ],
   validate: async (runtime, message) => {
     logger9.debug("Validating POST_TWEET action");
+    logger9.debug("Message details:", {
+      hasContent: !!message.content,
+      contentType: message.content?.type,
+      hasText: !!message.content?.text,
+      textLength: message.content?.text?.length || 0,
+      source: message.content?.source,
+      roomId: message.roomId,
+      entityId: message.entityId
+    });
     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);
       return false;
     }
     if (text.length > 280) {
@@ -8842,34 +8896,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"
         );
       }
-      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(ModelType5.TEXT_SMALL, {
           prompt: tweetPrompt,
           max_tokens: 100,
-          temperature: 0.8
+          temperature: 0.9
+          // Higher for more creativity
         });
         finalTweetText = response.trim();
       }
@@ -8910,7 +9000,7 @@ View it here: ${tweetUrl}`,
             }
           });
         }
-        return true;
+        return;
       } else {
         throw new Error("Failed to post tweet - no response data");
       }
@@ -8922,7 +9012,7 @@ View it here: ${tweetUrl}`,
           metadata: { error: error.message }
         });
       }
-      return false;
+      return;
     }
   },
   examples: [