@elizaos/plugin-twitter 1.2.19 → 1.2.21

package/dist/index.js

@@ -5,18 +5,18 @@ var __export = (target, all) => {
 };
 
 // src/index.ts
-import { logger as logger11 } from "@elizaos/core";
+import { logger as logger12 } from "@elizaos/core";
 
 // src/services/twitter.service.ts
-import { Service, logger as logger9 } from "@elizaos/core";
+import { Service, logger as logger10 } from "@elizaos/core";
 
 // src/interactions.ts
 import {
-  ChannelType,
+  ChannelType as ChannelType2,
   EventType,
   ModelType,
-  createUniqueUuid as createUniqueUuid2,
-  logger as logger4
+  createUniqueUuid as createUniqueUuid3,
+  logger as logger5
 } from "@elizaos/core";
 
 // src/client/auth.ts
@@ -6105,8 +6105,6 @@ var twitterEnvSchema = external_exports.object({
   // Advanced
   TWITTER_RETRY_LIMIT: external_exports.string().default("5")
 });
-delete process.env.TWITTER_SEARCH_ENABLE;
-delete process.env.TWITTER_POST_ENABLE;
 function safeParseInt(value, defaultValue) {
   if (!value) return defaultValue;
   const parsed = parseInt(value, 10);
@@ -6301,6 +6299,142 @@ function getEpochMs(ts) {
   return ts;
 }
 
+// src/utils/memory.ts
+import {
+  ChannelType,
+  createUniqueUuid as createUniqueUuid2,
+  logger as logger4
+} from "@elizaos/core";
+async function ensureTwitterContext(runtime, options) {
+  const {
+    userId,
+    username,
+    name = username,
+    conversationId = userId
+  } = options;
+  const worldId = createUniqueUuid2(runtime, userId);
+  const roomId = createUniqueUuid2(runtime, conversationId);
+  const entityId = createUniqueUuid2(runtime, userId);
+  try {
+    await runtime.ensureWorldExists({
+      id: worldId,
+      name: `${username}'s Twitter`,
+      agentId: runtime.agentId,
+      serverId: userId,
+      metadata: {
+        ownership: { ownerId: userId },
+        twitter: {
+          username,
+          id: userId
+        }
+      }
+    });
+    await runtime.ensureRoomExists({
+      id: roomId,
+      name: `Twitter conversation ${conversationId}`,
+      source: "twitter",
+      type: ChannelType.FEED,
+      channelId: conversationId,
+      serverId: userId,
+      worldId
+    });
+    await runtime.ensureConnection({
+      entityId,
+      roomId,
+      userName: username,
+      name,
+      source: "twitter",
+      type: ChannelType.FEED,
+      worldId
+    });
+    return {
+      worldId,
+      roomId,
+      entityId
+    };
+  } catch (error) {
+    logger4.error("Failed to ensure Twitter context:", error);
+    throw new Error(`Failed to create Twitter context for user ${username}: ${error.message}`);
+  }
+}
+async function createMemorySafe(runtime, memory, tableName = "messages", maxRetries = 3) {
+  let lastError = null;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      await runtime.createMemory(memory, tableName);
+      return;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      logger4.warn(`Failed to create memory (attempt ${attempt + 1}/${maxRetries}):`, error);
+      if (error.message?.includes("duplicate") || error.message?.includes("constraint")) {
+        logger4.debug("Memory already exists, skipping");
+        return;
+      }
+      if (attempt < maxRetries - 1) {
+        await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempt) * 1e3));
+      }
+    }
+  }
+  logger4.error(`Failed to create memory after ${maxRetries} attempts:`, lastError);
+  throw lastError;
+}
+async function isTweetProcessed(runtime, tweetId) {
+  try {
+    const memoryId = createUniqueUuid2(runtime, tweetId);
+    const memory = await runtime.getMemoryById(memoryId);
+    return !!memory;
+  } catch (error) {
+    logger4.debug(`Error checking if tweet ${tweetId} is processed:`, error);
+    return false;
+  }
+}
+async function getRecentTweets(runtime, username, count = 10) {
+  try {
+    const cacheKey = `twitter/${username}/recentTweets`;
+    const cached = await runtime.getCache(cacheKey);
+    if (cached && Array.isArray(cached)) {
+      return cached;
+    }
+    return [];
+  } catch (error) {
+    logger4.debug("Error getting recent tweets from cache:", error);
+    return [];
+  }
+}
+async function addToRecentTweets(runtime, username, tweetText, maxRecent = 10) {
+  try {
+    const cacheKey = `twitter/${username}/recentTweets`;
+    const recent = await getRecentTweets(runtime, username, maxRecent);
+    recent.unshift(tweetText);
+    const trimmed = recent.slice(0, maxRecent);
+    await runtime.setCache(cacheKey, trimmed);
+  } catch (error) {
+    logger4.debug("Error updating recent tweets cache:", error);
+  }
+}
+async function isDuplicateTweet(runtime, username, tweetText, similarityThreshold = 0.9) {
+  try {
+    const recentTweets = await getRecentTweets(runtime, username);
+    if (recentTweets.includes(tweetText)) {
+      return true;
+    }
+    const normalizedNew = tweetText.toLowerCase().trim();
+    for (const recent of recentTweets) {
+      const normalizedRecent = recent.toLowerCase().trim();
+      if (normalizedNew === normalizedRecent) {
+        return true;
+      }
+      if (normalizedNew.includes(normalizedRecent) || normalizedRecent.includes(normalizedNew)) {
+        return true;
+      }
+    }
+    return false;
+  } catch (error) {
+    logger4.debug("Error checking for duplicate tweets:", error);
+    return false;
+  }
+}
+
 // src/interactions.ts
 var TwitterInteractionClient = class {
   /**
@@ -6327,12 +6461,12 @@ var TwitterInteractionClient = class {
     this.isRunning = true;
     const handleTwitterInteractionsLoop = () => {
       if (!this.isRunning) {
-        logger4.info("Twitter interaction client stopped, exiting loop");
+        logger5.info("Twitter interaction client stopped, exiting loop");
         return;
       }
       const engagementIntervalMinutes = getRandomInterval(this.runtime, "engagement");
       const interactionInterval = engagementIntervalMinutes * 60 * 1e3;
-      logger4.info(
+      logger5.info(
         `Twitter interaction client will check in ${engagementIntervalMinutes.toFixed(1)} minutes`
       );
       this.handleTwitterInteractions();
@@ -6346,14 +6480,14 @@ var TwitterInteractionClient = class {
    * Stops the Twitter interaction client
    */
   async stop() {
-    logger4.log("Stopping Twitter interaction client...");
+    logger5.log("Stopping Twitter interaction client...");
     this.isRunning = false;
   }
   /**
    * Asynchronously handles Twitter interactions by checking for mentions and target user posts.
    */
   async handleTwitterInteractions() {
-    logger4.log("Checking Twitter interactions");
+    logger5.log("Checking Twitter interactions");
     const twitterUsername = this.client.profile?.username;
     try {
       const repliesEnabled = (getSetting(this.runtime, "TWITTER_ENABLE_REPLIES") ?? process.env.TWITTER_ENABLE_REPLIES) !== "false";
@@ -6365,9 +6499,9 @@ var TwitterInteractionClient = class {
         await this.handleTargetUserPosts(targetUsersConfig);
       }
       await this.client.cacheLatestCheckedTweetId();
-      logger4.log("Finished checking Twitter interactions");
+      logger5.log("Finished checking Twitter interactions");
     } catch (error) {
-      logger4.error("Error handling Twitter interactions:", error);
+      logger5.error("Error handling Twitter interactions:", error);
     }
   }
   /**
@@ -6391,7 +6525,7 @@ var TwitterInteractionClient = class {
       }
       await this.processMentionTweets(mentionCandidates);
     } catch (error) {
-      logger4.error("Error handling mentions:", error);
+      logger5.error("Error handling mentions:", error);
     }
   }
   /**
@@ -6403,7 +6537,7 @@ var TwitterInteractionClient = class {
       if (targetUsers.length === 0 && !targetUsersConfig.includes("*")) {
         return;
       }
-      logger4.info(
+      logger5.info(
         `Checking posts from target users: ${targetUsers.join(", ") || "everyone (*)"}`
       );
       for (const targetUser of targetUsers) {
@@ -6417,7 +6551,7 @@ var TwitterInteractionClient = class {
             1 /* Latest */
           );
           if (searchResult.tweets.length > 0) {
-            logger4.info(
+            logger5.info(
               `Found ${searchResult.tweets.length} posts from @${normalizedUsername}`
             );
             await this.processTargetUserTweets(
@@ -6426,14 +6560,14 @@ var TwitterInteractionClient = class {
             );
           }
         } catch (error) {
-          logger4.error(`Error searching posts from @${targetUser}:`, error);
+          logger5.error(`Error searching posts from @${targetUser}:`, error);
         }
       }
       if (targetUsersConfig.includes("*")) {
         await this.processTimelineForEngagement();
       }
     } catch (error) {
-      logger4.error("Error handling target user posts:", error);
+      logger5.error("Error handling target user posts:", error);
     }
   }
   /**
@@ -6446,12 +6580,11 @@ var TwitterInteractionClient = class {
     let engagementCount = 0;
     for (const tweet of tweets) {
       if (engagementCount >= maxEngagementsPerRun) {
-        logger4.info(`Reached max engagements limit (${maxEngagementsPerRun})`);
+        logger5.info(`Reached max engagements limit (${maxEngagementsPerRun})`);
         break;
       }
-      const tweetId = createUniqueUuid2(this.runtime, tweet.id);
-      const existingMemory = await this.runtime.getMemoryById(tweetId);
-      if (existingMemory) {
+      const isProcessed = await isTweetProcessed(this.runtime, tweet.id);
+      if (isProcessed) {
         continue;
       }
       const tweetAge = Date.now() - getEpochMs(tweet.timestamp);
@@ -6461,7 +6594,7 @@ var TwitterInteractionClient = class {
       }
       const shouldEngage = await this.shouldEngageWithTweet(tweet);
       if (shouldEngage) {
-        logger4.info(
+        logger5.info(
           `Engaging with tweet from @${username}: ${tweet.text.substring(0, 50)}...`
         );
         await this.ensureTweetContext(tweet);
@@ -6487,13 +6620,13 @@ var TwitterInteractionClient = class {
         return tweetAge < 12 * 60 * 60 * 1e3;
       });
       if (relevantTweets.length > 0) {
-        logger4.info(
+        logger5.info(
           `Found ${relevantTweets.length} relevant tweets from timeline`
         );
         await this.processTargetUserTweets(relevantTweets, "timeline");
       }
     } catch (error) {
-      logger4.error("Error processing timeline for engagement:", error);
+      logger5.error("Error processing timeline for engagement:", error);
     }
   }
   /**
@@ -6511,10 +6644,10 @@ var TwitterInteractionClient = class {
         }
       };
       const shouldEngageMemory = {
-        id: createUniqueUuid2(this.runtime, `eval-${tweet.id}`),
+        id: createUniqueUuid3(this.runtime, `eval-${tweet.id}`),
         entityId: this.runtime.agentId,
         agentId: this.runtime.agentId,
-        roomId: createUniqueUuid2(this.runtime, tweet.conversationId),
+        roomId: createUniqueUuid3(this.runtime, tweet.conversationId),
         content: {
           text: `Should I engage with this tweet? Tweet: "${tweet.text}" by @${tweet.username}`,
           evaluationContext
@@ -6546,7 +6679,7 @@ Response (YES/NO):`;
       });
       return response.trim().toUpperCase().includes("YES");
     } catch (error) {
-      logger4.error("Error determining engagement:", error);
+      logger5.error("Error determining engagement:", error);
       return false;
     }
   }
@@ -6554,57 +6687,31 @@ Response (YES/NO):`;
    * Ensure tweet context exists (world, room, entity)
    */
   async ensureTweetContext(tweet) {
-    const userId = tweet.userId;
-    const conversationId = tweet.conversationId || tweet.id;
-    const username = tweet.username;
-    const worldId = createUniqueUuid2(this.runtime, userId);
-    await this.runtime.ensureWorldExists({
-      id: worldId,
-      name: `${username}'s Twitter`,
-      agentId: this.runtime.agentId,
-      serverId: userId,
-      metadata: {
-        ownership: { ownerId: userId },
-        twitter: {
-          username,
-          id: userId
-        }
-      }
-    });
-    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,
-      roomId,
-      userName: username,
-      name: tweet.name,
-      source: "twitter",
-      type: ChannelType.FEED,
-      worldId
-    });
-    const tweetMemory = {
-      id: createUniqueUuid2(this.runtime, tweet.id),
-      entityId,
-      content: {
-        text: tweet.text,
-        url: tweet.permanentUrl,
-        source: "twitter",
-        tweet
-      },
-      agentId: this.runtime.agentId,
-      roomId,
-      createdAt: getEpochMs(tweet.timestamp)
-    };
-    await this.runtime.createMemory(tweetMemory, "messages");
+    try {
+      const context = await ensureTwitterContext(this.runtime, {
+        userId: tweet.userId,
+        username: tweet.username,
+        name: tweet.name,
+        conversationId: tweet.conversationId || tweet.id
+      });
+      const tweetMemory = {
+        id: createUniqueUuid3(this.runtime, tweet.id),
+        entityId: context.entityId,
+        content: {
+          text: tweet.text,
+          url: tweet.permanentUrl,
+          source: "twitter",
+          tweet
+        },
+        agentId: this.runtime.agentId,
+        roomId: context.roomId,
+        createdAt: getEpochMs(tweet.timestamp)
+      };
+      await createMemorySafe(this.runtime, tweetMemory, "messages");
+    } catch (error) {
+      logger5.error(`Failed to ensure context for tweet ${tweet.id}:`, error);
+      throw error;
+    }
   }
   /**
    * Engage with a tweet by generating and sending a reply
@@ -6612,15 +6719,15 @@ Response (YES/NO):`;
   async engageWithTweet(tweet) {
     try {
       const message = {
-        id: createUniqueUuid2(this.runtime, tweet.id),
-        entityId: createUniqueUuid2(this.runtime, tweet.userId),
+        id: createUniqueUuid3(this.runtime, tweet.id),
+        entityId: createUniqueUuid3(this.runtime, tweet.userId),
         content: {
           text: tweet.text,
           source: "twitter",
           tweet
         },
         agentId: this.runtime.agentId,
-        roomId: createUniqueUuid2(this.runtime, tweet.conversationId),
+        roomId: createUniqueUuid3(this.runtime, tweet.conversationId),
         createdAt: getEpochMs(tweet.timestamp)
       };
       const result = await this.handleTweet({
@@ -6630,7 +6737,7 @@ Response (YES/NO):`;
       });
       return result.text && result.text.length > 0;
     } catch (error) {
-      logger4.error("Error engaging with tweet:", error);
+      logger5.error("Error engaging with tweet:", error);
       return false;
     }
   }
@@ -6645,7 +6752,7 @@ Response (YES/NO):`;
    * Note: MENTION_RECEIVED is currently disabled (see TODO below)
    */
   async processMentionTweets(mentionCandidates) {
-    logger4.log(
+    logger5.log(
       "Completed checking mentioned tweets:",
       mentionCandidates.length
     );
@@ -6659,7 +6766,7 @@ Response (YES/NO):`;
           targetUsersConfig
         );
         if (!shouldTarget) {
-          logger4.log(
+          logger5.log(
             `Skipping tweet from @${tweet.username} - not in target users list`
           );
         }
@@ -6673,18 +6780,18 @@ Response (YES/NO):`;
       0,
       maxInteractionsPerRun
     );
-    logger4.info(
+    logger5.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);
+        const tweetId = createUniqueUuid3(this.runtime, tweet.id);
         const existingResponse = await this.runtime.getMemoryById(tweetId);
         if (existingResponse) {
-          logger4.log(`Already responded to tweet ${tweet.id}, skipping`);
+          logger5.log(`Already responded to tweet ${tweet.id}, skipping`);
           continue;
         }
-        const conversationRoomId = createUniqueUuid2(
+        const conversationRoomId = createUniqueUuid3(
           this.runtime,
           tweet.conversationId
         );
@@ -6698,23 +6805,23 @@ Response (YES/NO):`;
           (memory2) => memory2.content.inReplyTo === tweetId || memory2.content.inReplyTo === tweet.id
         );
         if (hasExistingReply) {
-          logger4.log(
+          logger5.log(
             `Already responded to tweet ${tweet.id} (found in conversation history), skipping`
           );
           continue;
         }
-        logger4.log("New Tweet found", tweet.id);
+        logger5.log("New Tweet found", tweet.id);
         const userId = tweet.userId;
         const conversationId = tweet.conversationId || tweet.id;
-        const roomId = createUniqueUuid2(this.runtime, conversationId);
+        const roomId = createUniqueUuid3(this.runtime, conversationId);
         const username = tweet.username;
-        logger4.log("----");
-        logger4.log(`User: ${username} (${userId})`);
-        logger4.log(`Tweet: ${tweet.id}`);
-        logger4.log(`Conversation: ${conversationId}`);
-        logger4.log(`Room: ${roomId}`);
-        logger4.log("----");
-        const worldId = createUniqueUuid2(this.runtime, userId);
+        logger5.log("----");
+        logger5.log(`User: ${username} (${userId})`);
+        logger5.log(`Tweet: ${tweet.id}`);
+        logger5.log(`Conversation: ${conversationId}`);
+        logger5.log(`Room: ${roomId}`);
+        logger5.log("----");
+        const worldId = createUniqueUuid3(this.runtime, userId);
         await this.runtime.ensureWorldExists({
           id: worldId,
           name: `${username}'s Twitter`,
@@ -6728,21 +6835,21 @@ Response (YES/NO):`;
             }
           }
         });
-        const entityId = createUniqueUuid2(this.runtime, userId);
+        const entityId = createUniqueUuid3(this.runtime, userId);
         await this.runtime.ensureConnection({
           entityId,
           roomId,
           userName: username,
           name: tweet.name,
           source: "twitter",
-          type: ChannelType.FEED,
+          type: ChannelType2.FEED,
           worldId
         });
         await this.runtime.ensureRoomExists({
           id: roomId,
           name: `Twitter conversation ${conversationId}`,
           source: "twitter",
-          type: ChannelType.FEED,
+          type: ChannelType2.FEED,
           channelId: conversationId,
           serverId: userId,
           worldId
@@ -6760,11 +6867,11 @@ Response (YES/NO):`;
           roomId,
           createdAt: getEpochMs(tweet.timestamp)
         };
-        logger4.log("Saving tweet memory...");
-        await this.runtime.createMemory(memory, "messages");
+        logger5.log("Saving tweet memory...");
+        await createMemorySafe(this.runtime, memory, "messages");
         if (tweet.thread && tweet.thread.length > 0) {
           const threadStartId = tweet.thread[0].id;
-          const threadMemoryId = createUniqueUuid2(
+          const threadMemoryId = createUniqueUuid3(
             this.runtime,
             `thread-${threadStartId}`
           );
@@ -6815,15 +6922,15 @@ Response (YES/NO):`;
         interaction.userId,
         interaction.targetTweet.conversationId
       );
-      await this.runtime.createMemory(memory, "messages");
+      await createMemorySafe(this.runtime, memory, "messages");
       const reactionMessage = {
-        id: createUniqueUuid2(this.runtime, interaction.targetTweetId),
+        id: createUniqueUuid3(this.runtime, interaction.targetTweetId),
         content: {
           text: interaction.targetTweet.text,
           source: "twitter"
         },
-        entityId: createUniqueUuid2(this.runtime, interaction.userId),
-        roomId: createUniqueUuid2(
+        entityId: createUniqueUuid3(this.runtime, interaction.userId),
+        roomId: createUniqueUuid3(
           this.runtime,
           interaction.targetTweet.conversationId
         ),
@@ -6874,7 +6981,7 @@ Response (YES/NO):`;
             callback: async () => [],
             reaction: {
               type: "quote",
-              entityId: createUniqueUuid2(this.runtime, interaction.userId)
+              entityId: createUniqueUuid3(this.runtime, interaction.userId)
             },
             source: "twitter"
           };
@@ -6884,12 +6991,12 @@ Response (YES/NO):`;
       }
       this.runtime.emitEvent(EventType.REACTION_RECEIVED, {
         runtime: this.runtime,
-        entityId: createUniqueUuid2(this.runtime, interaction.userId),
-        roomId: createUniqueUuid2(
+        entityId: createUniqueUuid3(this.runtime, interaction.userId),
+        roomId: createUniqueUuid3(
           this.runtime,
           interaction.targetTweet.conversationId
         ),
-        world: createUniqueUuid2(this.runtime, interaction.userId),
+        world: createUniqueUuid3(this.runtime, interaction.userId),
         message: reactionMessage,
         source: "twitter",
         metadata: {
@@ -6915,10 +7022,10 @@ Response (YES/NO):`;
    */
   createMemoryObject(type, id, userId, conversationId) {
     return {
-      id: createUniqueUuid2(this.runtime, id),
+      id: createUniqueUuid3(this.runtime, id),
       agentId: this.runtime.agentId,
-      entityId: createUniqueUuid2(this.runtime, userId),
-      roomId: createUniqueUuid2(this.runtime, conversationId),
+      entityId: createUniqueUuid3(this.runtime, userId),
+      roomId: createUniqueUuid3(this.runtime, conversationId),
       content: {
         type,
         source: "twitter"
@@ -6943,23 +7050,23 @@ Response (YES/NO):`;
     thread
   }) {
     if (!message.content.text) {
-      logger4.log("Skipping Tweet with no text", tweet.id);
+      logger5.log("Skipping Tweet with no text", tweet.id);
       return { text: "", actions: ["IGNORE"] };
     }
     const callback = async (response2, tweetId) => {
       try {
         if (!response2.text) {
-          logger4.warn("No text content in response, skipping tweet reply");
+          logger5.warn("No text content in response, skipping tweet reply");
           return [];
         }
         const tweetToReplyTo = tweetId || tweet.id;
         if (this.isDryRun) {
-          logger4.info(
+          logger5.info(
             `[DRY RUN] Would have replied to ${tweet.username} with: ${response2.text}`
           );
           return [];
         }
-        logger4.info(`Replying to tweet ${tweetToReplyTo}`);
+        logger5.info(`Replying to tweet ${tweetToReplyTo}`);
         const tweetResult = await sendTweet(
           this.client,
           response2.text,
@@ -6969,7 +7076,7 @@ Response (YES/NO):`;
         if (!tweetResult) {
           throw new Error("Failed to get tweet result from response");
         }
-        const responseId = createUniqueUuid2(this.runtime, tweetResult.id);
+        const responseId = createUniqueUuid3(this.runtime, tweetResult.id);
         const responseMemory = {
           id: responseId,
           entityId: this.runtime.agentId,
@@ -6982,21 +7089,21 @@ Response (YES/NO):`;
           },
           createdAt: Date.now()
         };
-        await this.runtime.createMemory(responseMemory, "messages");
+        await createMemorySafe(this.runtime, responseMemory, "messages");
         return [responseMemory];
       } catch (error) {
-        logger4.error("Error in tweet reply callback:", error);
+        logger5.error("Error in tweet reply callback:", error);
         return [];
       }
     };
     const twitterUserId = tweet.userId;
-    const entityId = createUniqueUuid2(this.runtime, twitterUserId);
+    const entityId = createUniqueUuid3(this.runtime, twitterUserId);
     const twitterUsername = tweet.username;
     this.runtime.emitEvent(
       ["TWITTER_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, EventType.MESSAGE_RECEIVED],
       {
         runtime: this.runtime,
-        world: createUniqueUuid2(this.runtime, twitterUserId),
+        world: createUniqueUuid3(this.runtime, twitterUserId),
         entityId,
         roomId: message.roomId,
         userId: twitterUserId,
@@ -7024,9 +7131,9 @@ Response (YES/NO):`;
 
 // src/post.ts
 import {
-  ChannelType as ChannelType2,
-  createUniqueUuid as createUniqueUuid3,
-  logger as logger5,
+  ChannelType as ChannelType3,
+  createUniqueUuid as createUniqueUuid4,
+  logger as logger6,
   ModelType as ModelType2
 } from "@elizaos/core";
 var TwitterPostClient = class {
@@ -7045,42 +7152,42 @@ var TwitterPostClient = class {
     this.runtime = runtime;
     const dryRunSetting = this.state?.TWITTER_DRY_RUN ?? getSetting(this.runtime, "TWITTER_DRY_RUN") ?? process.env.TWITTER_DRY_RUN;
     this.isDryRun = dryRunSetting === true || dryRunSetting === "true" || typeof dryRunSetting === "string" && dryRunSetting.toLowerCase() === "true";
-    logger5.log("Twitter Post Client Configuration:");
-    logger5.log(`- Dry Run Mode: ${this.isDryRun ? "Enabled" : "Disabled"}`);
+    logger6.log("Twitter Post Client Configuration:");
+    logger6.log(`- Dry Run Mode: ${this.isDryRun ? "Enabled" : "Disabled"}`);
     const postIntervalMin = parseInt(
       this.state?.TWITTER_POST_INTERVAL_MIN || getSetting(this.runtime, "TWITTER_POST_INTERVAL_MIN") || process.env.TWITTER_POST_INTERVAL_MIN || "90"
     );
     const postIntervalMax = parseInt(
       this.state?.TWITTER_POST_INTERVAL_MAX || getSetting(this.runtime, "TWITTER_POST_INTERVAL_MAX") || process.env.TWITTER_POST_INTERVAL_MAX || "150"
     );
-    logger5.log(`- Post Interval: ${postIntervalMin}-${postIntervalMax} minutes (randomized)`);
+    logger6.log(`- Post Interval: ${postIntervalMin}-${postIntervalMax} minutes (randomized)`);
   }
   /**
    * Stops the Twitter post client
    */
   async stop() {
-    logger5.log("Stopping Twitter post client...");
+    logger6.log("Stopping Twitter post client...");
     this.isRunning = false;
   }
   /**
    * Starts the Twitter post client, setting up a loop to periodically generate new tweets.
    */
   async start() {
-    logger5.log("Starting Twitter post client...");
+    logger6.log("Starting Twitter post client...");
     this.isRunning = true;
     const generateNewTweetLoop = async () => {
       if (!this.isRunning) {
-        logger5.log("Twitter post client stopped, exiting loop");
+        logger6.log("Twitter post client stopped, exiting loop");
         return;
       }
       await this.generateNewTweet();
       if (!this.isRunning) {
-        logger5.log("Twitter post client stopped after tweet, exiting loop");
+        logger6.log("Twitter post client stopped after tweet, exiting loop");
         return;
       }
       const postIntervalMinutes = getRandomInterval(this.runtime, "post");
       const interval = postIntervalMinutes * 60 * 1e3;
-      logger5.info(`Next tweet scheduled in ${postIntervalMinutes.toFixed(1)} minutes`);
+      logger6.info(`Next tweet scheduled in ${postIntervalMinutes.toFixed(1)} minutes`);
       await new Promise((resolve) => setTimeout(resolve, interval));
       if (this.isRunning) {
         generateNewTweetLoop();
@@ -7089,7 +7196,7 @@ var TwitterPostClient = class {
     await new Promise((resolve) => setTimeout(resolve, 5e3));
     const postImmediately = this.state?.TWITTER_POST_IMMEDIATELY || getSetting(this.runtime, "TWITTER_POST_IMMEDIATELY") || process.env.TWITTER_POST_IMMEDIATELY;
     if (postImmediately === "true" || postImmediately === true) {
-      logger5.info(
+      logger6.info(
         "TWITTER_POST_IMMEDIATELY is true, generating initial tweet now"
       );
       let retries = 0;
@@ -7097,7 +7204,7 @@ var TwitterPostClient = class {
         const success = await this.generateNewTweet();
         if (success) break;
         retries++;
-        logger5.info(`Retrying immediate tweet (attempt ${retries}/5)...`);
+        logger6.info(`Retrying immediate tweet (attempt ${retries}/5)...`);
         await new Promise((resolve) => setTimeout(resolve, 3e3));
       }
     }
@@ -7109,24 +7216,24 @@ var TwitterPostClient = class {
    * @returns {Promise<boolean>} true if tweet was posted successfully
    */
   async generateNewTweet() {
-    logger5.info("Attempting to generate new tweet...");
+    logger6.info("Attempting to generate new tweet...");
     if (this.isPosting) {
-      logger5.info("Already posting a tweet, skipping concurrent attempt");
+      logger6.info("Already posting a tweet, skipping concurrent attempt");
       return false;
     }
     this.isPosting = true;
     try {
       const userId = this.client.profile?.id;
       if (!userId) {
-        logger5.error("Cannot generate tweet: Twitter profile not available");
+        logger6.error("Cannot generate tweet: Twitter profile not available");
         this.isPosting = false;
         return false;
       }
-      logger5.info(
+      logger6.info(
         `Generating tweet for user: ${this.client.profile?.username} (${userId})`
       );
-      const worldId = createUniqueUuid3(this.runtime, userId);
-      const roomId = createUniqueUuid3(this.runtime, `${userId}-home`);
+      const worldId = createUniqueUuid4(this.runtime, userId);
+      const roomId = createUniqueUuid4(this.runtime, `${userId}-home`);
       const state = await this.runtime.composeState({
         agentId: this.runtime.agentId,
         entityId: this.runtime.agentId,
@@ -7134,7 +7241,7 @@ var TwitterPostClient = class {
         content: { text: "", type: "post" },
         createdAt: Date.now()
       }).catch((error) => {
-        logger5.warn("Error composing state, using minimal state:", error);
+        logger6.warn("Error composing state, using minimal state:", error);
         return {
           agentId: this.runtime.agentId,
           recentMemories: [],
@@ -7155,7 +7262,7 @@ ${this.runtime.character.messageExamples.map(
 
 Style guidelines:
 - Be authentic, opinionated, and specific - no generic platitudes
-- Use your unique voice and perspective  
+- 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
@@ -7182,15 +7289,15 @@ Generate a single tweet that sounds like YOU would actually write it:`;
       );
       const tweetText = generatedContent.trim();
       if (!tweetText || tweetText.length === 0) {
-        logger5.error("Generated empty tweet content");
+        logger6.error("Generated empty tweet content");
         return false;
       }
       if (tweetText.includes("Error: Missing")) {
-        logger5.error("Error in generated content:", tweetText);
+        logger6.error("Error in generated content:", tweetText);
         return false;
       }
       if (tweetText.length > 280) {
-        logger5.warn(`Generated tweet too long (${tweetText.length} chars), truncating...`);
+        logger6.warn(`Generated tweet too long (${tweetText.length} chars), truncating...`);
         const sentences = tweetText.match(/[^.!?]+[.!?]+/g) || [tweetText];
         let truncated = "";
         for (const sentence of sentences) {
@@ -7201,73 +7308,67 @@ Generate a single tweet that sounds like YOU would actually write it:`;
           }
         }
         const finalTweet = truncated.trim() || tweetText.substring(0, 277) + "...";
-        logger5.info(`Truncated tweet: ${finalTweet}`);
+        logger6.info(`Truncated tweet: ${finalTweet}`);
         if (this.isDryRun) {
-          logger5.info(`[DRY RUN] Would post tweet: ${finalTweet}`);
+          logger6.info(`[DRY RUN] Would post tweet: ${finalTweet}`);
           return false;
         }
         const result2 = await this.postToTwitter(finalTweet, []);
         if (result2 === null) {
-          logger5.info("Skipped posting duplicate tweet");
+          logger6.info("Skipped posting duplicate tweet");
           return false;
         }
         const tweetId2 = result2.id;
-        logger5.info(`Tweet posted successfully! ID: ${tweetId2}`);
-        logger5.info("Tweet posted successfully (memory saving disabled due to room constraints)");
+        logger6.info(`Tweet posted successfully! ID: ${tweetId2}`);
+        logger6.info("Tweet posted successfully (memory saving disabled due to room constraints)");
         return true;
       }
-      logger5.info(`Generated tweet: ${tweetText}`);
+      logger6.info(`Generated tweet: ${tweetText}`);
       if (this.isDryRun) {
-        logger5.info(`[DRY RUN] Would post tweet: ${tweetText}`);
+        logger6.info(`[DRY RUN] Would post tweet: ${tweetText}`);
         return false;
       }
       const result = await this.postToTwitter(tweetText, []);
       if (result === null) {
-        logger5.info("Skipped posting duplicate tweet");
+        logger6.info("Skipped posting duplicate tweet");
         return false;
       }
       const tweetId = result.id;
-      logger5.info(`Tweet posted successfully! ID: ${tweetId}`);
+      logger6.info(`Tweet posted successfully! ID: ${tweetId}`);
       if (result) {
-        const postedTweetId = createUniqueUuid3(this.runtime, tweetId);
-        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");
-        logger5.info("Tweet posted and saved to memory successfully");
+        const postedTweetId = createUniqueUuid4(this.runtime, tweetId);
+        try {
+          const context = await ensureTwitterContext(this.runtime, {
+            userId,
+            username: this.client.profile?.username || "unknown",
+            conversationId: `${userId}-home`
+          });
+          const postedMemory = {
+            id: postedTweetId,
+            entityId: this.runtime.agentId,
+            agentId: this.runtime.agentId,
+            roomId: context.roomId,
+            content: {
+              text: tweetText,
+              source: "twitter",
+              channelType: ChannelType3.FEED,
+              type: "post",
+              metadata: {
+                tweetId,
+                postedAt: Date.now()
+              }
+            },
+            createdAt: Date.now()
+          };
+          await createMemorySafe(this.runtime, postedMemory, "messages");
+          logger6.info("Tweet posted and saved to memory successfully");
+        } catch (error) {
+          logger6.error("Failed to save tweet memory:", error);
+        }
         return true;
       }
     } catch (error) {
-      logger5.error("Error generating tweet:", error);
+      logger6.error("Error generating tweet:", error);
       return false;
     } finally {
       this.isPosting = false;
@@ -7281,42 +7382,33 @@ Generate a single tweet that sounds like YOU would actually write it:`;
    */
   async postToTwitter(text, mediaData = []) {
     try {
-      const lastPost = await this.runtime.getCache(
-        `twitter/${this.client.profile?.username}/lastPost`
-      );
-      if (lastPost) {
-        const lastTweet = await this.client.getTweet(lastPost.id);
-        if (lastTweet && lastTweet.text === text) {
-          logger5.warn(
-            "Tweet is a duplicate of the last post. Skipping to avoid duplicate."
-          );
-          return null;
-        }
+      const username = this.client.profile?.username;
+      if (!username) {
+        logger6.error("No profile username available");
+        return null;
+      }
+      const isDuplicate = await isDuplicateTweet(this.runtime, username, text);
+      if (isDuplicate) {
+        logger6.warn("Tweet is a duplicate of a recent post. Skipping to avoid duplicate.");
+        return null;
       }
       const mediaIds = [];
       if (mediaData && mediaData.length > 0) {
         for (const media of mediaData) {
           try {
-            logger5.warn(
+            logger6.warn(
               "Media upload not currently supported with the modern Twitter API"
             );
           } catch (error) {
-            logger5.error("Error uploading media:", error);
+            logger6.error("Error uploading media:", error);
           }
         }
       }
       const result = await sendTweet(this.client, text, mediaData);
-      await this.runtime.setCache(
-        `twitter/${this.client.profile?.username}/lastPost`,
-        {
-          id: result.id,
-          text,
-          timestamp: Date.now()
-        }
-      );
+      await addToRecentTweets(this.runtime, username, text);
       return result;
     } catch (error) {
-      logger5.error("Error posting to Twitter:", error);
+      logger6.error("Error posting to Twitter:", error);
       throw error;
     }
   }
@@ -7324,13 +7416,13 @@ Generate a single tweet that sounds like YOU would actually write it:`;
 
 // src/timeline.ts
 import {
-  ChannelType as ChannelType3,
+  ChannelType as ChannelType4,
   composePromptFromState,
-  createUniqueUuid as createUniqueUuid4,
+  createUniqueUuid as createUniqueUuid5,
   ModelType as ModelType3,
   parseKeyValueXml
 } from "@elizaos/core";
-import { logger as logger6 } from "@elizaos/core";
+import { logger as logger7 } from "@elizaos/core";
 
 // src/templates.ts
 var twitterActionTemplate = `
@@ -7410,18 +7502,18 @@ var TwitterTimelineClient = class {
     this.timelineType = timelineMode === "following" /* Following */ ? "following" /* Following */ : "foryou" /* ForYou */;
   }
   async start() {
-    logger6.info("Starting Twitter timeline client...");
+    logger7.info("Starting Twitter timeline client...");
     this.isRunning = true;
     const handleTwitterTimelineLoop = () => {
       if (!this.isRunning) {
-        logger6.info("Twitter timeline client stopped, exiting loop");
+        logger7.info("Twitter timeline client stopped, exiting loop");
         return;
       }
       const engagementIntervalMinutes = parseInt(
         this.state?.TWITTER_ENGAGEMENT_INTERVAL || getSetting(this.runtime, "TWITTER_ENGAGEMENT_INTERVAL") || process.env.TWITTER_ENGAGEMENT_INTERVAL || "30"
       );
       const actionInterval = engagementIntervalMinutes * 60 * 1e3;
-      logger6.info(
+      logger7.info(
         `Timeline client will check every ${engagementIntervalMinutes} minutes`
       );
       this.handleTimeline();
@@ -7432,7 +7524,7 @@ var TwitterTimelineClient = class {
     handleTwitterTimelineLoop();
   }
   async stop() {
-    logger6.info("Stopping Twitter timeline client...");
+    logger7.info("Stopping Twitter timeline client...");
     this.isRunning = false;
   }
   async getTimeline(count) {
@@ -7441,7 +7533,7 @@ var TwitterTimelineClient = class {
     return homeTimeline.filter((tweet) => tweet.username !== twitterUsername);
   }
   createTweetId(runtime, tweet) {
-    return createUniqueUuid4(runtime, tweet.id);
+    return createUniqueUuid5(runtime, tweet.id);
   }
   formMessage(runtime, tweet) {
     return {
@@ -7451,33 +7543,32 @@ var TwitterTimelineClient = class {
         text: tweet.text,
         url: tweet.permanentUrl,
         imageUrls: tweet.photos?.map((photo) => photo.url) || [],
-        inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid4(runtime, tweet.inReplyToStatusId) : void 0,
+        inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid5(runtime, tweet.inReplyToStatusId) : void 0,
         source: "twitter",
-        channelType: ChannelType3.GROUP,
+        channelType: ChannelType4.GROUP,
         tweet
       },
-      entityId: createUniqueUuid4(runtime, tweet.userId),
-      roomId: createUniqueUuid4(runtime, tweet.conversationId),
+      entityId: createUniqueUuid5(runtime, tweet.userId),
+      roomId: createUniqueUuid5(runtime, tweet.conversationId),
       createdAt: getEpochMs(tweet.timestamp)
     };
   }
   async handleTimeline() {
-    logger6.info("Starting Twitter timeline processing...");
+    logger7.info("Starting Twitter timeline processing...");
     const tweets = await this.getTimeline(20);
-    logger6.info(`Fetched ${tweets.length} tweets from timeline`);
+    logger7.info(`Fetched ${tweets.length} tweets from timeline`);
     const maxActionsPerCycle = parseInt(
       getSetting(this.runtime, "TWITTER_MAX_ENGAGEMENTS_PER_RUN") || process.env.TWITTER_MAX_ENGAGEMENTS_PER_RUN || "10"
     );
     const tweetDecisions = [];
     for (const tweet of tweets) {
       try {
-        const tweetId = this.createTweetId(this.runtime, tweet);
-        const memory = await this.runtime.getMemoryById(tweetId);
-        if (memory) {
-          logger6.log(`Already processed tweet ID: ${tweet.id}`);
+        const isProcessed = await isTweetProcessed(this.runtime, tweet.id);
+        if (isProcessed) {
+          logger7.log(`Already processed tweet ID: ${tweet.id}`);
           continue;
         }
-        const roomId = createUniqueUuid4(this.runtime, tweet.conversationId);
+        const roomId = createUniqueUuid5(this.runtime, tweet.conversationId);
         const message = this.formMessage(this.runtime, tweet);
         let state = await this.runtime.composeState(message);
         const actionRespondPrompt = composePromptFromState({
@@ -7498,7 +7589,7 @@ Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appro
         );
         const parsedResponse = parseActionResponseFromText(actionResponse);
         if (!parsedResponse) {
-          logger6.debug(`No action response generated for tweet ${tweet.id}`);
+          logger7.debug(`No action response generated for tweet ${tweet.id}`);
           continue;
         }
         tweetDecisions.push({
@@ -7509,7 +7600,7 @@ Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appro
         });
         if (tweetDecisions.length >= maxActionsPerCycle) break;
       } catch (error) {
-        logger6.error(`Error processing tweet ${tweet.id}:`, error);
+        logger7.error(`Error processing tweet ${tweet.id}:`, error);
       }
     }
     const rankByActionRelevance = (arr) => {
@@ -7527,7 +7618,7 @@ Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appro
       });
     };
     const prioritizedTweets = rankByActionRelevance(tweetDecisions);
-    logger6.info(`Processing ${prioritizedTweets.length} tweets with actions`);
+    logger7.info(`Processing ${prioritizedTweets.length} tweets with actions`);
     if (prioritizedTweets.length > 0) {
       const actionSummary = prioritizedTweets.map((td) => {
         const actions = [];
@@ -7537,11 +7628,11 @@ Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appro
         if (td.actionResponse.reply) actions.push("REPLY");
         return `Tweet ${td.tweet.id}: ${actions.join(", ")}`;
       });
-      logger6.info(`Actions to execute:
+      logger7.info(`Actions to execute:
 ${actionSummary.join("\n")}`);
     }
     await this.processTimelineActions(prioritizedTweets);
-    logger6.info("Timeline processing complete");
+    logger7.info("Timeline processing complete");
   }
   async processTimelineActions(tweetDecisions) {
     const results = [];
@@ -7557,32 +7648,30 @@ ${actionSummary.join("\n")}`);
         id: roomId,
         name: `Twitter conversation ${tweet.conversationId}`,
         source: "twitter",
-        type: ChannelType3.GROUP,
+        type: ChannelType4.GROUP,
         channelId: tweet.conversationId,
         serverId: tweet.userId,
-        worldId: createUniqueUuid4(this.runtime, tweet.userId)
+        worldId: createUniqueUuid5(this.runtime, tweet.userId)
       });
-      await this.runtime.createMemory(
-        {
-          id: tweetId,
-          entityId: createUniqueUuid4(this.runtime, tweet.userId),
-          content: {
-            text: tweet.text,
-            url: tweet.permanentUrl,
-            source: "twitter",
-            channelType: ChannelType3.GROUP,
-            tweet
-          },
-          agentId: this.runtime.agentId,
-          roomId,
-          createdAt: getEpochMs(tweet.timestamp)
+      const tweetMemory = {
+        id: tweetId,
+        entityId: createUniqueUuid5(this.runtime, tweet.userId),
+        content: {
+          text: tweet.text,
+          url: tweet.permanentUrl,
+          source: "twitter",
+          channelType: ChannelType4.GROUP,
+          tweet
         },
-        "messages"
-      );
+        agentId: this.runtime.agentId,
+        roomId,
+        createdAt: getEpochMs(tweet.timestamp)
+      };
+      await createMemorySafe(this.runtime, tweetMemory, "messages");
       try {
         const userId = tweet.userId;
-        const worldId = createUniqueUuid4(this.runtime, userId);
-        const entityId = createUniqueUuid4(this.runtime, userId);
+        const worldId = createUniqueUuid5(this.runtime, userId);
+        const entityId = createUniqueUuid5(this.runtime, userId);
         await this.ensureTweetWorldContext(tweet, roomId, worldId, entityId);
         if (actionResponse.like) {
           await this.handleLikeAction(tweet);
@@ -7602,69 +7691,45 @@ ${actionSummary.join("\n")}`);
         }
         results.push({ tweetId: tweet.id, actionResponse, executedActions });
       } catch (error) {
-        logger6.error(`Error processing actions for tweet ${tweet.id}:`, error);
+        logger7.error(`Error processing actions for tweet ${tweet.id}:`, error);
       }
     }
     return results;
   }
   async ensureTweetWorldContext(tweet, roomId, worldId, entityId) {
-    await this.runtime.ensureWorldExists({
-      id: worldId,
-      name: `${tweet.name}'s Twitter`,
-      agentId: this.runtime.agentId,
-      serverId: tweet.userId,
-      metadata: {
-        ownership: { ownerId: tweet.userId },
-        twitter: {
-          username: tweet.username,
-          id: tweet.userId,
-          name: tweet.name
-        }
-      }
-    });
-    await this.runtime.ensureConnection({
-      entityId,
-      roomId,
-      userName: tweet.username,
-      name: tweet.name,
-      worldName: `${tweet.name}'s Twitter`,
-      source: "twitter",
-      type: ChannelType3.GROUP,
-      channelId: tweet.conversationId,
-      serverId: tweet.userId,
-      worldId,
-      metadata: {
-        ownership: { ownerId: tweet.userId },
-        twitter: {
-          username: tweet.username,
-          id: tweet.userId,
-          name: tweet.name
-        }
-      }
-    });
+    try {
+      await ensureTwitterContext(this.runtime, {
+        userId: tweet.userId,
+        username: tweet.username,
+        name: tweet.name,
+        conversationId: tweet.conversationId
+      });
+    } catch (error) {
+      logger7.error(`Failed to ensure context for tweet ${tweet.id}:`, error);
+    }
   }
   async handleLikeAction(tweet) {
     try {
       if (this.isDryRun) {
-        logger6.log(`[DRY RUN] Would have liked tweet ${tweet.id}`);
+        logger7.log(`[DRY RUN] Would have liked tweet ${tweet.id}`);
         return;
       }
       await this.twitterClient.likeTweet(tweet.id);
-      logger6.log(`Liked tweet ${tweet.id}`);
+      logger7.log(`Liked tweet ${tweet.id}`);
     } catch (error) {
-      logger6.error(`Error liking tweet ${tweet.id}:`, error);
+      logger7.error(`Error liking tweet ${tweet.id}:`, error);
     }
   }
   async handleRetweetAction(tweet) {
     try {
       if (this.isDryRun) {
-        logger6.log(`[DRY RUN] Would have retweeted tweet ${tweet.id}`);
+        logger7.log(`[DRY RUN] Would have retweeted tweet ${tweet.id}`);
         return;
       }
       await this.twitterClient.retweet(tweet.id);
-      logger6.log(`Retweeted tweet ${tweet.id}`);
+      logger7.log(`Retweeted tweet ${tweet.id}`);
     } catch (error) {
-      logger6.error(`Error retweeting tweet ${tweet.id}:`, error);
+      logger7.error(`Error retweeting tweet ${tweet.id}:`, error);
     }
   }
   async handleQuoteAction(tweet) {
@@ -7683,7 +7748,7 @@ ${tweet.text}`;
       const responseObject = parseKeyValueXml(quoteResponse);
       if (responseObject.post) {
         if (this.isDryRun) {
-          logger6.log(
+          logger7.log(
             `[DRY RUN] Would have quoted tweet ${tweet.id} with: ${responseObject.post}`
           );
           return;
@@ -7697,12 +7762,12 @@ ${tweet.text}`;
         const body = await result.json();
         const tweetResult = body?.data?.create_tweet?.tweet_results?.result || body?.data || body;
         if (tweetResult) {
-          logger6.log("Successfully posted quote tweet");
+          logger7.log("Successfully posted quote tweet");
         } else {
-          logger6.error("Quote tweet creation failed:", body);
+          logger7.error("Quote tweet creation failed:", body);
         }
         const tweetId = tweetResult?.id || Date.now().toString();
-        const responseId = createUniqueUuid4(this.runtime, tweetId);
+        const responseId = createUniqueUuid5(this.runtime, tweetId);
         const responseMemory = {
           id: responseId,
           entityId: this.runtime.agentId,
@@ -7714,10 +7779,10 @@ ${tweet.text}`;
           },
           createdAt: Date.now()
         };
-        await this.runtime.createMemory(responseMemory, "messages");
+        await createMemorySafe(this.runtime, responseMemory, "messages");
       }
     } catch (error) {
-      logger6.error("Error in quote tweet generation:", error);
+      logger7.error("Error in quote tweet generation:", error);
     }
   }
   async handleReplyAction(tweet) {
@@ -7736,7 +7801,7 @@ ${tweet.text}`;
       const responseObject = parseKeyValueXml(replyResponse);
       if (responseObject.post) {
         if (this.isDryRun) {
-          logger6.log(
+          logger7.log(
             `[DRY RUN] Would have replied to tweet ${tweet.id} with: ${responseObject.post}`
           );
           return;
@@ -7748,8 +7813,8 @@ ${tweet.text}`;
           tweet.id
         );
         if (result) {
-          logger6.log("Successfully posted reply tweet");
-          const responseId = createUniqueUuid4(this.runtime, result.id);
+          logger7.log("Successfully posted reply tweet");
+          const responseId = createUniqueUuid5(this.runtime, result.id);
           const responseMemory = {
             id: responseId,
             entityId: this.runtime.agentId,
@@ -7761,19 +7826,19 @@ ${tweet.text}`;
             },
             createdAt: Date.now()
           };
-          await this.runtime.createMemory(responseMemory, "messages");
+          await createMemorySafe(this.runtime, responseMemory, "messages");
         }
       }
     } catch (error) {
-      logger6.error("Error in reply tweet generation:", error);
+      logger7.error("Error in reply tweet generation:", error);
     }
   }
 };
 
 // src/discovery.ts
 import {
-  createUniqueUuid as createUniqueUuid5,
-  logger as logger7,
+  createUniqueUuid as createUniqueUuid6,
+  logger as logger8,
   ModelType as ModelType4
 } from "@elizaos/core";
 var TwitterDiscoveryClient = class {
@@ -7787,7 +7852,7 @@ var TwitterDiscoveryClient = class {
     const dryRunSetting = state?.TWITTER_DRY_RUN ?? getSetting(this.runtime, "TWITTER_DRY_RUN") ?? process.env.TWITTER_DRY_RUN;
     this.isDryRun = dryRunSetting === true || dryRunSetting === "true" || typeof dryRunSetting === "string" && dryRunSetting.toLowerCase() === "true";
     this.config = this.buildDiscoveryConfig();
-    logger7.info("Twitter Discovery Config:", {
+    logger8.info("Twitter Discovery Config:", {
       topics: this.config.topics,
       isDryRun: this.isDryRun,
       minFollowerCount: this.config.minFollowerCount,
@@ -7825,7 +7890,7 @@ var TwitterDiscoveryClient = class {
         topics = this.extractTopicsFromBio(character.bio);
       }
     } else {
-      logger7.warn(
+      logger8.warn(
         "Character not available in runtime, using default topics for discovery"
       );
     }
@@ -7870,21 +7935,21 @@ var TwitterDiscoveryClient = class {
     return [...new Set(words)].slice(0, 5);
   }
   async start() {
-    logger7.info("Starting Twitter Discovery Client...");
+    logger8.info("Starting Twitter Discovery Client...");
     this.isRunning = true;
     const discoveryLoop = async () => {
       if (!this.isRunning) {
-        logger7.info("Discovery client stopped, exiting loop");
+        logger8.info("Discovery client stopped, exiting loop");
         return;
       }
       try {
         await this.runDiscoveryCycle();
       } catch (error) {
-        logger7.error("Discovery cycle error:", error);
+        logger8.error("Discovery cycle error:", error);
       }
       const discoveryIntervalMinutes = getRandomInterval(this.runtime, "discovery");
       const nextInterval = discoveryIntervalMinutes * 60 * 1e3;
-      logger7.log(
+      logger8.log(
         `Next discovery cycle in ${discoveryIntervalMinutes.toFixed(1)} minutes`
       );
       setTimeout(discoveryLoop, nextInterval);
@@ -7892,19 +7957,19 @@ var TwitterDiscoveryClient = class {
     setTimeout(discoveryLoop, 5e3);
   }
   async stop() {
-    logger7.info("Stopping Twitter Discovery Client...");
+    logger8.info("Stopping Twitter Discovery Client...");
     this.isRunning = false;
   }
   async runDiscoveryCycle() {
-    logger7.info("Starting Twitter discovery cycle...");
+    logger8.info("Starting Twitter discovery cycle...");
     const discoveries = await this.discoverContent();
     const { tweets, accounts } = discoveries;
-    logger7.info(
+    logger8.info(
       `Discovered ${tweets.length} tweets and ${accounts.length} accounts`
     );
     const followedCount = await this.processAccounts(accounts);
     const engagementCount = await this.processTweets(tweets);
-    logger7.info(
+    logger8.info(
       `Discovery cycle complete: ${followedCount} follows, ${engagementCount} engagements`
     );
   }
@@ -7916,7 +7981,7 @@ var TwitterDiscoveryClient = class {
       allTweets.push(...topicContent.tweets);
       topicContent.accounts.forEach((acc) => allAccounts.set(acc.user.id, acc));
     } catch (error) {
-      logger7.error("Failed to discover from topics:", error);
+      logger8.error("Failed to discover from topics:", error);
     }
     try {
       const threadContent = await this.discoverFromThreads();
@@ -7925,7 +7990,7 @@ var TwitterDiscoveryClient = class {
         (acc) => allAccounts.set(acc.user.id, acc)
       );
     } catch (error) {
-      logger7.error("Failed to discover from threads:", error);
+      logger8.error("Failed to discover from threads:", error);
     }
     try {
       const popularContent = await this.discoverFromPopularAccounts();
@@ -7934,7 +7999,7 @@ var TwitterDiscoveryClient = class {
         (acc) => allAccounts.set(acc.user.id, acc)
       );
     } catch (error) {
-      logger7.error("Failed to discover from popular accounts:", error);
+      logger8.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(
@@ -7943,14 +8008,14 @@ var TwitterDiscoveryClient = class {
     return { tweets: sortedTweets, accounts: sortedAccounts };
   }
   async discoverFromTopics() {
-    logger7.debug("Discovering from character topics...");
+    logger8.debug("Discovering from character topics...");
     const tweets = [];
     const accounts = /* @__PURE__ */ new Map();
     for (const topic of this.config.topics.slice(0, 5)) {
       try {
         const searchTopic = this.sanitizeTopic(topic);
         const popularQuery = `${searchTopic} -is:retweet -is:reply lang:en`;
-        logger7.debug(`Searching popular tweets for topic: ${topic}`);
+        logger8.debug(`Searching popular tweets for topic: ${topic}`);
         const popularResults = await this.twitterClient.fetchSearchTweets(
           popularQuery,
           20,
@@ -7979,7 +8044,7 @@ var TwitterDiscoveryClient = class {
           }
         }
         const engagedQuery = `${searchTopic} -is:retweet lang:en`;
-        logger7.debug(`Searching engaged tweets for topic: ${topic}`);
+        logger8.debug(`Searching engaged tweets for topic: ${topic}`);
         const engagedResults = await this.twitterClient.fetchSearchTweets(
           engagedQuery,
           15,
@@ -8007,19 +8072,19 @@ var TwitterDiscoveryClient = class {
           }
         }
       } catch (error) {
-        logger7.error(`Failed to search topic ${topic}:`, error);
+        logger8.error(`Failed to search topic ${topic}:`, error);
       }
     }
     return { tweets, accounts: Array.from(accounts.values()) };
   }
   async discoverFromThreads() {
-    logger7.debug("Discovering from conversation threads...");
+    logger8.debug("Discovering from conversation threads...");
     const tweets = [];
     const accounts = /* @__PURE__ */ new Map();
     const topicQuery = this.config.topics.slice(0, 3).map((t) => this.sanitizeTopic(t)).join(" OR ");
     try {
       const viralQuery = `(${topicQuery}) -is:retweet has:mentions`;
-      logger7.debug(`Searching viral threads with query: ${viralQuery}`);
+      logger8.debug(`Searching viral threads with query: ${viralQuery}`);
       const searchResults = await this.twitterClient.fetchSearchTweets(
         viralQuery,
         15,
@@ -8042,19 +8107,19 @@ var TwitterDiscoveryClient = class {
         }
       }
     } catch (error) {
-      logger7.error("Failed to discover threads:", error);
+      logger8.error("Failed to discover threads:", error);
     }
     return { tweets, accounts: Array.from(accounts.values()) };
   }
   async discoverFromPopularAccounts() {
-    logger7.debug("Discovering from popular accounts in topics...");
+    logger8.debug("Discovering from popular accounts in topics...");
     const tweets = [];
     const accounts = /* @__PURE__ */ new Map();
     for (const topic of this.config.topics.slice(0, 3)) {
       try {
         const searchTopic = this.sanitizeTopic(topic);
         const influencerQuery = `${searchTopic} -is:retweet lang:en`;
-        logger7.debug(`Searching for influencers in topic: ${topic}`);
+        logger8.debug(`Searching for influencers in topic: ${topic}`);
         const results = await this.twitterClient.fetchSearchTweets(
           influencerQuery,
           10,
@@ -8081,7 +8146,7 @@ var TwitterDiscoveryClient = class {
           }
         }
       } catch (error) {
-        logger7.error(
+        logger8.error(
           `Failed to discover popular accounts for ${topic}:`,
           error
         );
@@ -8160,13 +8225,13 @@ var TwitterDiscoveryClient = class {
     for (const scoredAccount of sortedAccounts) {
       if (followedCount >= this.config.maxFollowsPerCycle) break;
       if (scoredAccount.user.followersCount < this.config.minFollowerCount) {
-        logger7.debug(
+        logger8.debug(
           `Skipping @${scoredAccount.user.username} - below minimum follower count (${scoredAccount.user.followersCount} < ${this.config.minFollowerCount})`
         );
         continue;
       }
       if (scoredAccount.qualityScore < 0.2) {
-        logger7.debug(
+        logger8.debug(
           `Skipping @${scoredAccount.user.username} - quality score too low (${scoredAccount.qualityScore.toFixed(2)})`
         );
         continue;
@@ -8175,12 +8240,12 @@ var TwitterDiscoveryClient = class {
         const isFollowing = await this.checkIfFollowing(scoredAccount.user.id);
         if (isFollowing) continue;
         if (this.isDryRun) {
-          logger7.info(
+          logger8.info(
             `[DRY RUN] Would follow @${scoredAccount.user.username} (quality: ${scoredAccount.qualityScore.toFixed(2)}, relevance: ${scoredAccount.relevanceScore.toFixed(2)})`
           );
         } else {
           await this.twitterClient.followUser(scoredAccount.user.id);
-          logger7.info(
+          logger8.info(
             `Followed @${scoredAccount.user.username} (quality: ${scoredAccount.qualityScore.toFixed(2)}, relevance: ${scoredAccount.relevanceScore.toFixed(2)})`
           );
           await this.saveFollowMemory(scoredAccount.user);
@@ -8188,7 +8253,7 @@ var TwitterDiscoveryClient = class {
         followedCount++;
         await this.delay(2e3 + Math.random() * 3e3);
       } catch (error) {
-        logger7.error(
+        logger8.error(
           `Failed to follow @${scoredAccount.user.username}:`,
           error
         );
@@ -8202,13 +8267,13 @@ var TwitterDiscoveryClient = class {
       if (engagementCount >= this.config.maxEngagementsPerCycle) break;
       if (scoredTweet.engagementType === "skip") continue;
       try {
-        const tweetMemoryId = createUniqueUuid5(
+        const tweetMemoryId = createUniqueUuid6(
           this.runtime,
           scoredTweet.tweet.id
         );
         const existingMemory = await this.runtime.getMemoryById(tweetMemoryId);
         if (existingMemory) {
-          logger7.debug(
+          logger8.debug(
             `Already engaged with tweet ${scoredTweet.tweet.id}, skipping`
           );
           continue;
@@ -8216,12 +8281,12 @@ var TwitterDiscoveryClient = class {
         switch (scoredTweet.engagementType) {
           case "like":
             if (this.isDryRun) {
-              logger7.info(
+              logger8.info(
                 `[DRY RUN] Would like tweet: ${scoredTweet.tweet.id} (score: ${scoredTweet.relevanceScore.toFixed(2)})`
               );
             } else {
               await this.twitterClient.likeTweet(scoredTweet.tweet.id);
-              logger7.info(
+              logger8.info(
                 `Liked tweet: ${scoredTweet.tweet.id} (score: ${scoredTweet.relevanceScore.toFixed(2)})`
               );
             }
@@ -8229,7 +8294,7 @@ var TwitterDiscoveryClient = class {
           case "reply":
             const replyText = await this.generateReply(scoredTweet.tweet);
             if (this.isDryRun) {
-              logger7.info(
+              logger8.info(
                 `[DRY RUN] Would reply to tweet ${scoredTweet.tweet.id} with: "${replyText}"`
               );
             } else {
@@ -8237,13 +8302,13 @@ var TwitterDiscoveryClient = class {
                 replyText,
                 scoredTweet.tweet.id
               );
-              logger7.info(`Replied to tweet: ${scoredTweet.tweet.id}`);
+              logger8.info(`Replied to tweet: ${scoredTweet.tweet.id}`);
             }
             break;
           case "quote":
             const quoteText = await this.generateQuote(scoredTweet.tweet);
             if (this.isDryRun) {
-              logger7.info(
+              logger8.info(
                 `[DRY RUN] Would quote tweet ${scoredTweet.tweet.id} with: "${quoteText}"`
               );
             } else {
@@ -8251,7 +8316,7 @@ var TwitterDiscoveryClient = class {
                 quoteText,
                 scoredTweet.tweet.id
               );
-              logger7.info(`Quoted tweet: ${scoredTweet.tweet.id}`);
+              logger8.info(`Quoted tweet: ${scoredTweet.tweet.id}`);
             }
             break;
         }
@@ -8263,7 +8328,7 @@ var TwitterDiscoveryClient = class {
         await this.delay(3e3 + Math.random() * 5e3);
       } catch (error) {
         if (error?.message?.includes("403")) {
-          logger7.warn(
+          logger8.warn(
             `Permission denied (403) for tweet ${scoredTweet.tweet.id}. This might be a protected account or restricted tweet. Skipping.`
           );
           await this.saveEngagementMemory(
@@ -8271,12 +8336,12 @@ var TwitterDiscoveryClient = class {
             "skip"
           );
         } else if (error?.message?.includes("429")) {
-          logger7.warn(
+          logger8.warn(
             `Rate limit (429) hit while engaging with tweet ${scoredTweet.tweet.id}. Pausing engagement cycle.`
           );
           break;
         } else {
-          logger7.error(
+          logger8.error(
             `Failed to engage with tweet ${scoredTweet.tweet.id}:`,
             error
           );
@@ -8362,12 +8427,65 @@ Quote tweet:`;
     return response.trim();
   }
   async saveEngagementMemory(tweet, engagementType) {
-    logger7.debug(`[Discovery] Would save engagement memory for ${engagementType} on tweet ${tweet.id}`);
-    return;
+    try {
+      const context = await ensureTwitterContext(this.runtime, {
+        userId: tweet.userId,
+        username: tweet.username,
+        conversationId: tweet.conversationId || tweet.id
+      });
+      const memory = {
+        id: createUniqueUuid6(this.runtime, `${tweet.id}-${engagementType}`),
+        entityId: context.entityId,
+        content: {
+          text: `${engagementType} tweet from @${tweet.username}: ${tweet.text}`,
+          metadata: {
+            tweetId: tweet.id,
+            engagementType,
+            source: "discovery",
+            isDryRun: this.isDryRun
+          }
+        },
+        roomId: context.roomId,
+        agentId: this.runtime.agentId,
+        createdAt: Date.now()
+      };
+      await createMemorySafe(this.runtime, memory, "messages");
+      logger8.debug(`[Discovery] Saved ${engagementType} memory for tweet ${tweet.id}`);
+    } catch (error) {
+      logger8.error(`[Discovery] Failed to save engagement memory:`, error);
+    }
   }
   async saveFollowMemory(user) {
-    logger7.debug(`[Discovery] Would save follow memory for @${user.username}`);
-    return;
+    try {
+      const context = await ensureTwitterContext(this.runtime, {
+        userId: user.id,
+        username: user.username,
+        name: user.name,
+        conversationId: `twitter-follows`
+      });
+      const memory = {
+        id: createUniqueUuid6(this.runtime, `follow-${user.id}`),
+        entityId: context.entityId,
+        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: context.roomId,
+        agentId: this.runtime.agentId,
+        createdAt: Date.now()
+      };
+      await createMemorySafe(this.runtime, memory, "messages");
+      logger8.debug(`[Discovery] Saved follow memory for @${user.username}`);
+    } catch (error) {
+      logger8.error(`[Discovery] Failed to save follow memory:`, error);
+    }
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -8376,9 +8494,9 @@ Quote tweet:`;
 
 // src/base.ts
 import {
-  ChannelType as ChannelType4,
-  createUniqueUuid as createUniqueUuid6,
-  logger as logger8
+  ChannelType as ChannelType5,
+  createUniqueUuid as createUniqueUuid7,
+  logger as logger9
 } from "@elizaos/core";
 var RequestQueue = class {
   constructor() {
@@ -8423,7 +8541,7 @@ var RequestQueue = class {
         await request();
         this.retryAttempts.delete(request);
       } catch (error) {
-        logger8.error("Error processing request:", error);
+        logger9.error("Error processing request:", error);
         const retryCount = (this.retryAttempts.get(request) || 0) + 1;
         if (retryCount < this.maxRetries) {
           this.retryAttempts.set(request, retryCount);
@@ -8431,7 +8549,7 @@ var RequestQueue = class {
           await this.exponentialBackoff(retryCount);
           break;
         } else {
-          logger8.error(
+          logger9.error(
             `Max retries (${this.maxRetries}) exceeded for request, skipping`
           );
           this.retryAttempts.delete(request);
@@ -8489,7 +8607,7 @@ var _ClientBase = class _ClientBase {
    */
   async cacheTweet(tweet) {
     if (!tweet) {
-      logger8.warn("Tweet is undefined, skipping cache");
+      logger9.warn("Tweet is undefined, skipping cache");
       return;
     }
     this.runtime.setCache(`twitter/tweets/${tweet.id}`, tweet);
@@ -8554,7 +8672,7 @@ var _ClientBase = class _ClientBase {
     let lastError = null;
     while (retryCount < maxRetries) {
       try {
-        logger8.log("Initializing Twitter API v2 client");
+        logger9.log("Initializing Twitter API v2 client");
         await this.twitterClient.login(
           "",
           // username not needed for API v2
@@ -8570,18 +8688,18 @@ var _ClientBase = class _ClientBase {
           accessTokenSecret
         );
         if (await this.twitterClient.isLoggedIn()) {
-          logger8.info("Successfully authenticated with Twitter API v2");
+          logger9.info("Successfully authenticated with Twitter API v2");
           break;
         }
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
-        logger8.error(
+        logger9.error(
           `Authentication attempt ${retryCount + 1} failed: ${lastError.message}`
         );
         retryCount++;
         if (retryCount < maxRetries) {
           const delay = 2 ** retryCount * 1e3;
-          logger8.info(`Retrying in ${delay / 1e3} seconds...`);
+          logger9.info(`Retrying in ${delay / 1e3} seconds...`);
           await new Promise((resolve) => setTimeout(resolve, delay));
         }
       }
@@ -8593,13 +8711,13 @@ var _ClientBase = class _ClientBase {
     }
     const profile = await this.twitterClient.me();
     if (profile) {
-      logger8.log("Twitter user ID:", profile.userId);
-      logger8.log("Twitter loaded:", JSON.stringify(profile, null, 10));
+      logger9.log("Twitter user ID:", profile.userId);
+      logger9.log("Twitter loaded:", JSON.stringify(profile, null, 10));
       const agentId = this.runtime.agentId;
       const entity = await this.runtime.getEntityById(agentId);
       const entityMetadata = entity?.metadata;
       if (entityMetadata?.twitter?.userName !== profile.username) {
-        logger8.log(
+        logger9.log(
           "Updating Agents known X/twitter handle",
           profile.username,
           "was",
@@ -8638,7 +8756,7 @@ var _ClientBase = class _ClientBase {
     await this.populateTimeline();
   }
   async fetchOwnPosts(count) {
-    logger8.debug("fetching own posts");
+    logger9.debug("fetching own posts");
     const homeTimeline = await this.twitterClient.getUserTweets(
       this.profile.id,
       count
@@ -8649,7 +8767,7 @@ var _ClientBase = class _ClientBase {
    * Fetch timeline for twitter account, optionally only from followed accounts
    */
   async fetchHomeTimeline(count, following) {
-    logger8.debug("fetching home timeline");
+    logger9.debug("fetching home timeline");
     const homeTimeline = following ? await this.twitterClient.fetchFollowingTimeline(count, []) : await this.twitterClient.fetchHomeTimeline(count, []);
     return homeTimeline;
   }
@@ -8672,40 +8790,40 @@ var _ClientBase = class _ClientBase {
         );
         return result ?? { tweets: [] };
       } catch (error) {
-        logger8.error("Error fetching search tweets:", error);
+        logger9.error("Error fetching search tweets:", error);
         return { tweets: [] };
       }
     } catch (error) {
-      logger8.error("Error fetching search tweets:", error);
+      logger9.error("Error fetching search tweets:", error);
       return { tweets: [] };
     }
   }
   async populateTimeline() {
-    logger8.debug("populating timeline...");
+    logger9.debug("populating timeline...");
     const cachedTimeline = await this.getCachedTimeline();
     if (cachedTimeline) {
       const existingMemories2 = await this.runtime.getMemoriesByRoomIds({
         tableName: "messages",
         roomIds: cachedTimeline.map(
-          (tweet) => createUniqueUuid6(this.runtime, tweet.conversationId)
+          (tweet) => createUniqueUuid7(this.runtime, tweet.conversationId)
         )
       });
       const existingMemoryIds2 = new Set(
         existingMemories2.map((memory) => memory.id.toString())
       );
       const someCachedTweetsExist = cachedTimeline.some(
-        (tweet) => existingMemoryIds2.has(createUniqueUuid6(this.runtime, tweet.id))
+        (tweet) => existingMemoryIds2.has(createUniqueUuid7(this.runtime, tweet.id))
       );
       if (someCachedTweetsExist) {
         const tweetsToSave2 = cachedTimeline.filter(
-          (tweet) => tweet.userId !== this.profile.id && !existingMemoryIds2.has(createUniqueUuid6(this.runtime, tweet.id))
+          (tweet) => tweet.userId !== this.profile.id && !existingMemoryIds2.has(createUniqueUuid7(this.runtime, tweet.id))
         );
         for (const tweet of tweetsToSave2) {
-          logger8.log("Saving Tweet", tweet.id);
+          logger9.log("Saving Tweet", tweet.id);
           if (tweet.userId === this.profile.id) {
             continue;
           }
-          const worldId = createUniqueUuid6(this.runtime, tweet.userId);
+          const worldId = createUniqueUuid7(this.runtime, tweet.userId);
           await this.runtime.ensureWorldExists({
             id: worldId,
             name: `${tweet.username}'s Twitter`,
@@ -8719,26 +8837,26 @@ var _ClientBase = class _ClientBase {
               }
             }
           });
-          const roomId = createUniqueUuid6(this.runtime, tweet.conversationId);
-          const entityId = tweet.userId === this.profile.id ? this.runtime.agentId : createUniqueUuid6(this.runtime, tweet.userId);
+          const roomId = createUniqueUuid7(this.runtime, tweet.conversationId);
+          const entityId = tweet.userId === this.profile.id ? this.runtime.agentId : createUniqueUuid7(this.runtime, tweet.userId);
           await this.runtime.ensureConnection({
             entityId,
             roomId,
             userName: tweet.username,
             name: tweet.name,
             source: "twitter",
-            type: ChannelType4.FEED,
+            type: ChannelType5.FEED,
             worldId
           });
           const content = {
             text: tweet.text,
             url: tweet.permanentUrl,
             source: "twitter",
-            inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid6(this.runtime, tweet.inReplyToStatusId) : void 0
+            inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid7(this.runtime, tweet.inReplyToStatusId) : void 0
           };
           await this.runtime.createMemory(
             {
-              id: createUniqueUuid6(this.runtime, tweet.id),
+              id: createUniqueUuid7(this.runtime, tweet.id),
               entityId,
               content,
               agentId: this.runtime.agentId,
@@ -8749,7 +8867,7 @@ var _ClientBase = class _ClientBase {
           );
           await this.cacheTweet(tweet);
         }
-        logger8.log(
+        logger9.log(
           `Populated ${tweetsToSave2.length} missing tweets from the cache.`
         );
         return;
@@ -8766,7 +8884,7 @@ var _ClientBase = class _ClientBase {
     const roomIds = /* @__PURE__ */ new Set();
     for (const tweet of allTweets) {
       tweetIdsToCheck.add(tweet.id);
-      roomIds.add(createUniqueUuid6(this.runtime, tweet.conversationId));
+      roomIds.add(createUniqueUuid7(this.runtime, tweet.conversationId));
     }
     const existingMemories = await this.runtime.getMemoriesByRoomIds({
       tableName: "messages",
@@ -8776,17 +8894,17 @@ var _ClientBase = class _ClientBase {
       existingMemories.map((memory) => memory.id)
     );
     const tweetsToSave = allTweets.filter(
-      (tweet) => tweet.userId !== this.profile.id && !existingMemoryIds.has(createUniqueUuid6(this.runtime, tweet.id))
+      (tweet) => tweet.userId !== this.profile.id && !existingMemoryIds.has(createUniqueUuid7(this.runtime, tweet.id))
     );
-    logger8.debug({
+    logger9.debug({
       processingTweets: tweetsToSave.map((tweet) => tweet.id).join(",")
     });
     for (const tweet of tweetsToSave) {
-      logger8.log("Saving Tweet", tweet.id);
+      logger9.log("Saving Tweet", tweet.id);
       if (tweet.userId === this.profile.id) {
         continue;
       }
-      const worldId = createUniqueUuid6(this.runtime, tweet.userId);
+      const worldId = createUniqueUuid7(this.runtime, tweet.userId);
       await this.runtime.ensureWorldExists({
         id: worldId,
         name: `${tweet.username}'s Twitter`,
@@ -8800,26 +8918,27 @@ var _ClientBase = class _ClientBase {
           }
         }
       });
-      const roomId = createUniqueUuid6(this.runtime, tweet.conversationId);
-      const entityId = tweet.userId === this.profile.id ? this.runtime.agentId : createUniqueUuid6(this.runtime, tweet.userId);
+      const roomId = createUniqueUuid7(this.runtime, tweet.conversationId);
+      const entityId = tweet.userId === this.profile.id ? this.runtime.agentId : createUniqueUuid7(this.runtime, tweet.userId);
       await this.runtime.ensureConnection({
         entityId,
         roomId,
         userName: tweet.username,
         name: tweet.name,
         source: "twitter",
-        type: ChannelType4.FEED,
+        type: ChannelType5.FEED,
         worldId
       });
       const content = {
         text: tweet.text,
         url: tweet.permanentUrl,
         source: "twitter",
-        inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid6(this.runtime, tweet.inReplyToStatusId) : void 0
+        inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid7(this.runtime, tweet.inReplyToStatusId) : void 0
       };
-      await this.runtime.createMemory(
+      await createMemorySafe(
+        this.runtime,
         {
-          id: createUniqueUuid6(this.runtime, tweet.id),
+          id: createUniqueUuid7(this.runtime, tweet.id),
           entityId,
           content,
           agentId: this.runtime.agentId,
@@ -8842,9 +8961,9 @@ var _ClientBase = class _ClientBase {
         unique: false
       });
       if (recentMessage.length > 0 && recentMessage[0].content === message.content) {
-        logger8.debug("Message already saved", recentMessage[0].id);
+        logger9.debug("Message already saved", recentMessage[0].id);
       } else {
-        await this.runtime.createMemory(message, "messages");
+        await createMemorySafe(this.runtime, message, "messages");
       }
       await this.runtime.evaluate(message, {
         ...state,
@@ -8915,7 +9034,7 @@ var _ClientBase = class _ClientBase {
       });
       return profile;
     } catch (error) {
-      logger8.error("Error fetching Twitter profile:", error);
+      logger9.error("Error fetching Twitter profile:", error);
       throw error;
     }
   }
@@ -8936,7 +9055,7 @@ var _ClientBase = class _ClientBase {
         (tweet) => this.formatTweetToInteraction(tweet)
       );
     } catch (error) {
-      logger8.error("Error fetching Twitter interactions:", error);
+      logger9.error("Error fetching Twitter interactions:", error);
       return [];
     }
   }
@@ -8966,42 +9085,42 @@ var TwitterClientInstance = class {
   constructor(runtime, state) {
     this.client = new ClientBase(runtime, state);
     const postEnabledSetting = getSetting(runtime, "TWITTER_ENABLE_POST") ?? process.env.TWITTER_ENABLE_POST;
-    logger9.debug(
+    logger10.debug(
       `TWITTER_ENABLE_POST setting value: ${JSON.stringify(postEnabledSetting)}, type: ${typeof postEnabledSetting}`
     );
-    const postEnabled = postEnabledSetting === "true" || postEnabledSetting === true;
+    const postEnabled = typeof postEnabledSetting === "string" && (postEnabledSetting === "true" || postEnabledSetting.toLowerCase() === "true") || typeof postEnabledSetting === "boolean" && postEnabledSetting === true;
     if (postEnabled) {
-      logger9.info("Twitter posting is ENABLED - creating post client");
+      logger10.info("Twitter posting is ENABLED - creating post client");
       this.post = new TwitterPostClient(this.client, runtime, state);
     } else {
-      logger9.info(
+      logger10.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) {
-      logger9.info("Twitter replies/interactions are ENABLED");
+      logger10.info("Twitter replies/interactions are ENABLED");
       this.interaction = new TwitterInteractionClient(
         this.client,
         runtime,
         state
       );
     } else {
-      logger9.info("Twitter replies/interactions are DISABLED");
+      logger10.info("Twitter replies/interactions are DISABLED");
     }
     const actionsEnabled = (getSetting(runtime, "TWITTER_ENABLE_ACTIONS") ?? process.env.TWITTER_ENABLE_ACTIONS) === "true";
     if (actionsEnabled) {
-      logger9.info("Twitter timeline actions are ENABLED");
+      logger10.info("Twitter timeline actions are ENABLED");
       this.timeline = new TwitterTimelineClient(this.client, runtime, state);
     } else {
-      logger9.info("Twitter timeline actions are DISABLED");
+      logger10.info("Twitter timeline actions are DISABLED");
     }
     const discoveryEnabled = (getSetting(runtime, "TWITTER_ENABLE_DISCOVERY") ?? process.env.TWITTER_ENABLE_DISCOVERY) === "true" || actionsEnabled && (getSetting(runtime, "TWITTER_ENABLE_DISCOVERY") ?? process.env.TWITTER_ENABLE_DISCOVERY) !== "false";
     if (discoveryEnabled) {
-      logger9.info("Twitter discovery service is ENABLED");
+      logger10.info("Twitter discovery service is ENABLED");
       this.discovery = new TwitterDiscoveryClient(this.client, runtime, state);
     } else {
-      logger9.info(
+      logger10.info(
         "Twitter discovery service is DISABLED - set TWITTER_ENABLE_DISCOVERY=true to enable"
       );
     }
@@ -9018,28 +9137,28 @@ var _TwitterService = class _TwitterService extends Service {
     service.runtime = runtime;
     try {
       await validateTwitterConfig(runtime);
-      logger9.log("\u2705 Twitter configuration validated successfully");
+      logger10.log("\u2705 Twitter configuration validated successfully");
       service.twitterClient = new TwitterClientInstance(runtime, {});
       await service.twitterClient.client.init();
       if (service.twitterClient.post) {
-        logger9.log("\u{1F4EE} Starting Twitter post client...");
+        logger10.log("\u{1F4EE} Starting Twitter post client...");
         await service.twitterClient.post.start();
       }
       if (service.twitterClient.interaction) {
-        logger9.log("\u{1F4AC} Starting Twitter interaction client...");
+        logger10.log("\u{1F4AC} Starting Twitter interaction client...");
         await service.twitterClient.interaction.start();
       }
       if (service.twitterClient.timeline) {
-        logger9.log("\u{1F4CA} Starting Twitter timeline client...");
+        logger10.log("\u{1F4CA} Starting Twitter timeline client...");
         await service.twitterClient.timeline.start();
       }
       if (service.twitterClient.discovery) {
-        logger9.log("\u{1F50D} Starting Twitter discovery client...");
+        logger10.log("\u{1F50D} Starting Twitter discovery client...");
         await service.twitterClient.discovery.start();
       }
-      logger9.log("\u2705 Twitter service started successfully");
+      logger10.log("\u2705 Twitter service started successfully");
     } catch (error) {
-      logger9.error("\u{1F6A8} Failed to start Twitter service:", error);
+      logger10.error("\u{1F6A8} Failed to start Twitter service:", error);
       throw error;
     }
     return service;
@@ -9057,7 +9176,7 @@ var _TwitterService = class _TwitterService extends Service {
     if (this.twitterClient?.discovery) {
       await this.twitterClient.discovery.stop();
     }
-    logger9.log("Twitter service stopped");
+    logger10.log("Twitter service stopped");
   }
 };
 _TwitterService.serviceType = "twitter";
@@ -9065,7 +9184,7 @@ var TwitterService = _TwitterService;
 
 // src/actions/postTweet.ts
 import {
-  logger as logger10,
+  logger as logger11,
   ModelType as ModelType5
 } from "@elizaos/core";
 var postTweetAction = {
@@ -9078,34 +9197,12 @@ var postTweetAction = {
     "SHARE_ON_TWITTER"
   ],
   validate: async (runtime, message) => {
-    logger10.debug("Validating POST_TWEET action");
-    logger10.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) {
-      logger10.debug("Skipping validation for provider context (empty post type)");
-      return false;
-    }
-    const text = message.content?.text?.trim();
-    if (!text || text.length === 0) {
-      logger10.error("No text content for tweet");
-      logger10.debug("Stack trace:", new Error().stack);
-      return false;
-    }
-    if (text.length > 280) {
-      logger10.warn(`Tweet too long: ${text.length} characters`);
-    }
-    return true;
+    const service = runtime.getService("twitter");
+    return !!service;
   },
   description: "Post a tweet on Twitter",
   handler: async (runtime, message, state, _options, callback) => {
-    logger10.info("Executing POST_TWEET action");
+    logger11.info("Executing POST_TWEET action");
     try {
       const twitterService = runtime.getService("twitter");
       if (!twitterService) {
@@ -9123,7 +9220,7 @@ var postTweetAction = {
       }
       let text = message.content?.text?.trim();
       if (!text) {
-        logger10.error("No text content for tweet");
+        logger11.error("No text content for tweet");
         if (callback) {
           callback({
             text: "I need something to tweet! Please provide the text.",
@@ -9133,7 +9230,7 @@ var postTweetAction = {
         return;
       }
       if (text.length > 280) {
-        logger10.info(`Truncating tweet from ${text.length} to 280 characters`);
+        logger11.info(`Truncating tweet from ${text.length} to 280 characters`);
         const sentences = text.match(/[^.!?]+[.!?]+/g) || [text];
         let truncated = "";
         for (const sentence of sentences) {
@@ -9144,7 +9241,7 @@ var postTweetAction = {
           }
         }
         text = truncated.trim() || text.substring(0, 277) + "...";
-        logger10.info(`Truncated tweet: ${text}`);
+        logger11.info(`Truncated tweet: ${text}`);
       }
       let finalTweetText = text;
       if (text.length < 50 || text.toLowerCase().includes("post") || text.toLowerCase().includes("tweet")) {
@@ -9195,20 +9292,24 @@ Tweet:`;
           tweetId = Date.now().toString();
         }
         const tweetUrl = `https://twitter.com/${client.profile.username}/status/${tweetId}`;
-        logger10.info(`Successfully posted tweet: ${tweetId}`);
-        await runtime.createMemory(
-          {
-            entityId: runtime.agentId,
-            content: {
-              text: finalTweetText,
-              url: tweetUrl,
-              source: "twitter",
-              action: "POST_TWEET"
+        logger11.info(`Successfully posted tweet: ${tweetId}`);
+        try {
+          await runtime.createMemory(
+            {
+              entityId: runtime.agentId,
+              content: {
+                text: finalTweetText,
+                url: tweetUrl,
+                source: "twitter",
+                action: "POST_TWEET"
+              },
+              roomId: message.roomId
             },
-            roomId: message.roomId
-          },
-          "messages"
-        );
+            "messages"
+          );
+        } catch (memoryError) {
+          logger11.error("Failed to create memory for posted tweet:", memoryError);
+        }
         if (callback) {
           await callback({
             text: `I've posted a tweet: "${finalTweetText}"
@@ -9225,7 +9326,7 @@ View it here: ${tweetUrl}`,
         throw new Error("Failed to post tweet - no response data");
       }
     } catch (error) {
-      logger10.error("Error posting tweet:", error);
+      logger11.error("Error posting tweet:", error);
       if (callback) {
         await callback({
           text: `Sorry, I couldn't post the tweet. Error: ${error.message}`,
@@ -9240,28 +9341,13 @@ View it here: ${tweetUrl}`,
       {
         name: "{{user1}}",
         content: {
-          text: "Post a tweet about the importance of open source AI"
-        }
-      },
-      {
-        name: "{{agentName}}",
-        content: {
-          text: "I'll post a tweet about open source AI for you.",
-          action: "POST_TWEET"
-        }
-      }
-    ],
-    [
-      {
-        name: "{{user1}}",
-        content: {
-          text: "Tweet something interesting about web3"
+          text: "Post a tweet about the weather today"
         }
       },
       {
-        name: "{{agentName}}",
+        name: "{{agent}}",
         content: {
-          text: "I'll share an interesting thought about web3 on Twitter.",
+          text: "I'll post a tweet about today's weather for you.",
           action: "POST_TWEET"
         }
       }
@@ -9270,13 +9356,13 @@ View it here: ${tweetUrl}`,
       {
         name: "{{user1}}",
         content: {
-          text: "Share your thoughts on the future of technology on Twitter"
+          text: "Tweet: The future of AI is collaborative intelligence"
         }
       },
       {
-        name: "{{agentName}}",
+        name: "{{agent}}",
         content: {
-          text: "I'll post my thoughts on the future of technology.",
+          text: "I'll post that tweet for you.",
           action: "POST_TWEET"
         }
       }
@@ -9291,7 +9377,7 @@ var TwitterPlugin = {
   actions: [postTweetAction],
   services: [TwitterService],
   init: async (_config, runtime) => {
-    logger11.log("\u{1F527} Initializing Twitter plugin...");
+    logger12.log("\u{1F527} Initializing Twitter plugin...");
     const hasGetSetting = runtime && typeof runtime.getSetting === "function";
     const apiKey = hasGetSetting ? runtime.getSetting("TWITTER_API_KEY") : process.env.TWITTER_API_KEY;
     const apiSecretKey = hasGetSetting ? runtime.getSetting("TWITTER_API_SECRET_KEY") : process.env.TWITTER_API_SECRET_KEY;
@@ -9303,14 +9389,14 @@ var TwitterPlugin = {
       if (!apiSecretKey) missing.push("TWITTER_API_SECRET_KEY");
       if (!accessToken) missing.push("TWITTER_ACCESS_TOKEN");
       if (!accessTokenSecret) missing.push("TWITTER_ACCESS_TOKEN_SECRET");
-      logger11.warn(
+      logger12.warn(
         `Twitter API credentials not configured - Twitter functionality will be limited. Missing: ${missing.join(", ")}`
       );
-      logger11.warn(
+      logger12.warn(
         "To enable Twitter functionality, please provide the missing credentials in your .env file"
       );
     } else {
-      logger11.log("\u2705 Twitter credentials found");
+      logger12.log("\u2705 Twitter credentials found");
     }
   }
 };