@elizaos/plugin-twitter 1.0.0-beta.32 → 1.0.0-beta.34

package/dist/index.js

@@ -6611,8 +6611,52 @@ import {
   ModelType as ModelType2,
   composePrompt,
   createUniqueUuid as createUniqueUuid2,
-  logger as logger3
+  logger as logger3,
+  truncateToCompleteSentence
 } from "@elizaos/core";
+
+// src/constants.ts
+var TWITTER_SERVICE_NAME = "twitter";
+var TWEET_CHAR_LIMIT = 280;
+
+// src/utils.ts
+async function handleNoteTweet(client, content, tweetId, mediaData) {
+  try {
+    const noteTweetResult = await client.requestQueue.add(
+      async () => await client.twitterClient.sendNoteTweet(content, tweetId, mediaData)
+    );
+    if (noteTweetResult.errors && noteTweetResult.errors.length > 0) {
+      const truncateContent = truncateToCompleteSentence(content, TWEET_CHAR_LIMIT - 1);
+      return await this.sendStandardTweet(client, truncateContent, tweetId);
+    }
+    return noteTweetResult.data.notetweet_create.tweet_results.result;
+  } catch (error) {
+    throw new Error(`Note Tweet failed: ${error}`);
+  }
+}
+async function sendStandardTweet(client, content, tweetId, mediaData) {
+  try {
+    const standardTweetResult = await client.requestQueue.add(
+      async () => await client.twitterClient.sendTweet(content, tweetId, mediaData)
+    );
+    const body = await standardTweetResult.json();
+    if (!body?.data?.create_tweet?.tweet_results?.result) {
+      logger3.error("Error sending tweet; Bad response:", body);
+      return;
+    }
+    return body.data.create_tweet.tweet_results.result;
+  } catch (error) {
+    logger3.error("Error sending standard Tweet:", error);
+    throw error;
+  }
+}
+async function sendTweet(client, text, mediaData = [], tweetToReplyTo) {
+  if (text.length > TWEET_CHAR_LIMIT - 1) {
+    return await handleNoteTweet(client, text, tweetToReplyTo, mediaData);
+  } else {
+    return await sendStandardTweet(client, text, tweetToReplyTo, mediaData);
+  }
+}
 async function generateFiller(runtime, fillerType) {
   try {
     const prompt = composePrompt({
@@ -7825,9 +7869,6 @@ var _ClientBase = class _ClientBase {
 _ClientBase._twitterClients = {};
 var ClientBase = _ClientBase;
 
-// src/constants.ts
-var TWITTER_SERVICE_NAME = "twitter";
-
 // src/interactions.ts
 import {
   ChannelType as ChannelType5,
@@ -8178,14 +8219,7 @@ var TwitterInteractionClient = class {
           return [];
         }
         logger7.info(`Replying to tweet ${tweetToReplyTo}`);
-        const replyTweetResult = await this.client.requestQueue.add(
-          () => this.client.twitterClient.sendTweet(response.text.substring(0, 280), tweetToReplyTo)
-        );
-        if (!replyTweetResult) {
-          throw new Error("Failed to create tweet response");
-        }
-        const responseBody = await replyTweetResult.json();
-        const tweetResult = responseBody?.data?.create_tweet?.tweet_results?.result;
+        const tweetResult = await sendTweet(this.client, response.text, [], tweetToReplyTo);
         if (!tweetResult) {
           throw new Error("Failed to get tweet result from response");
         }
@@ -8325,8 +8359,7 @@ import {
   EventType as EventType3,
   createUniqueUuid as createUniqueUuid6,
   logger as logger8,
-  parseBooleanFromText,
-  truncateToCompleteSentence
+  parseBooleanFromText
 } from "@elizaos/core";
 var TwitterPostClient = class {
   /**
@@ -8351,7 +8384,7 @@ var TwitterPostClient = class {
     );
     logger8.log(`- Auto-post: ${this.state.isTwitterEnabled ? "enabled" : "disabled"}`);
     logger8.log(
-      `- Post Interval: ${this.state?.TWITTER_POST_INTERVAL_MIN || this.runtime.getSetting("TWITTER_POST_INTERVAL_MIN")}-${this.state?.TWITTER_POST_INTERVAL_MAX || this.runtime.getSetting("TWITTER_POST_INTERVAL_MAX")} minutes`
+      `- Post Interval: ${this.state?.TWITTER_POST_INTERVAL_MIN || this.runtime.getSetting("TWITTER_POST_INTERVAL_MIN") || 90}-${this.state?.TWITTER_POST_INTERVAL_MAX || this.runtime.getSetting("TWITTER_POST_INTERVAL_MAX") || 180} minutes`
     );
     logger8.log(
       `- Post Immediately: ${this.state?.TWITTER_POST_IMMEDIATELY || this.runtime.getSetting("TWITTER_POST_IMMEDIATELY") ? "enabled" : "disabled"}`
@@ -8371,159 +8404,17 @@ var TwitterPostClient = class {
       return;
     }
     const generateNewTweetLoop = async () => {
-      const interval = (this.state?.TWITTER_POST_INTERVAL || this.runtime.getSetting("TWITTER_POST_INTERVAL") || 30) * 60 * 1e3;
-      this.generateNewTweet();
+      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);
     };
     setTimeout(generateNewTweetLoop, 60 * 1e3);
-    if (this.runtime.getSetting("TWITTER_POST_IMMEDIATELY")) {
+    if (this.state?.TWITTER_POST_IMMEDIATELY || this.runtime.getSetting("TWITTER_POST_IMMEDIATELY")) {
       await new Promise((resolve) => setTimeout(resolve, 1e3));
-      this.generateNewTweet();
-    }
-  }
-  /**
-   * Creates a Tweet object based on the tweet result, client information, and Twitter username.
-   *
-   * @param {any} tweetResult - The result object from the Twitter API representing a tweet.
-   * @param {any} client - The client object containing profile information.
-   * @param {string} twitterUsername - The Twitter username of the user.
-   * @returns {Tweet} A Tweet object with specific properties extracted from the tweet result and client information.
-   */
-  createTweetObject(tweetResult, client, twitterUsername) {
-    return {
-      id: tweetResult.rest_id,
-      name: client.profile.screenName,
-      username: client.profile.username,
-      text: tweetResult.legacy.full_text,
-      conversationId: tweetResult.legacy.conversation_id_str,
-      createdAt: tweetResult.legacy.created_at,
-      timestamp: new Date(tweetResult.legacy.created_at).getTime(),
-      userId: client.profile.id,
-      inReplyToStatusId: tweetResult.legacy.in_reply_to_status_id_str,
-      permanentUrl: `https://twitter.com/${twitterUsername}/status/${tweetResult.rest_id}`,
-      hashtags: [],
-      mentions: [],
-      photos: [],
-      thread: [],
-      urls: [],
-      videos: []
-    };
-  }
-  /**
-   * Processes and caches a tweet.
-   *
-   * @param {IAgentRuntime} runtime - The agent runtime.
-   * @param {ClientBase} client - The client object.
-   * @param {Tweet} tweet - The tweet to be processed and cached.
-   * @param {UUID} roomId - The ID of the room where the tweet will be stored.
-   * @param {string} rawTweetContent - The raw content of the tweet.
-   */
-  async processAndCacheTweet(runtime, client, tweet, roomId, rawTweetContent) {
-    await runtime.setCache(`twitter/${client.profile.username}/lastPost`, {
-      id: tweet.id,
-      timestamp: Date.now()
-    });
-    await client.cacheTweet(tweet);
-    logger8.log(`Tweet posted:
- ${tweet.permanentUrl}`);
-    await runtime.ensureRoomExists({
-      id: roomId,
-      name: "Twitter Feed",
-      source: "twitter",
-      type: ChannelType6.FEED
-    });
-    await runtime.ensureParticipantInRoom(runtime.agentId, roomId);
-    await runtime.createMemory(
-      {
-        id: createUniqueUuid6(this.runtime, tweet.id),
-        entityId: runtime.agentId,
-        agentId: runtime.agentId,
-        content: {
-          text: rawTweetContent.trim(),
-          url: tweet.permanentUrl,
-          source: "twitter"
-        },
-        roomId,
-        createdAt: tweet.timestamp
-      },
-      "messages"
-    );
-  }
-  /**
-   * Handles sending a note tweet with optional media data.
-   *
-   * @param {ClientBase} client - The client object used for sending the note tweet.
-   * @param {string} content - The content of the note tweet.
-   * @param {string} [tweetId] - Optional Tweet ID to reply to.
-   * @param {MediaData[]} [mediaData] - Optional media data to attach to the note tweet.
-   * @returns {Promise<Object>} - The result of the note tweet operation.
-   * @throws {Error} - If the note tweet operation fails.
-   */
-  async handleNoteTweet(client, content, tweetId, mediaData) {
-    try {
-      const noteTweetResult = await client.requestQueue.add(
-        async () => await client.twitterClient.sendNoteTweet(content, tweetId, mediaData)
-      );
-      if (noteTweetResult.errors && noteTweetResult.errors.length > 0) {
-        const truncateContent = truncateToCompleteSentence(content, 280 - 1);
-        return await this.sendStandardTweet(client, truncateContent, tweetId);
-      }
-      return noteTweetResult.data.notetweet_create.tweet_results.result;
-    } catch (error) {
-      throw new Error(`Note Tweet failed: ${error}`);
-    }
-  }
-  /**
-   * Asynchronously sends a standard tweet using the provided Twitter client.
-   *
-   * @param {ClientBase} client - The client used to make the request.
-   * @param {string} content - The content of the tweet.
-   * @param {string} [tweetId] - Optional tweet ID to reply to.
-   * @param {MediaData[]} [mediaData] - Optional array of media data to attach to the tweet.
-   * @returns {Promise<string>} The result of sending the tweet.
-   */
-  async sendStandardTweet(client, content, tweetId, mediaData) {
-    try {
-      const standardTweetResult = await client.requestQueue.add(
-        async () => await client.twitterClient.sendTweet(content, tweetId, mediaData)
-      );
-      const body = await standardTweetResult.json();
-      if (!body?.data?.create_tweet?.tweet_results?.result) {
-        logger8.error("Error sending tweet; Bad response:", body);
-        return;
-      }
-      return body.data.create_tweet.tweet_results.result;
-    } catch (error) {
-      logger8.error("Error sending standard Tweet:", error);
-      throw error;
-    }
-  }
-  /**
-   * Posts a new tweet with the provided tweet content and optional media data.
-   *
-   * @param {IAgentRuntime} runtime - The runtime environment for the agent.
-   * @param {ClientBase} client - The Twitter client used to post the tweet.
-   * @param {string} tweetTextForPosting - The text content of the tweet.
-   * @param {UUID} roomId - The ID of the room where the tweet will be posted.
-   * @param {string} rawTweetContent - The raw content of the tweet.
-   * @param {string} twitterUsername - The username associated with the Twitter account.
-   * @param {MediaData[]} [mediaData] - Optional media data to be included in the tweet.
-   * @returns {Promise<void>} - A Promise that resolves when the tweet is successfully posted.
-   */
-  async postTweet(runtime, client, tweetTextForPosting, roomId, rawTweetContent, twitterUsername, mediaData) {
-    try {
-      logger8.log("Posting new tweet:\n");
-      let result;
-      if (tweetTextForPosting.length > 280 - 1) {
-        result = await this.handleNoteTweet(client, tweetTextForPosting, void 0, mediaData);
-      } else {
-        result = await this.sendStandardTweet(client, tweetTextForPosting, void 0, mediaData);
-      }
-      const tweet = this.createTweetObject(result, client, twitterUsername);
-      await this.processAndCacheTweet(runtime, client, tweet, roomId, rawTweetContent);
-    } catch (error) {
-      logger8.error("Error sending tweet:");
-      throw error;
+      await this.generateNewTweet();
     }
   }
   /**
@@ -8623,15 +8514,12 @@ var TwitterPostClient = class {
           }
         }
       }
-      const result = await this.client.requestQueue.add(
-        () => this.client.twitterClient.sendTweet(text.substring(0, 280))
-      );
-      const body = await result.json();
-      if (!body?.data?.create_tweet?.tweet_results?.result) {
-        logger8.error("Error sending tweet; Bad response:", body);
+      const result = await sendTweet(this.client, text, mediaData);
+      if (!result) {
+        logger8.error("Error sending tweet; Bad response:");
         return null;
       }
-      return body.data.create_tweet.tweet_results.result;
+      return result;
     } catch (error) {
       logger8.error("Error posting to Twitter:", error);
       throw error;