@elizaos/plugin-twitter 1.2.0 → 1.2.1

package/README.md

@@ -177,11 +177,6 @@ TWITTER_POST_INTERVAL_VARIANCE=0.2 # Random variance factor for posting interval
 
 # Interaction Settings
 TWITTER_SEARCH_ENABLE=true         # Enable timeline monitoring and interactions
-TWITTER_INTERACTION_INTERVAL_MIN=15    # Minimum interval between interactions (minutes)
-TWITTER_INTERACTION_INTERVAL_MAX=30    # Maximum interval between interactions (minutes)
-TWITTER_INTERACTION_INTERVAL_VARIANCE=0.3  # Random variance for interaction intervals
-TWITTER_AUTO_RESPOND_MENTIONS=true     # Automatically respond to mentions
-TWITTER_AUTO_RESPOND_REPLIES=true      # Automatically respond to replies
 TWITTER_MAX_INTERACTIONS_PER_RUN=10    # Maximum interactions processed per cycle
 
 # Timeline Algorithm Configuration
@@ -193,8 +188,8 @@ TWITTER_TIMELINE_RELEVANCE_WEIGHT=5    # Weight for relevance scoring
 # Advanced Settings
 TWITTER_MAX_TWEET_LENGTH=4000      # Maximum tweet length (for threads)
 TWITTER_DM_ONLY=false             # Only interact via direct messages
