@elizaos/plugin-twitter 1.2.12 → 1.2.14

package/dist/index.js

@@ -6460,6 +6460,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,
@@ -6617,6 +6626,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,
@@ -6894,6 +6912,7 @@ Response (YES/NO):`;
 
 // src/post.ts
 import {
+  ChannelType as ChannelType2,
   createUniqueUuid as createUniqueUuid3,
   logger as logger4,
   ModelType as ModelType2
@@ -6944,9 +6963,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));
@@ -6987,6 +7011,13 @@ 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}
@@ -7077,7 +7108,40 @@ Generate a single tweet that sounds like YOU would actually write it:`;
       logger4.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");
+        logger4.info("Tweet posted and saved to memory successfully");
       }
     } catch (error) {
       logger4.error("Error generating tweet:", error);
@@ -7365,6 +7429,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,
@@ -8108,43 +8181,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"
-    );
+    logger6.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"
-    );
+    logger6.debug(`[Discovery] Would save follow memory for @${user.username}`);
+    return;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -8856,9 +8898,23 @@ 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
+    });
+    if (message.content?.type === "post" && !message.content?.text) {
+      logger9.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);
       return false;
     }
     if (text.length > 280) {