-TWITTER_ENABLE_ACTION_PROCESSING=false  # Enable timeline action processing
-TWITTER_ACTION_INTERVAL=240       # Action processing interval (minutes)
+TWITTER_ENABLE_ACTION_PROCESSING=false  # Enable timeline action processing (likes, retweets, replies)
+TWITTER_ACTION_INTERVAL=30       # Timeline action processing interval in MINUTES (default: 30 minutes)
 ```
 
 ## 🎯 Common Use Cases

package/dist/index.d.ts

@@ -769,6 +769,7 @@ declare class TwitterInteractionClient {
     runtime: IAgentRuntime;
     private isDryRun;
     private state;
+    private isRunning;
     /**
      * Constructor for setting up a new instance with the provided client, runtime, and state.
      * @param {ClientBase} client - The client being used for communication.
@@ -833,6 +834,7 @@ declare class TwitterInteractionClient {
      */
     buildConversationThread(tweet: Tweet$1, maxReplies?: number): Promise<Tweet$1[]>;
     private createMemoryObject;
+    stop(): Promise<void>;
 }
 
 /**
@@ -844,6 +846,7 @@ declare class TwitterPostClient {
     twitterUsername: string;
     private isDryRun;
     private state;
+    private isRunning;
     /**
      * 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
@@ -943,6 +946,8 @@ type TwitterProfile = {
 declare class RequestQueue {
     private queue;
     private processing;
+    private maxRetries;
+    private retryAttempts;
     /**
      * Asynchronously adds a request to the queue, then processes the queue.
      *
@@ -1058,6 +1063,7 @@ declare class TwitterTimelineClient {
     isDryRun: boolean;
     timelineType: TIMELINE_TYPE;
     private state;
+    private isRunning;
     constructor(client: ClientBase, runtime: IAgentRuntime, state: any);
     start(): Promise<void>;
     getTimeline(count: number): Promise<Tweet$1[]>;
@@ -1085,6 +1091,7 @@ declare class TwitterTimelineClient {
     handleRetweetAction(tweet: Tweet$1): Promise<void>;
     handleQuoteAction(tweet: Tweet$1): Promise<void>;
     handleReplyAction(tweet: Tweet$1): Promise<void>;
+    stop(): Promise<void>;
 }
 
 /**

package/dist/index.js

@@ -504,9 +504,7 @@ async function* searchTweets(query, maxTweets, searchMode, auth) {
       const convertedTweet = {
         id: tweet.id,
         text: tweet.text || "",
-        // Twitter API returns created_at as ISO string, convert to seconds
-        // to match the expected Tweet.timestamp format used throughout the plugin
-        timestamp: tweet.created_at ? new Date(tweet.created_at).getTime() / 1e3 : Date.now() / 1e3,
+        timestamp: tweet.created_at ? new Date(tweet.created_at).getTime() : Date.now(),
         timeParsed: tweet.created_at ? new Date(tweet.created_at) : /* @__PURE__ */ new Date(),
         userId: tweet.author_id || "",
         name: searchIterator.includes?.users?.find((u) => u.id === tweet.author_id)?.name || "",
@@ -1919,6 +1917,8 @@ var RequestQueue = class {
   constructor() {
     this.queue = [];
     this.processing = false;
+    this.maxRetries = 3;
+    this.retryAttempts = /* @__PURE__ */ new Map();
   }
   /**
    * Asynchronously adds a request to the queue, then processes the queue.
@@ -1954,14 +1954,26 @@ var RequestQueue = class {
       const request = this.queue.shift();
       try {
         await request();
+        this.retryAttempts.delete(request);
       } catch (error) {
-        console.error("Error processing request:", error);
-        this.queue.unshift(request);
-        await this.exponentialBackoff(this.queue.length);
+        logger.error("Error processing request:", error);
+        const retryCount = (this.retryAttempts.get(request) || 0) + 1;
+        if (retryCount < this.maxRetries) {
+          this.retryAttempts.set(request, retryCount);
+          this.queue.unshift(request);
+          await this.exponentialBackoff(retryCount);
+          break;
+        } else {
+          logger.error(`Max retries (${this.maxRetries}) exceeded for request, skipping`);
+          this.retryAttempts.delete(request);
+        }
       }
       await this.randomDelay();
     }
     this.processing = false;
+    if (this.queue.length > 0) {
+      this.processQueue();
+    }
   }
   /**
    * Implements an exponential backoff strategy for retrying a task.
@@ -2008,7 +2020,7 @@ var _ClientBase = class _ClientBase {
    */
   async cacheTweet(tweet) {
     if (!tweet) {
-      console.warn("Tweet is undefined, skipping cache");
+      logger.warn("Tweet is undefined, skipping cache");
       return;
     }
     this.runtime.setCache(`twitter/tweets/${tweet.id}`, tweet);
@@ -2422,7 +2434,7 @@ var _ClientBase = class _ClientBase {
       });
       return profile;
     } catch (error) {
-      console.error("Error fetching Twitter profile:", error);
+      logger.error("Error fetching Twitter profile:", error);
       throw error;
     }
   }
@@ -6668,6 +6680,7 @@ var TwitterInteractionClient = class {
    * @param {any} state - The initial state of the agent.
    */
   constructor(client, runtime, state) {
+    this.isRunning = false;
     this.client = client;
     this.runtime = runtime;
     this.state = state;
@@ -6678,12 +6691,19 @@ var TwitterInteractionClient = class {
    * Uses an interval based on the 'TWITTER_POLL_INTERVAL' setting, or defaults to 2 minutes if not set.
    */
   async start() {
+    this.isRunning = true;
     const handleTwitterInteractionsLoop = () => {
+      if (!this.isRunning) {
+        logger4.info("Twitter interaction client stopped, exiting loop");
+        return;
+      }
       const interactionInterval = (this.state?.TWITTER_POLL_INTERVAL || this.runtime.getSetting(
         "TWITTER_POLL_INTERVAL"
       ) || 120) * 1e3;
       this.handleTwitterInteractions();
-      setTimeout(handleTwitterInteractionsLoop, interactionInterval);
+      if (this.isRunning) {
+        setTimeout(handleTwitterInteractionsLoop, interactionInterval);
+      }
     };
     handleTwitterInteractionsLoop();
   }
@@ -6747,7 +6767,12 @@ var TwitterInteractionClient = class {
         return shouldTarget;
       });
     }
-    for (const tweet of uniqueTweetCandidates) {
+    const maxInteractionsPerRun = parseInt(
+      this.runtime.getSetting("TWITTER_MAX_INTERACTIONS_PER_RUN") || "10"
+    );
+    const tweetsToProcess = uniqueTweetCandidates.slice(0, maxInteractionsPerRun);
+    logger4.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 = createUniqueUuid3(this.runtime, tweet.id);
         const existingResponse = await this.runtime.getMemoryById(tweetId);
@@ -7151,6 +7176,10 @@ var TwitterInteractionClient = class {
       createdAt: Date.now()
     };
   }
+  async stop() {
+    logger4.info("Stopping Twitter interaction client...");
+    this.isRunning = false;
+  }
 };
 
 // src/post.ts
@@ -7168,6 +7197,7 @@ var TwitterPostClient = class {
    * @param {any} state - The state object containing configuration settings
    */
   constructor(client, runtime, state) {
+    this.isRunning = false;
     this.client = client;
     this.state = state;
     this.runtime = runtime;
@@ -7194,13 +7224,20 @@ var TwitterPostClient = class {
    */
   async start() {
     logger5.log("Starting Twitter post client...");
+    this.isRunning = true;
     const generateNewTweetLoop = async () => {
+      if (!this.isRunning) {
+        logger5.log("Twitter post client stopped, exiting loop");
+        return;
+      }
       const minPostMinutes = this.state?.TWITTER_POST_INTERVAL_MIN || this.runtime.getSetting("TWITTER_POST_INTERVAL_MIN") || 90;
       const maxPostMinutes = this.state?.TWITTER_POST_INTERVAL_MAX || this.runtime.getSetting("TWITTER_POST_INTERVAL_MAX") || 180;
       const randomMinutes = Math.floor(Math.random() * (maxPostMinutes - minPostMinutes + 1)) + minPostMinutes;
       const interval = randomMinutes * 60 * 1e3;
       await this.generateNewTweet();
-      setTimeout(generateNewTweetLoop, interval);
+      if (this.isRunning) {
+        setTimeout(generateNewTweetLoop, interval);
+      }
     };
     setTimeout(generateNewTweetLoop, 60 * 1e3);
     const postImmediately = this.state?.TWITTER_POST_IMMEDIATELY ?? this.runtime.getSetting("TWITTER_POST_IMMEDIATELY");
@@ -7336,6 +7373,8 @@ var TwitterPostClient = class {
     }
   }
   async stop() {
+    logger5.log("Stopping Twitter post client...");
+    this.isRunning = false;
   }
 };
 
@@ -7413,19 +7452,31 @@ Your output must ONLY contain the XML block.`;
 // src/timeline.ts
 var TwitterTimelineClient = class {
   constructor(client, runtime, state) {
+    this.isRunning = false;
     this.client = client;
     this.twitterClient = client.twitterClient;
     this.runtime = runtime;
     this.state = state;
-    this.timelineType = this.state?.TWITTER_TIMELINE_MODE || this.runtime.getSetting("TWITTER_TIMELINE_MODE");
+    const dryRunSetting = this.state?.TWITTER_DRY_RUN ?? this.runtime.getSetting("TWITTER_DRY_RUN");
+    this.isDryRun = dryRunSetting === true || dryRunSetting === "true" || typeof dryRunSetting === "string" && dryRunSetting.toLowerCase() === "true";
+    const timelineMode = this.state?.TWITTER_TIMELINE_MODE || this.runtime.getSetting("TWITTER_TIMELINE_MODE") || "foryou";
+    this.timelineType = timelineMode.toLowerCase() === "following" ? "following" /* Following */ : "foryou" /* ForYou */;
   }
   async start() {
+    logger6.info("Starting Twitter timeline client...");
+    this.isRunning = true;
     const handleTwitterTimelineLoop = () => {
-      const interactionInterval = (this.state?.TWITTER_TIMELINE_POLL_INTERVAL || this.runtime.getSetting(
-        "TWITTER_TIMELINE_POLL_INTERVAL"
-      ) || 120) * 1e3;
+      if (!this.isRunning) {
+        logger6.info("Twitter timeline client stopped, exiting loop");
+        return;
+      }
+      const actionIntervalMinutes = this.state?.TWITTER_ACTION_INTERVAL || this.runtime.getSetting("TWITTER_ACTION_INTERVAL") || 240;
+      const actionInterval = actionIntervalMinutes * 60 * 1e3;
+      logger6.info(`Timeline client will check every ${actionIntervalMinutes} minutes`);
       this.handleTimeline();
-      setTimeout(handleTwitterTimelineLoop, interactionInterval);
+      if (this.isRunning) {
+        setTimeout(handleTwitterTimelineLoop, actionInterval);
+      }
     };
     handleTwitterTimelineLoop();
   }
@@ -7456,8 +7507,9 @@ var TwitterTimelineClient = class {
     };
   }
   async handleTimeline() {
-    console.log("Start Hanldeling Twitter Timeline");
+    logger6.info("Starting Twitter timeline processing...");
     const tweets = await this.getTimeline(20);
+    logger6.info(`Fetched ${tweets.length} tweets from timeline`);
     const maxActionsPerCycle = 20;
     const tweetDecisions = [];
     for (const tweet of tweets) {
@@ -7465,7 +7517,7 @@ var TwitterTimelineClient = class {
         const tweetId = this.createTweetId(this.runtime, tweet);
         const memory = await this.runtime.getMemoryById(tweetId);
         if (memory) {
-          console.log(`Already processed tweet ID: ${tweet.id}`);
+          logger6.log(`Already processed tweet ID: ${tweet.id}`);
           continue;
         }
         const roomId = createUniqueUuid5(this.runtime, tweet.conversationId);
@@ -7518,7 +7570,21 @@ Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appro
       });
     };
     const prioritizedTweets = rankByActionRelevance(tweetDecisions);
-    this.processTimelineActions(prioritizedTweets);
+    logger6.info(`Processing ${prioritizedTweets.length} tweets with actions`);
+    if (prioritizedTweets.length > 0) {
+      const actionSummary = prioritizedTweets.map((td) => {
+        const actions = [];
+        if (td.actionResponse.like) actions.push("LIKE");
+        if (td.actionResponse.retweet) actions.push("RETWEET");
+        if (td.actionResponse.quote) actions.push("QUOTE");
+        if (td.actionResponse.reply) actions.push("REPLY");
+        return `Tweet ${td.tweet.id}: ${actions.join(", ")}`;
+      });
+      logger6.info(`Actions to execute:
+${actionSummary.join("\n")}`);
+    }
+    await this.processTimelineActions(prioritizedTweets);
+    logger6.info("Timeline processing complete");
   }
   async processTimelineActions(tweetDecisions) {
     const results = [];
@@ -7576,6 +7642,10 @@ Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appro
   }
   async handleLikeAction(tweet) {
     try {
+      if (this.isDryRun) {
+        logger6.log(`[DRY RUN] Would have liked tweet ${tweet.id}`);
+        return;
+      }
       await this.twitterClient.likeTweet(tweet.id);
       logger6.log(`Liked tweet ${tweet.id}`);
     } catch (error) {
@@ -7584,6 +7654,10 @@ Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appro
   }
   async handleRetweetAction(tweet) {
     try {
+      if (this.isDryRun) {
+        logger6.log(`[DRY RUN] Would have retweeted tweet ${tweet.id}`);
+        return;
+      }
       await this.twitterClient.retweet(tweet.id);
       logger6.log(`Retweeted tweet ${tweet.id}`);
     } catch (error) {
@@ -7605,6 +7679,10 @@ ${tweet.text}`;
       });
       const responseObject = parseKeyValueXml(quoteResponse);
       if (responseObject.post) {
+        if (this.isDryRun) {
+          logger6.log(`[DRY RUN] Would have quoted tweet ${tweet.id} with: ${responseObject.post}`);
+          return;
+        }
         const result = await this.client.requestQueue.add(
           async () => await this.twitterClient.sendQuoteTweet(
             responseObject.post,
@@ -7652,6 +7730,10 @@ ${tweet.text}`;
       });
       const responseObject = parseKeyValueXml(replyResponse);
       if (responseObject.post) {
+        if (this.isDryRun) {
+          logger6.log(`[DRY RUN] Would have replied to tweet ${tweet.id} with: ${responseObject.post}`);
+          return;
+        }
         const tweetResult = await sendTweet(
           this.client,
           responseObject.post,
@@ -7679,6 +7761,10 @@ ${tweet.text}`;
       logger6.error("Error in quote tweet generation:", error);
     }
   }
+  async stop() {
+    logger6.info("Stopping Twitter timeline client...");
+    this.isRunning = false;
+  }
 };
 
 // src/tests.ts
@@ -7785,7 +7871,7 @@ var ClientBaseTestSuite = class {
 };
 
 // src/index.ts
-console.log(`Twitter plugin loaded with service name: ${TWITTER_SERVICE_NAME}`);
+logger7.info(`Twitter plugin loaded with service name: ${TWITTER_SERVICE_NAME}`);
 var TwitterClientInstance = class {
   constructor(runtime, state) {
     this.client = new ClientBase(runtime, state);
@@ -7844,13 +7930,13 @@ var _TwitterService = class _TwitterService extends Service {
       const client = new TwitterClientInstance(runtime, state);
       await client.client.init();
       if (client.post) {
-        client.post.start();
+        await client.post.start();
       }
       if (client.interaction) {
-        client.interaction.start();
+        await client.interaction.start();
       }
       if (client.timeline) {
-        client.timeline.start();
+        await client.timeline.start();
       }
       this.clients.set(this.getClientKey(clientId, runtime.agentId), client);
       await this.emitServerJoinedEvent(runtime, client);
@@ -7957,7 +8043,15 @@ var _TwitterService = class _TwitterService extends Service {
     const client = this.clients.get(key);
     if (client) {
       try {
-        await client.service.stop();
+        if (client.post) {
+          await client.post.stop();
+        }
+        if (client.interaction) {
+          await client.interaction.stop();
+        }
+        if (client.timeline) {
+          await client.timeline.stop();
+        }
         this.clients.delete(key);
         logger7.info(`Stopped Twitter client for ${clientId}`);
       } catch (error) {
@@ -7997,7 +8091,15 @@ var _TwitterService = class _TwitterService extends Service {
   async stopAllClients() {
     for (const [key, client] of this.clients.entries()) {
       try {
-        await client.service.stop();
+        if (client.post) {
+          await client.post.stop();
+        }
+        if (client.interaction) {
+          await client.interaction.stop();
+        }
+        if (client.timeline) {
+          await client.timeline.stop();
+        }
         this.clients.delete(key);
       } catch (error) {
         logger7.error(`Error stopping Twitter client ${key}:`, error);