@elizaos/plugin-twitter 1.0.0-alpha.58 → 1.0.0-alpha.59

package/dist/index.js

@@ -1,10 +1,10 @@
 // src/index.ts
 import {
-  ChannelType as ChannelType6,
-  EventTypes as EventTypes3,
+  ChannelType as ChannelType7,
+  EventTypes as EventTypes4,
   Role,
   Service,
-  createUniqueUuid as createUniqueUuid7,
+  createUniqueUuid as createUniqueUuid8,
   logger as logger9
 } from "@elizaos/core";
 
@@ -15,7 +15,12 @@ import {
 } from "@elizaos/core";
 
 // src/spaces.ts
-import { ModelTypes as ModelTypes3, logger as logger3 } from "@elizaos/core";
+import {
+  ChannelType as ChannelType3,
+  ModelType as ModelType3,
+  createUniqueUuid as createUniqueUuid3,
+  logger as logger3
+} from "@elizaos/core";
 
 // src/client/api.ts
 import { Headers as Headers2 } from "headers-polyfill";
@@ -576,7 +581,7 @@ async function getScreenNameByUserId(userId, auth) {
     value: legacy.screen_name
   };
 }
-async function getUserIdByScreenName(screenName, auth) {
+async function getEntityIdByScreenName(screenName, auth) {
   const cached = idCache.get(screenName);
   if (cached != null) {
     return { success: true, value: cached };
@@ -1357,7 +1362,7 @@ async function followUser(username, auth) {
   if (!await auth.isLoggedIn()) {
     throw new Error("Must be logged in to follow users");
   }
-  const userIdResult = await getUserIdByScreenName(username, auth);
+  const userIdResult = await getEntityIdByScreenName(username, auth);
   if (!userIdResult.success) {
     throw new Error(`Failed to get user ID: ${userIdResult.err.message}`);
   }
@@ -3031,7 +3036,7 @@ async function fetchListTweets(listId, maxTweets, cursor, auth) {
 }
 function getTweets(user, maxTweets, auth) {
   return getTweetTimeline(user, maxTweets, async (q, mt, c) => {
-    const userIdRes = await getUserIdByScreenName(q, auth);
+    const userIdRes = await getEntityIdByScreenName(q, auth);
     if (!userIdRes.success) {
       throw userIdRes.err;
     }
@@ -3046,7 +3051,7 @@ function getTweetsByUserId(userId, maxTweets, auth) {
 }
 function getTweetsAndReplies(user, maxTweets, auth) {
   return getTweetTimeline(user, maxTweets, async (q, mt, c) => {
-    const userIdRes = await getUserIdByScreenName(q, auth);
+    const userIdRes = await getEntityIdByScreenName(q, auth);
     if (!userIdRes.success) {
       throw userIdRes.err;
     }
@@ -3675,8 +3680,8 @@ var Client = class {
    * @param screenName The Twitter screen name of the profile to fetch.
    * @returns The ID of the corresponding account.
    */
-  async getUserIdByScreenName(screenName) {
-    const res = await getUserIdByScreenName(screenName, this.auth);
+  async getEntityIdByScreenName(screenName) {
+    const res = await getEntityIdByScreenName(screenName, this.auth);
     return this.handleResponse(res);
   }
   /**
@@ -6521,7 +6526,7 @@ import { spawn } from "node:child_process";
 import {
   ChannelType,
   EventTypes,
-  ModelTypes,
+  ModelType,
   createUniqueUuid,
   logger
 } from "@elizaos/core";
@@ -6680,7 +6685,7 @@ var SttTtsPlugin2 = class {
       }
       const wavBuffer = await this.convertPcmToWavInMemory(merged, 48e3);
       const sttText = await this.runtime.useModel(
-        ModelTypes.TRANSCRIPTION,
+        ModelType.TRANSCRIPTION,
         wavBuffer
       );
       logger.log(`[SttTtsPlugin] Transcription result: "${sttText}"`);
@@ -6719,7 +6724,7 @@ var SttTtsPlugin2 = class {
       const { signal } = this.ttsAbortController;
       try {
         const responseStream = await this.runtime.useModel(
-          ModelTypes.TEXT_TO_SPEECH,
+          ModelType.TEXT_TO_SPEECH,
           text
         );
         if (!responseStream) {
@@ -6803,7 +6808,7 @@ var SttTtsPlugin2 = class {
           createdAt: Date.now()
         };
         if (responseMemory.content.text?.trim()) {
-          await this.runtime.getMemoryManager("messages").createMemory(responseMemory);
+          await this.runtime.createMemory(responseMemory);
           this.isProcessingAudio = false;
           this.volumeBuffers.clear();
           await this.speakText(content.text);
@@ -6922,107 +6927,11 @@ import fs from "node:fs";
 import path from "node:path";
 import {
   ChannelType as ChannelType2,
-  ModelTypes as ModelTypes2,
+  ModelType as ModelType2,
   composePrompt,
   createUniqueUuid as createUniqueUuid2,
   logger as logger2
 } from "@elizaos/core";
-async function buildConversationThread(tweet, client, maxReplies = 10) {
-  const thread = [];
-  const visited = /* @__PURE__ */ new Set();
-  async function processThread(currentTweet, depth = 0) {
-    logger2.debug("Processing tweet:", {
-      id: currentTweet.id,
-      inReplyToStatusId: currentTweet.inReplyToStatusId,
-      depth
-    });
-    if (!currentTweet) {
-      logger2.debug("No current tweet found for thread building");
-      return;
-    }
-    if (depth >= maxReplies) {
-      logger2.debug("Reached maximum reply depth", depth);
-      return;
-    }
-    const memory = await client.runtime.getMemoryManager("messages").getMemoryById(createUniqueUuid2(this.runtime, currentTweet.id));
-    if (!memory) {
-      const roomId = createUniqueUuid2(
-        this.runtime,
-        currentTweet.conversationId
-      );
-      const entityId = createUniqueUuid2(this.runtime, currentTweet.userId);
-      await client.runtime.ensureConnection({
-        entityId,
-        roomId,
-        userName: currentTweet.username,
-        name: currentTweet.name,
-        source: "twitter",
-        type: ChannelType2.GROUP
-      });
-      await client.runtime.getMemoryManager("messages").createMemory({
-        id: createUniqueUuid2(this.runtime, currentTweet.id),
-        agentId: client.runtime.agentId,
-        content: {
-          text: currentTweet.text,
-          source: "twitter",
-          url: currentTweet.permanentUrl,
-          imageUrls: currentTweet.photos.map((p) => p.url) || [],
-          inReplyTo: currentTweet.inReplyToStatusId ? createUniqueUuid2(this.runtime, currentTweet.inReplyToStatusId) : void 0
-        },
-        createdAt: currentTweet.timestamp * 1e3,
-        roomId,
-        entityId: currentTweet.userId === client.profile.id ? client.runtime.agentId : createUniqueUuid2(this.runtime, currentTweet.userId)
-      });
-    }
-    if (visited.has(currentTweet.id)) {
-      logger2.debug("Already visited tweet:", currentTweet.id);
-      return;
-    }
-    visited.add(currentTweet.id);
-    thread.unshift(currentTweet);
-    logger2.debug("Current thread state:", {
-      length: thread.length,
-      currentDepth: depth,
-      tweetId: currentTweet.id
-    });
-    if (currentTweet.inReplyToStatusId) {
-      logger2.debug("Fetching parent tweet:", currentTweet.inReplyToStatusId);
-      try {
-        const parentTweet = await client.twitterClient.getTweet(
-          currentTweet.inReplyToStatusId
-        );
-        if (parentTweet) {
-          logger2.debug("Found parent tweet:", {
-            id: parentTweet.id,
-            text: parentTweet.text?.slice(0, 50)
-          });
-          await processThread(parentTweet, depth + 1);
-        } else {
-          logger2.debug(
-            "No parent tweet found for:",
-            currentTweet.inReplyToStatusId
-          );
-        }
-      } catch (error) {
-        logger2.error("Error fetching parent tweet:", {
-          tweetId: currentTweet.inReplyToStatusId,
-          error
-        });
-      }
-    } else {
-      logger2.debug("Reached end of reply chain at:", currentTweet.id);
-    }
-  }
-  await processThread(tweet, 0);
-  logger2.debug("Final thread built:", {
-    totalTweets: thread.length,
-    tweetIds: thread.map((t) => ({
-      id: t.id,
-      text: t.text?.slice(0, 50)
-    }))
-  });
-  return thread;
-}
 async function fetchMediaData(attachments) {
   return Promise.all(
     attachments.map(async (attachment) => {
@@ -7032,14 +6941,14 @@ async function fetchMediaData(attachments) {
           throw new Error(`Failed to fetch file: ${attachment.url}`);
         }
         const mediaBuffer = Buffer.from(await response.arrayBuffer());
-        const mediaType = attachment.contentType;
+        const mediaType = attachment.contentType || "image/png";
         return { data: mediaBuffer, mediaType };
       }
       if (fs.existsSync(attachment.url)) {
         const mediaBuffer = await fs.promises.readFile(
           path.resolve(attachment.url)
         );
-        const mediaType = attachment.contentType;
+        const mediaType = attachment.contentType || "image/png";
         return { data: mediaBuffer, mediaType };
       }
       throw new Error(
@@ -7065,7 +6974,7 @@ Only return the text, no additional formatting.
 ---
 `
     });
-    const output = await runtime.useModel(ModelTypes2.TEXT_SMALL, {
+    const output = await runtime.useModel(ModelType2.TEXT_SMALL, {
       prompt
     });
     return output.trim();
@@ -7098,7 +7007,7 @@ Example:
 ---
 `
     });
-    const response = await runtime.useModel(ModelTypes2.TEXT_SMALL, {
+    const response = await runtime.useModel(ModelType2.TEXT_SMALL, {
       prompt
     });
     const topics = response.split(",").map((t) => t.trim()).filter(Boolean);
@@ -7221,7 +7130,42 @@ var TwitterSpaceClient = class {
       this.speakerQueue = [];
       const broadcastInfo = await this.currentSpace.initialize(config);
       this.spaceId = broadcastInfo.room_id;
-      if (this.runtime.getModel(ModelTypes3.TEXT_TO_SPEECH) && this.runtime.getModel(ModelTypes3.TRANSCRIPTION)) {
+      const userId = this.client.profile.id;
+      const worldId = createUniqueUuid3(this.runtime, userId);
+      const spaceRoomId = createUniqueUuid3(this.runtime, `${userId}-space-${this.spaceId}`);
+      await this.runtime.ensureWorldExists({
+        id: worldId,
+        name: `${this.client.profile.username}'s Twitter`,
+        agentId: this.runtime.agentId,
+        serverId: userId,
+        metadata: {
+          ownership: { ownerId: userId },
+          twitter: {
+            username: this.client.profile.username,
+            id: userId
+          }
+        }
+      });
+      await this.runtime.ensureRoomExists({
+        id: spaceRoomId,
+        name: config.title || "Twitter Space",
+        source: "twitter",
+        type: ChannelType3.GROUP,
+        channelId: this.spaceId,
+        serverId: userId,
+        worldId,
+        metadata: {
+          spaceInfo: {
+            title: config.title,
+            description: config.description,
+            startedAt: Date.now(),
+            mode: config.mode,
+            languages: config.languages,
+            isRecording: config.record
+          }
+        }
+      });
+      if (this.runtime.getModel(ModelType3.TEXT_TO_SPEECH) && this.runtime.getModel(ModelType3.TRANSCRIPTION)) {
         logger3.log("[Space] Using SttTtsPlugin");
         this.currentSpace.use(this.sttTtsPlugin, {
           runtime: this.runtime,
@@ -7238,10 +7182,8 @@ var TwitterSpaceClient = class {
         );
       }
       this.spaceStatus = "hosting" /* HOSTING */;
-      await this.twitterClient.sendTweet(
-        broadcastInfo.share_url.replace("broadcasts", "spaces")
-      );
       const spaceUrl = broadcastInfo.share_url.replace("broadcasts", "spaces");
+      await this.twitterClient.sendTweet(spaceUrl);
       logger3.log(`[Space] Space started => ${spaceUrl}`);
       await speakFiller(this.client.runtime, this.sttTtsPlugin, "WELCOME");
       this.currentSpace.on("occupancyUpdate", (update) => {
@@ -7566,7 +7508,7 @@ var spaceJoin_default = {
     for (const response of responses) {
       await callback(response.content);
     }
-    const manager = runtime.getService(ServiceTypes.TWITTER);
+    const manager = runtime.getService(ServiceType.TWITTER);
     if (!manager) {
       throw new Error("Twitter client manager not found");
     }
@@ -7671,10 +7613,9 @@ var spaceJoin_default = {
 };
 
 // src/base.ts
-import { EventEmitter as EventEmitter6 } from "node:events";
 import {
-  ChannelType as ChannelType3,
-  createUniqueUuid as createUniqueUuid3,
+  ChannelType as ChannelType4,
+  createUniqueUuid as createUniqueUuid4,
   logger as logger5
 } from "@elizaos/core";
 var RequestQueue = class {
@@ -7744,9 +7685,8 @@ var RequestQueue = class {
     await new Promise((resolve) => setTimeout(resolve, delay));
   }
 };
-var _ClientBase = class _ClientBase extends EventEmitter6 {
+var _ClientBase = class _ClientBase {
   constructor(runtime, state) {
-    super();
     this.lastCheckedTweetId = null;
     this.temperature = 0.5;
     this.requestQueue = new RequestQueue();
@@ -7838,7 +7778,7 @@ var _ClientBase = class _ClientBase extends EventEmitter6 {
       conversationId: raw.conversationId ?? raw.legacy?.conversation_id_str,
       hashtags: raw.hashtags ?? raw.legacy?.entities?.hashtags ?? [],
       html: raw.html,
-      id: raw.id ?? raw.rest_id ?? raw.id_str ?? void 0,
+      id: raw.id ?? raw.rest_id ?? raw.legacy.id_str ?? raw.id_str ?? void 0,
       inReplyToStatus: raw.inReplyToStatus,
       inReplyToStatusId: raw.inReplyToStatusId ?? raw.legacy?.in_reply_to_status_id_str ?? void 0,
       isQuoted: raw.legacy?.is_quote_status === true,
@@ -7852,7 +7792,7 @@ var _ClientBase = class _ClientBase extends EventEmitter6 {
       mentions: raw.mentions ?? raw.legacy?.entities?.user_mentions ?? [],
       permanentUrl: raw.permanentUrl ?? (raw.core?.user_results?.result?.legacy?.screen_name && raw.rest_id ? `https://x.com/${raw.core?.user_results?.result?.legacy?.screen_name}/status/${raw.rest_id}` : void 0),
       photos: raw.photos ?? (raw.legacy?.entities?.media?.filter((media) => media.type === "photo").map((media) => ({
-        id: media.id_str,
+        id: media.id_str || media.rest_id || media.legacy.id_str,
         url: media.media_url_https,
         alt_text: media.alt_text
       })) || []),
@@ -7881,6 +7821,7 @@ var _ClientBase = class _ClientBase extends EventEmitter6 {
     return t;
   }
   async init() {
+    await this.runtime.ensureAgentExists(this.runtime.character);
     const username = this.state?.TWITTER_USERNAME || this.runtime.getSetting("TWITTER_USERNAME");
     const password = this.state?.TWITTER_PASSWORD || this.runtime.getSetting("TWITTER_PASSWORD");
     const email = this.state?.TWITTER_EMAIL || this.runtime.getSetting("TWITTER_EMAIL");
@@ -7945,7 +7886,7 @@ var _ClientBase = class _ClientBase extends EventEmitter6 {
         }
       }
     }
-    if (retryCount === maxRetries) {
+    if (retryCount >= maxRetries) {
       throw new Error(
         `Twitter login failed after ${maxRetries} attempts. Last error: ${lastError?.message}`
       );
@@ -7981,7 +7922,6 @@ var _ClientBase = class _ClientBase extends EventEmitter6 {
   async fetchHomeTimeline(count, following) {
     logger5.debug("fetching home timeline");
     const homeTimeline = following ? await this.twitterClient.fetchFollowingTimeline(count, []) : await this.twitterClient.fetchHomeTimeline(count, []);
-    logger5.debug(homeTimeline);
     const processedTimeline = homeTimeline.filter((t) => t.__typename !== "TweetWithVisibilityResults").map((tweet) => this.parseTweet(tweet));
     return processedTimeline;
   }
@@ -8016,59 +7956,75 @@ var _ClientBase = class _ClientBase extends EventEmitter6 {
     logger5.debug("populating timeline...");
     const cachedTimeline = await this.getCachedTimeline();
     if (cachedTimeline) {
-      const existingMemories2 = await this.runtime.getMemoryManager("messages").getMemoriesByRoomIds({
+      const existingMemories2 = await this.runtime.getMemoriesByRoomIds({
+        tableName: "messages",
         roomIds: cachedTimeline.map(
-          (tweet) => createUniqueUuid3(this.runtime, tweet.conversationId)
+          (tweet) => createUniqueUuid4(this.runtime, tweet.conversationId)
         )
       });
       const existingMemoryIds2 = new Set(
         existingMemories2.map((memory) => memory.id.toString())
       );
       const someCachedTweetsExist = cachedTimeline.some(
-        (tweet) => existingMemoryIds2.has(createUniqueUuid3(this.runtime, tweet.id))
+        (tweet) => existingMemoryIds2.has(createUniqueUuid4(this.runtime, tweet.id))
       );
       if (someCachedTweetsExist) {
         const tweetsToSave2 = cachedTimeline.filter(
-          (tweet) => tweet.userId !== this.profile.id && !existingMemoryIds2.has(createUniqueUuid3(this.runtime, tweet.id))
+          (tweet) => tweet.userId !== this.profile.id && !existingMemoryIds2.has(createUniqueUuid4(this.runtime, tweet.id))
         );
         for (const tweet of tweetsToSave2) {
           logger5.log("Saving Tweet", tweet.id);
           if (tweet.userId === this.profile.id) {
             continue;
           }
-          const roomId = createUniqueUuid3(this.runtime, tweet.conversationId);
-          const entityId = createUniqueUuid3(
-            this.runtime,
-            tweet.userId === this.profile.id ? this.runtime.agentId : tweet.userId
-          );
+          const worldId = createUniqueUuid4(this.runtime, tweet.userId);
+          await this.runtime.ensureWorldExists({
+            id: worldId,
+            name: `${tweet.username}'s Twitter`,
+            agentId: this.runtime.agentId,
+            serverId: tweet.userId,
+            metadata: {
+              ownership: { ownerId: tweet.userId },
+              twitter: {
+                username: tweet.username,
+                id: tweet.userId
+              }
+            }
+          });
+          const roomId = createUniqueUuid4(this.runtime, tweet.conversationId);
+          await this.runtime.ensureRoomExists({
+            id: roomId,
+            name: `${tweet.username}'s Thread`,
+            source: "twitter",
+            type: ChannelType4.FEED,
+            channelId: tweet.conversationId,
+            serverId: tweet.userId,
+            worldId
+          });
+          const entityId = tweet.userId === this.profile.id ? this.runtime.agentId : createUniqueUuid4(this.runtime, tweet.userId);
           await this.runtime.ensureConnection({
             entityId,
             roomId,
             userName: tweet.username,
             name: tweet.name,
             source: "twitter",
-            type: ChannelType3.FEED
+            type: ChannelType4.FEED,
+            worldId
           });
           const content = {
             text: tweet.text,
             url: tweet.permanentUrl,
             source: "twitter",
-            inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid3(this.runtime, tweet.inReplyToStatusId) : void 0
+            inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid4(this.runtime, tweet.inReplyToStatusId) : void 0
           };
-          logger5.log("Creating memory for tweet", tweet.id);
-          const memory = await this.runtime.getMemoryManager("messages").getMemoryById(createUniqueUuid3(this.runtime, tweet.id));
-          if (memory) {
-            logger5.log("Memory already exists, skipping timeline population");
-            break;
-          }
-          await this.runtime.getMemoryManager("messages").createMemory({
-            id: createUniqueUuid3(this.runtime, tweet.id),
+          await this.runtime.createMemory({
+            id: createUniqueUuid4(this.runtime, tweet.id),
             entityId,
             content,
             agentId: this.runtime.agentId,
             roomId,
             createdAt: tweet.timestamp * 1e3
-          });
+          }, "messages");
           await this.cacheTweet(tweet);
         }
         logger5.log(
@@ -8089,16 +8045,17 @@ var _ClientBase = class _ClientBase extends EventEmitter6 {
     const roomIds = /* @__PURE__ */ new Set();
     for (const tweet of allTweets) {
       tweetIdsToCheck.add(tweet.id);
-      roomIds.add(createUniqueUuid3(this.runtime, tweet.conversationId));
+      roomIds.add(createUniqueUuid4(this.runtime, tweet.conversationId));
     }
-    const existingMemories = await this.runtime.getMemoryManager("messages").getMemoriesByRoomIds({
+    const existingMemories = await this.runtime.getMemoriesByRoomIds({
+      tableName: "messages",
       roomIds: Array.from(roomIds)
     });
     const existingMemoryIds = new Set(
       existingMemories.map((memory) => memory.id)
     );
     const tweetsToSave = allTweets.filter(
-      (tweet) => tweet.userId !== this.profile.id && !existingMemoryIds.has(createUniqueUuid3(this.runtime, tweet.id))
+      (tweet) => tweet.userId !== this.profile.id && !existingMemoryIds.has(createUniqueUuid4(this.runtime, tweet.id))
     );
     logger5.debug({
       processingTweets: tweetsToSave.map((tweet) => tweet.id).join(",")
@@ -8108,30 +8065,54 @@ var _ClientBase = class _ClientBase extends EventEmitter6 {
       if (tweet.userId === this.profile.id) {
         continue;
       }
-      const roomId = createUniqueUuid3(this.runtime, tweet.conversationId);
-      const entityId = tweet.userId === this.profile.id ? this.runtime.agentId : createUniqueUuid3(this.runtime, tweet.userId);
+      const worldId = createUniqueUuid4(this.runtime, tweet.userId);
+      await this.runtime.ensureWorldExists({
+        id: worldId,
+        name: `${tweet.username}'s Twitter`,
+        agentId: this.runtime.agentId,
+        serverId: tweet.userId,
+        metadata: {
+          ownership: { ownerId: tweet.userId },
+          twitter: {
+            username: tweet.username,
+            id: tweet.userId
+          }
+        }
+      });
+      const roomId = createUniqueUuid4(this.runtime, tweet.conversationId);
+      await this.runtime.ensureRoomExists({
+        id: roomId,
+        name: `${tweet.username}'s Thread`,
+        source: "twitter",
+        type: ChannelType4.FEED,
+        channelId: tweet.conversationId,
+        serverId: tweet.userId,
+        worldId
+      });
+      const entityId = tweet.userId === this.profile.id ? this.runtime.agentId : createUniqueUuid4(this.runtime, tweet.userId);
       await this.runtime.ensureConnection({
         entityId,
         roomId,
         userName: tweet.username,
         name: tweet.name,
         source: "twitter",
-        type: ChannelType3.FEED
+        type: ChannelType4.FEED,
+        worldId
       });
       const content = {
         text: tweet.text,
         url: tweet.permanentUrl,
         source: "twitter",
-        inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid3(this.runtime, tweet.inReplyToStatusId) : void 0
+        inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid4(this.runtime, tweet.inReplyToStatusId) : void 0
       };
-      await this.runtime.getMemoryManager("messages").createMemory({
-        id: createUniqueUuid3(this.runtime, tweet.id),
+      await this.runtime.createMemory({
+        id: createUniqueUuid4(this.runtime, tweet.id),
         entityId,
         content,
         agentId: this.runtime.agentId,
         roomId,
         createdAt: tweet.timestamp * 1e3
-      });
+      }, "messages");
       await this.cacheTweet(tweet);
     }
     await this.cacheTimeline(timeline);
@@ -8145,7 +8126,8 @@ var _ClientBase = class _ClientBase extends EventEmitter6 {
   }
   async saveRequestMessage(message, state) {
     if (message.content.text) {
-      const recentMessage = await this.runtime.getMemoryManager("messages").getMemories({
+      const recentMessage = await this.runtime.getMemories({
+        tableName: "messages",
         roomId: message.roomId,
         count: 1,
         unique: false
@@ -8153,7 +8135,7 @@ var _ClientBase = class _ClientBase extends EventEmitter6 {
       if (recentMessage.length > 0 && recentMessage[0].content === message.content) {
         logger5.debug("Message already saved", recentMessage[0].id);
       } else {
-        await this.runtime.getMemoryManager("messages").createMemory(message);
+        await this.runtime.createMemory(message, "messages");
       }
       await this.runtime.evaluate(message, {
         ...state,
@@ -8233,102 +8215,30 @@ var _ClientBase = class _ClientBase extends EventEmitter6 {
    */
   async fetchInteractions() {
     try {
-      const interactions = await this.requestQueue.add(
-        () => this.twitterClient.get("statuses/mentions_timeline", {
-          count: 100,
-          include_entities: true
-        })
+      const username = this.profile.username;
+      const mentionsResponse = await this.requestQueue.add(
+        () => this.twitterClient.fetchSearchTweets(
+          `@${username}`,
+          100,
+          1 /* Latest */
+        )
       );
-      return interactions.map((interaction) => ({
-        id: interaction.id_str,
-        type: this.getInteractionType(interaction),
-        userId: interaction.user.id_str,
-        username: interaction.user.screen_name,
-        name: interaction.user.name,
-        targetTweetId: interaction.in_reply_to_status_id_str || interaction.quoted_status_id_str,
-        targetTweet: interaction.quoted_status || interaction,
-        quoteTweet: interaction.is_quote_status ? interaction : void 0,
-        retweetId: interaction.retweeted_status?.id_str
+      return mentionsResponse.tweets.map((tweet) => ({
+        id: tweet.id,
+        type: tweet.isQuoted ? "quote" : tweet.retweetedStatus ? "retweet" : "like",
+        userId: tweet.userId,
+        username: tweet.username,
+        name: tweet.name || tweet.username,
+        targetTweetId: tweet.inReplyToStatusId || tweet.quotedStatusId,
+        targetTweet: tweet.quotedStatus || tweet,
+        quoteTweet: tweet.isQuoted ? tweet : void 0,
+        retweetId: tweet.retweetedStatus?.id
       }));
     } catch (error) {
       logger5.error("Error fetching Twitter interactions:", error);
       return [];
     }
   }
-  /**
-   * Determines the type of interaction from a Twitter API response
-   */
-  getInteractionType(interaction) {
-    if (interaction.retweeted_status) {
-      return "retweet";
-    }
-    if (interaction.is_quote_status) {
-      return "quote";
-    }
-    return "like";
-  }
-  /**
-   * Fetches recent follower changes (new followers and unfollowers)
-   */
-  async fetchFollowerChanges() {
-    try {
-      const currentFollowers = await this.requestQueue.add(
-        () => this.twitterClient.get("followers/list", {
-          count: 200,
-          include_user_entities: false
-        })
-      );
-      const cachedFollowers = await this.getCachedFollowers();
-      const changes = [];
-      for (const follower of currentFollowers.users) {
-        if (!cachedFollowers.some(
-          (f) => f.id_str === follower.id_str
-        )) {
-          changes.push({
-            type: "followed",
-            userId: follower.id_str,
-            username: follower.screen_name,
-            name: follower.name,
-            user: follower
-          });
-        }
-      }
-      for (const cached of cachedFollowers) {
-        if (!currentFollowers.users.some((f) => f.id_str === cached.id_str)) {
-          changes.push({
-            type: "unfollowed",
-            userId: cached.id_str,
-            username: cached.screen_name,
-            name: cached.name,
-            user: cached
-          });
-        }
-      }
-      await this.cacheFollowers(currentFollowers.users);
-      return changes;
-    } catch (error) {
-      logger5.error("Error fetching Twitter follower changes:", error);
-      return [];
-    }
-  }
-  /**
-   * Gets cached followers from the database
-   */
-  async getCachedFollowers() {
-    const cached = await this.runtime.getCache(
-      `twitter/${this.profile.username}/followers`
-    );
-    return cached || [];
-  }
-  /**
-   * Caches current followers in the database
-   */
-  async cacheFollowers(followers) {
-    await this.runtime.setCache(
-      `twitter/${this.profile.username}/followers`,
-      followers
-    );
-  }
 };
 _ClientBase._twitterClients = {};
 var ClientBase = _ClientBase;
@@ -8338,16 +8248,16 @@ var TWITTER_SERVICE_NAME = "twitter";
 
 // src/interactions.ts
 import {
-  ChannelType as ChannelType4,
+  ChannelType as ChannelType5,
   EventTypes as EventTypes2,
-  ModelTypes as ModelTypes4,
+  ModelType as ModelType4,
   composePrompt as composePrompt2,
-  createUniqueUuid as createUniqueUuid4,
+  createUniqueUuid as createUniqueUuid5,
   logger as logger6
 } from "@elizaos/core";
 
 // src/types.ts
-var ServiceTypes2 = {
+var ServiceType2 = {
   TWITTER: "twitter"
 };
 
@@ -8417,48 +8327,75 @@ var TwitterInteractionClient = class {
       uniqueTweetCandidates = uniqueTweetCandidates.sort((a, b) => a.id.localeCompare(b.id)).filter((tweet) => tweet.userId !== this.client.profile.id);
       for (const tweet of uniqueTweetCandidates) {
         if (!this.client.lastCheckedTweetId || BigInt(tweet.id) > this.client.lastCheckedTweetId) {
-          const tweetId = createUniqueUuid4(this.runtime, tweet.id);
-          const existingResponse = await this.runtime.getMemoryManager("messages").getMemoryById(tweetId);
+          const tweetId = createUniqueUuid5(this.runtime, tweet.id);
+          const existingResponse = await this.runtime.getMemoryById(tweetId);
           if (existingResponse) {
             logger6.log(`Already responded to tweet ${tweet.id}, skipping`);
             continue;
           }
           logger6.log("New Tweet found", tweet.permanentUrl);
-          const roomId = createUniqueUuid4(this.runtime, tweet.conversationId);
-          const entityId = createUniqueUuid4(
+          const entityId = createUniqueUuid5(
             this.runtime,
             tweet.userId === this.client.profile.id ? this.runtime.agentId : tweet.userId
           );
+          const worldId = createUniqueUuid5(this.runtime, tweet.userId);
+          const roomId = createUniqueUuid5(this.runtime, tweet.conversationId);
+          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,
             source: "twitter",
-            type: ChannelType4.GROUP
+            type: ChannelType5.GROUP,
+            channelId: tweet.conversationId,
+            serverId: tweet.userId,
+            worldId
+          });
+          await this.runtime.ensureRoomExists({
+            id: roomId,
+            name: `Conversation with ${tweet.name}`,
+            source: "twitter",
+            type: ChannelType5.GROUP,
+            channelId: tweet.conversationId,
+            serverId: tweet.userId,
+            worldId
           });
-          const thread = await buildConversationThread(tweet, this.client);
-          const message = {
+          const memory = {
+            id: tweetId,
+            agentId: this.runtime.agentId,
             content: {
               text: tweet.text,
+              url: tweet.permanentUrl,
               imageUrls: tweet.photos?.map((photo) => photo.url) || [],
-              tweet,
-              source: "twitter"
+              inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid5(this.runtime, tweet.inReplyToStatusId) : void 0,
+              source: "twitter",
+              channelType: ChannelType5.GROUP
             },
-            agentId: this.runtime.agentId,
             entityId,
-            roomId
+            roomId,
+            createdAt: tweet.timestamp * 1e3
           };
+          await this.runtime.createMemory(memory, "messages");
           if (tweet.text.includes(`@${twitterUsername}`)) {
             const messagePayload = {
               runtime: this.runtime,
               message: {
-                ...message,
-                content: {
-                  ...message.content,
-                  source: "twitter"
-                },
-                roomId: message.roomId
+                ...memory,
+                source: "twitter"
               },
               source: "twitter",
               callback: async (response) => {
@@ -8470,12 +8407,8 @@ var TwitterInteractionClient = class {
             const mentionPayload = {
               runtime: this.runtime,
               message: {
-                ...message,
-                content: {
-                  ...message.content,
-                  source: "twitter"
-                },
-                roomId: message.roomId
+                ...memory,
+                source: "twitter"
               },
               tweet: convertToCoreTweet(tweet),
               user: {
@@ -8491,10 +8424,10 @@ var TwitterInteractionClient = class {
             };
             this.runtime.emitEvent("TWITTER_MENTION_RECEIVED" /* MENTION_RECEIVED */, mentionPayload);
           }
-          if (thread.length > 1) {
+          if (tweet.thread.length > 1) {
             const threadPayload = {
               runtime: this.runtime,
-              tweets: convertToCoreTweets(thread),
+              tweets: convertToCoreTweets(tweet.thread),
               user: {
                 id: tweet.userId,
                 username: tweet.username,
@@ -8502,19 +8435,19 @@ var TwitterInteractionClient = class {
               },
               source: "twitter"
             };
-            if (thread[thread.length - 1].id === tweet.id) {
+            if (tweet.thread[tweet.thread.length - 1].id === tweet.id) {
               this.runtime.emitEvent("TWITTER_THREAD_UPDATED" /* THREAD_UPDATED */, {
                 ...threadPayload,
                 newTweet: convertToCoreTweet(tweet)
               });
-            } else if (thread[0].id === tweet.id) {
+            } else if (tweet.thread[0].id === tweet.id) {
               this.runtime.emitEvent("TWITTER_THREAD_CREATED" /* THREAD_CREATED */, threadPayload);
             }
           }
           await this.handleTweet({
             tweet,
-            message,
-            thread
+            message: memory,
+            thread: tweet.thread
           });
           this.client.lastCheckedTweetId = BigInt(tweet.id);
         }
@@ -8528,15 +8461,15 @@ var TwitterInteractionClient = class {
             interaction.userId,
             interaction.targetTweet.conversationId
           );
-          await this.runtime.getMemoryManager("interactions").createMemory(memory);
+          await this.runtime.createMemory(memory, "messages");
           const reactionMessage = {
-            id: createUniqueUuid4(this.runtime, interaction.targetTweetId),
+            id: createUniqueUuid5(this.runtime, interaction.targetTweetId),
             content: {
               text: interaction.targetTweet.text,
               source: "twitter"
             },
-            entityId: createUniqueUuid4(this.runtime, interaction.targetTweet.userId),
-            roomId: createUniqueUuid4(this.runtime, interaction.targetTweet.conversationId),
+            entityId: createUniqueUuid5(this.runtime, interaction.targetTweet.userId),
+            roomId: createUniqueUuid5(this.runtime, interaction.targetTweet.conversationId),
             agentId: this.runtime.agentId
           };
           const basePayload = {
@@ -8559,7 +8492,7 @@ var TwitterInteractionClient = class {
                 ...basePayload,
                 reaction: {
                   type: "like",
-                  entityId: createUniqueUuid4(this.runtime, interaction.userId)
+                  entityId: createUniqueUuid5(this.runtime, interaction.userId)
                 },
                 message: reactionMessage,
                 callback: async () => {
@@ -8579,7 +8512,7 @@ var TwitterInteractionClient = class {
                 ...basePayload,
                 reaction: {
                   type: "retweet",
-                  entityId: createUniqueUuid4(this.runtime, interaction.userId)
+                  entityId: createUniqueUuid5(this.runtime, interaction.userId)
                 },
                 message: reactionMessage,
                 callback: async () => {
@@ -8597,7 +8530,7 @@ var TwitterInteractionClient = class {
                 callback: async () => [],
                 reaction: {
                   type: "quote",
-                  entityId: createUniqueUuid4(this.runtime, interaction.userId)
+                  entityId: createUniqueUuid5(this.runtime, interaction.userId)
                 }
               };
               this.runtime.emitEvent("TWITTER_QUOTE_RECEIVED" /* QUOTE_RECEIVED */, quotePayload);
@@ -8605,7 +8538,7 @@ var TwitterInteractionClient = class {
                 ...basePayload,
                 reaction: {
                   type: "quote",
-                  entityId: createUniqueUuid4(this.runtime, interaction.userId)
+                  entityId: createUniqueUuid5(this.runtime, interaction.userId)
                 },
                 message: reactionMessage,
                 callback: async () => {
@@ -8632,43 +8565,9 @@ var TwitterInteractionClient = class {
             change.userId,
             profileId
           );
-          await this.runtime.getMemoryManager("follower-changes").createMemory(followerMemory);
+          await this.runtime.createMemory(followerMemory, "follower-changes");
         }
       };
-      const followerChanges = await this.client.fetchFollowerChanges();
-      for (const change of followerChanges) {
-        const changeId = createUniqueUuid4(this.runtime, `${change.type}-${change.userId}`);
-        const existingChange = await this.runtime.getMemoryManager("follower-changes").getMemoryById(changeId);
-        if (existingChange) continue;
-        const entityId = createUniqueUuid4(this.runtime, change.userId);
-        const basePayload = {
-          runtime: this.runtime,
-          user: {
-            id: change.userId,
-            username: change.username,
-            name: change.name
-          },
-          source: "twitter"
-        };
-        if (change.type === "followed") {
-          const userFollowedPayload = {
-            ...basePayload,
-            follower: change.user,
-            entityId: createUniqueUuid4(this.runtime, change.userId),
-            roomId: createUniqueUuid4(this.runtime, this.client.profile.id)
-          };
-          this.runtime.emitEvent("TWITTER_USER_FOLLOWED" /* USER_FOLLOWED */, userFollowedPayload);
-        } else if (change.type === "unfollowed") {
-          const userUnfollowedPayload = {
-            ...basePayload,
-            unfollower: change.user,
-            entityId: createUniqueUuid4(this.runtime, change.userId),
-            roomId: createUniqueUuid4(this.runtime, this.client.profile.id)
-          };
-          this.runtime.emitEvent("TWITTER_USER_UNFOLLOWED" /* USER_UNFOLLOWED */, userUnfollowedPayload);
-        }
-        await processFollowerChange(change, this.client.profile.id);
-      }
       await this.client.cacheLatestCheckedTweetId();
       logger6.log("Finished checking Twitter interactions");
     } catch (error) {
@@ -8718,7 +8617,7 @@ var TwitterInteractionClient = class {
     try {
       for (const photo of tweet.photos) {
         const description = await this.runtime.useModel(
-          ModelTypes4.IMAGE_DESCRIPTION,
+          ModelType4.IMAGE_DESCRIPTION,
           photo.url
         );
         imageDescriptionsArray.push(description);
@@ -8733,27 +8632,27 @@ var TwitterInteractionClient = class {
       currentPost,
       formattedConversation
     };
-    const tweetId = createUniqueUuid4(this.runtime, tweet.id);
-    const tweetExists = await this.runtime.getMemoryManager("messages").getMemoryById(tweetId);
+    const tweetId = createUniqueUuid5(this.runtime, tweet.id);
+    const tweetExists = await this.runtime.getMemoryById(tweetId);
     if (!tweetExists) {
       logger6.log("tweet does not exist, saving");
-      const entityId = createUniqueUuid4(this.runtime, tweet.userId);
-      const roomId = createUniqueUuid4(this.runtime, tweet.conversationId);
+      const entityId = createUniqueUuid5(this.runtime, tweet.userId);
+      const roomId = createUniqueUuid5(this.runtime, tweet.conversationId);
       await this.runtime.ensureConnection({
         entityId,
         roomId,
         userName: tweet.username,
         name: tweet.name,
         source: "twitter",
-        type: ChannelType4.GROUP
+        type: ChannelType5.GROUP
       });
       await this.runtime.ensureRoomExists({
         id: roomId,
         name: `Conversation with ${tweet.name}`,
         source: "twitter",
-        type: ChannelType4.GROUP,
+        type: ChannelType5.GROUP,
         channelId: tweet.conversationId,
-        worldId: createUniqueUuid4(this.runtime, tweet.userId)
+        worldId: createUniqueUuid5(this.runtime, tweet.userId)
       });
       const memory = {
         id: tweetId,
@@ -8762,9 +8661,9 @@ var TwitterInteractionClient = class {
           text: tweet.text,
           url: tweet.permanentUrl,
           imageUrls: tweet.photos?.map((photo) => photo.url) || [],
-          inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid4(this.runtime, tweet.inReplyToStatusId) : void 0,
+          inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid5(this.runtime, tweet.inReplyToStatusId) : void 0,
           source: "twitter",
-          channelType: ChannelType4.GROUP
+          channelType: ChannelType5.GROUP
         },
         entityId,
         roomId,
@@ -8776,7 +8675,7 @@ var TwitterInteractionClient = class {
       state,
       template: this.runtime.character.templates?.shouldRespondTemplate || ""
     });
-    const response = await this.runtime.useModel(ModelTypes4.TEXT_SMALL, {
+    const response = await this.runtime.useModel(ModelType4.TEXT_SMALL, {
       prompt: shouldRespondPrompt
     });
     const responseActions = (response.match(/(?:RESPOND|IGNORE|STOP)/g) || [
@@ -8808,9 +8707,9 @@ var TwitterInteractionClient = class {
         if (!replyTweetResult) {
           throw new Error("Failed to create tweet response");
         }
-        const responseId = createUniqueUuid4(
+        const responseId = createUniqueUuid5(
           this.runtime,
-          replyTweetResult.id_str
+          replyTweetResult.id_str || replyTweetResult.rest_id || replyTweetResult.legacy.id_str || replyTweetResult.id
         );
         const responseMemory = {
           id: responseId,
@@ -8823,7 +8722,7 @@ var TwitterInteractionClient = class {
           },
           createdAt: Date.now()
         };
-        await this.runtime.getMemoryManager("messages").createMemory(responseMemory);
+        await this.runtime.createMemory(responseMemory, "messages");
         return [responseMemory];
       } catch (error) {
         logger6.error("Error replying to tweet:", error);
@@ -8862,32 +8761,32 @@ var TwitterInteractionClient = class {
         logger6.log("Reached maximum reply depth", depth);
         return;
       }
-      const memory = await this.runtime.getMemoryManager("messages").getMemoryById(createUniqueUuid4(this.runtime, currentTweet.id));
+      const memory = await this.runtime.getMemoryById(createUniqueUuid5(this.runtime, currentTweet.id));
       if (!memory) {
-        const roomId = createUniqueUuid4(this.runtime, tweet.conversationId);
-        const entityId = createUniqueUuid4(this.runtime, currentTweet.userId);
+        const roomId = createUniqueUuid5(this.runtime, tweet.conversationId);
+        const entityId = createUniqueUuid5(this.runtime, currentTweet.userId);
         await this.runtime.ensureConnection({
           entityId,
           roomId,
           userName: currentTweet.username,
           name: currentTweet.name,
           source: "twitter",
-          type: ChannelType4.GROUP
+          type: ChannelType5.GROUP
         });
-        this.runtime.getMemoryManager("messages").createMemory({
-          id: createUniqueUuid4(this.runtime, currentTweet.id),
+        this.runtime.createMemory({
+          id: createUniqueUuid5(this.runtime, currentTweet.id),
           agentId: this.runtime.agentId,
           content: {
             text: currentTweet.text,
             source: "twitter",
             url: currentTweet.permanentUrl,
             imageUrls: currentTweet.photos?.map((photo) => photo.url) || [],
-            inReplyTo: currentTweet.inReplyToStatusId ? createUniqueUuid4(this.runtime, currentTweet.inReplyToStatusId) : void 0
+            inReplyTo: currentTweet.inReplyToStatusId ? createUniqueUuid5(this.runtime, currentTweet.inReplyToStatusId) : void 0
           },
           createdAt: currentTweet.timestamp * 1e3,
           roomId,
-          entityId: currentTweet.userId === this.twitterUserId ? this.runtime.agentId : createUniqueUuid4(this.runtime, currentTweet.userId)
-        });
+          entityId: currentTweet.userId === this.twitterUserId ? this.runtime.agentId : createUniqueUuid5(this.runtime, currentTweet.userId)
+        }, "messages");
       }
       if (visited.has(currentTweet.id)) {
         logger6.log("Already visited tweet:", currentTweet.id);
@@ -8928,10 +8827,10 @@ var TwitterInteractionClient = class {
   }
   createMemoryObject(type, id, userId, roomId) {
     return {
-      id: createUniqueUuid4(this.runtime, id),
+      id: createUniqueUuid5(this.runtime, id),
       agentId: this.runtime.agentId,
-      entityId: createUniqueUuid4(this.runtime, userId),
-      roomId: createUniqueUuid4(this.runtime, roomId),
+      entityId: createUniqueUuid5(this.runtime, userId),
+      roomId: createUniqueUuid5(this.runtime, roomId),
       content: {
         type,
         source: "twitter"
@@ -8943,23 +8842,12 @@ var TwitterInteractionClient = class {
 
 // src/post.ts
 import {
-  ChannelType as ChannelType5,
-  ModelTypes as ModelTypes5,
-  composePrompt as composePrompt3,
-  createUniqueUuid as createUniqueUuid5,
+  ChannelType as ChannelType6,
+  EventTypes as EventTypes3,
+  createUniqueUuid as createUniqueUuid6,
   logger as logger7,
-  parseJSONObjectFromText,
   truncateToCompleteSentence
 } from "@elizaos/core";
-
-// src/templates.ts
-var twitterPostTemplate = `# Task: Create a post in the voice and style and perspective of {{agentName}} @{{twitterUserName}}.
-{{providers}}
-Write a post that is {{adjective}} about {{topic}} (without mentioning {{topic}} directly), from the perspective of {{agentName}}. Do not add commentary or acknowledge this request, just write the post.
-Your response should be 1, 2, or 3 sentences (choose the length at random).
-Your response should not contain any questions. Brief, concise statements only. The total character count MUST be less than 280. No emojis. Use \\n\\n (double spaces) between statements if there are multiple statements in your response.`;
-
-// src/post.ts
 var TwitterPostClient = class {
   /**
    * Constructor for initializing a new Twitter client with the provided client, runtime, and state
@@ -8977,7 +8865,7 @@ var TwitterPostClient = class {
     logger7.log(`- Username: ${this.twitterUsername}`);
     logger7.log(`- Dry Run Mode: ${this.isDryRun ? "Enabled" : "Disabled"}`);
     logger7.log(
-      `- Disable Post: ${this.state?.TWITTER_ENABLE_POST_GENERATION || this.runtime.getSetting("TWITTER_ENABLE_POST_GENERATION") ? "disabled" : "enabled"}`
+      `- Auto-post: ${this.state?.TWITTER_ENABLE_POST_GENERATION || this.runtime.getSetting("TWITTER_ENABLE_POST_GENERATION") ? "disabled" : "enabled"}`
     );
     logger7.log(
       `- Post Interval: ${this.state?.TWITTER_POST_INTERVAL_MIN || this.runtime.getSetting("TWITTER_POST_INTERVAL_MIN")}-${this.state?.TWITTER_POST_INTERVAL_MAX || this.runtime.getSetting("TWITTER_POST_INTERVAL_MAX")} minutes`
@@ -9007,6 +8895,10 @@ var TwitterPostClient = class {
       setTimeout(generateNewTweetLoop, interval);
     };
     setTimeout(generateNewTweetLoop, 60 * 1e3);
+    if (this.runtime.getSetting("TWITTER_POST_IMMEDIATELY")) {
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      this.generateNewTweet();
+    }
   }
   /**
    * Creates a Tweet object based on the tweet result, client information, and Twitter username.
@@ -9057,11 +8949,11 @@ var TwitterPostClient = class {
       id: roomId,
       name: "Twitter Feed",
       source: "twitter",
-      type: ChannelType5.FEED
+      type: ChannelType6.FEED
     });
     await runtime.ensureParticipantInRoom(runtime.agentId, roomId);
-    await runtime.getMemoryManager("messages").createMemory({
-      id: createUniqueUuid5(this.runtime, tweet.id),
+    await runtime.createMemory({
+      id: createUniqueUuid6(this.runtime, tweet.id),
       entityId: runtime.agentId,
       agentId: runtime.agentId,
       content: {
@@ -9071,7 +8963,7 @@ var TwitterPostClient = class {
       },
       roomId,
       createdAt: tweet.timestamp
-    });
+    }, "messages");
   }
   /**
    * Handles sending a note tweet with optional media data.
@@ -9172,94 +9064,45 @@ var TwitterPostClient = class {
    */
   async generateNewTweet() {
     try {
-      logger7.log("Generating new tweet...");
       const userId = this.client.profile?.id;
       if (!userId) {
         logger7.error("Cannot generate tweet: Twitter profile not available");
         return;
       }
-      const worldId = createUniqueUuid5(this.runtime, userId);
-      const timelineRoomId = createUniqueUuid5(this.runtime, `${userId}-home`);
-      const state = await this.runtime.composeState(null, [
-        "CHARACTER",
-        "RECENT_MESSAGES",
-        "TIME"
-      ]);
-      const tweetPrompt = composePrompt3({
-        state,
-        template: this.runtime.character.templates?.twitterPostTemplate || twitterPostTemplate
-      });
-      const response = await this.runtime.useModel(ModelTypes5.TEXT_LARGE, {
-        prompt: tweetPrompt
-      });
-      const jsonResponse = parseJSONObjectFromText(response);
-      if (!jsonResponse || !jsonResponse.text) {
-        logger7.error("Failed to generate valid tweet content");
-        return;
-      }
-      const cleanedText = this.cleanupTweetText(jsonResponse.text);
-      const mediaData = [];
-      if (jsonResponse.imagePrompt) {
-        try {
-          const imagePromptMedia = Array.isArray(jsonResponse.imagePrompt) ? jsonResponse.imagePrompt.map((prompt) => ({
-            url: prompt,
-            contentType: "image/png"
-          })) : [{
-            url: jsonResponse.imagePrompt,
-            contentType: "image/png"
-          }];
-          const fetchedMedia = await fetchMediaData(imagePromptMedia);
-          mediaData.push(...fetchedMedia);
-        } catch (error) {
-          logger7.error("Error fetching media for tweet:", error);
-        }
-      }
-      const tweetId = createUniqueUuid5(this.runtime, `tweet-${Date.now()}`);
-      const memory = {
-        id: tweetId,
-        entityId: this.runtime.agentId,
-        agentId: this.runtime.agentId,
-        roomId: timelineRoomId,
-        content: {
-          text: cleanedText,
-          source: "twitter",
-          channelType: ChannelType5.FEED,
-          thought: jsonResponse.thought || "",
-          plan: jsonResponse.plan || "",
-          type: "post"
-        },
-        createdAt: Date.now()
-      };
+      const worldId = createUniqueUuid6(this.runtime, userId);
+      const roomId = createUniqueUuid6(this.runtime, `${userId}-home`);
       const callback = async (content) => {
         try {
           if (this.isDryRun) {
             logger7.info(`[DRY RUN] Would post tweet: ${content.text}`);
             return [];
           }
-          const result = await this.postToTwitter(content.text, mediaData);
+          const result = await this.postToTwitter(content.text, content.mediaData);
+          console.log("result is", result);
+          const tweetId = result.rest_id || result.id_str || result.legacy?.id_str;
           if (result) {
-            const postedTweetId = createUniqueUuid5(
+            const postedTweetId = createUniqueUuid6(
               this.runtime,
-              result.id_str
+              tweetId
             );
             const postedMemory = {
               id: postedTweetId,
               entityId: this.runtime.agentId,
               agentId: this.runtime.agentId,
-              roomId: timelineRoomId,
+              roomId,
               content: {
                 ...content,
                 source: "twitter",
-                channelType: ChannelType5.FEED,
+                channelType: ChannelType6.FEED,
                 type: "post",
                 metadata: {
-                  tweetId: result.id_str,
+                  tweetId,
                   postedAt: Date.now()
                 }
               },
               createdAt: Date.now()
             };
-            await this.runtime.getMemoryManager("messages").createMemory(postedMemory);
+            await this.runtime.createMemory(postedMemory, "messages");
             return [postedMemory];
           }
           return [];
@@ -9268,11 +9111,13 @@ var TwitterPostClient = class {
           return [];
         }
       };
-      this.runtime.emitEvent(["TWITTER_POST_GENERATED", "POST_GENERATED"], {
+      console.log("emitting event");
+      this.runtime.emitEvent([EventTypes3.POST_GENERATED, "TWITTER_POST_GENERATED" /* POST_GENERATED */], {
         runtime: this.runtime,
-        message: memory,
         callback,
-        source: "twitter"
+        worldId,
+        userId,
+        roomId
       });
     } catch (error) {
       logger7.error("Error generating tweet:", error);
@@ -9290,54 +9135,34 @@ var TwitterPostClient = class {
       if (mediaData && mediaData.length > 0) {
         for (const media of mediaData) {
           try {
-            const uploadResult = await this.client.requestQueue.add(
-              () => this.client.twitterClient.post("media/upload", {
-                media_data: Buffer.isBuffer(media.data) ? media.data : Buffer.from(String(media.data).split(",")[1], "base64")
-              })
-            );
-            if (uploadResult && uploadResult.media_id_string) {
-              mediaIds.push(uploadResult.media_id_string);
-            }
+            logger7.warn("Media upload not currently supported with the modern Twitter API");
           } catch (error) {
             logger7.error("Error uploading media:", error);
           }
         }
       }
-      const tweetParams = {
-        status: text.substring(0, 280)
-        // Twitter's character limit
-      };
-      if (mediaIds.length > 0) {
-        tweetParams.media_ids = mediaIds.join(",");
-      }
       const result = await this.client.requestQueue.add(
-        () => this.client.twitterClient.post("statuses/update", tweetParams)
+        () => this.client.twitterClient.sendTweet(text.substring(0, 280))
       );
-      return result;
+      const body = await result.json();
+      if (!body?.data?.create_tweet?.tweet_results?.result) {
+        logger7.error("Error sending tweet; Bad response:", body);
+        return null;
+      }
+      return body.data.create_tweet.tweet_results.result;
     } catch (error) {
       logger7.error("Error posting to Twitter:", error);
       throw error;
     }
   }
-  /**
-   * Cleans up a tweet text by removing quotes and fixing newlines
-   */
-  cleanupTweetText(text) {
-    let cleanedText = text.replace(/^['"](.*)['"]$/, "$1");
-    cleanedText = cleanedText.replaceAll(/\\n/g, "\n\n");
-    if (cleanedText.length > 280) {
-      cleanedText = truncateToCompleteSentence(cleanedText, 280);
-    }
-    return cleanedText;
-  }
   async stop() {
   }
 };
 
 // src/tests.ts
 import {
-  ModelTypes as ModelTypes6,
-  createUniqueUuid as createUniqueUuid6,
+  ModelType as ModelType6,
+  createUniqueUuid as createUniqueUuid7,
   logger as logger8,
   stringToUuid as stringToUuid2
 } from "@elizaos/core";
@@ -9392,7 +9217,7 @@ var TwitterTestSuite = class {
    */
   async testInitializingClient(runtime) {
     try {
-      const manager = runtime.getService(ServiceTypes2.TWITTER);
+      const manager = runtime.getService(ServiceType2.TWITTER);
       if (!manager) {
         throw new Error("Twitter client manager not found");
       }
@@ -9494,7 +9319,7 @@ var TwitterTestSuite = class {
    */
   async testPostTweet(runtime) {
     try {
-      const roomId = createUniqueUuid6(runtime, "twitter_mock_room");
+      const roomId = createUniqueUuid7(runtime, "twitter_mock_room");
       const postClient = this.twitterClient.post;
       const tweetText = await this.generateRandomTweetContent(runtime);
       await postClient.postTweet(
@@ -9519,7 +9344,7 @@ var TwitterTestSuite = class {
    */
   async testPostImageTweet(runtime) {
     try {
-      const roomId = createUniqueUuid6(runtime, "twitter_mock_room");
+      const roomId = createUniqueUuid7(runtime, "twitter_mock_room");
       const postClient = this.twitterClient.post;
       const tweetText = await this.generateRandomTweetContent(
         runtime,
@@ -9585,8 +9410,8 @@ var TwitterTestSuite = class {
         message: {
           content: { text: testTweet.text, source: "twitter" },
           agentId: runtime.agentId,
-          entityId: createUniqueUuid6(runtime, testTweet.entityId),
-          roomId: createUniqueUuid6(runtime, testTweet.conversationId)
+          entityId: createUniqueUuid7(runtime, testTweet.entityId),
+          roomId: createUniqueUuid7(runtime, testTweet.conversationId)
         },
         thread: []
       });
@@ -9622,7 +9447,7 @@ var TwitterTestSuite = class {
       - A lighthearted take on everyday situations.
       Do not include hashtags or emojis.`;
     }
-    return await runtime.useModel(ModelTypes6.TEXT_SMALL, {
+    return await runtime.useModel(ModelType6.TEXT_SMALL, {
       prompt
     });
   }
@@ -9701,7 +9526,7 @@ var _TwitterService = class _TwitterService extends Service {
       const profile = client.client.profile;
       const twitterId = profile.id;
       const username = profile.username;
-      const worldId = createUniqueUuid7(runtime, twitterId);
+      const worldId = createUniqueUuid8(runtime, twitterId);
       const world = {
         id: worldId,
         name: `${username}'s Twitter`,
@@ -9718,27 +9543,27 @@ var _TwitterService = class _TwitterService extends Service {
           }
         }
       };
-      const homeTimelineRoomId = createUniqueUuid7(runtime, `${twitterId}-home`);
+      const homeTimelineRoomId = createUniqueUuid8(runtime, `${twitterId}-home`);
       const homeTimelineRoom = {
         id: homeTimelineRoomId,
         name: `${username}'s Timeline`,
         source: "twitter",
-        type: ChannelType6.FEED,
+        type: ChannelType7.FEED,
         channelId: `${twitterId}-home`,
         serverId: twitterId,
         worldId
       };
-      const mentionsRoomId = createUniqueUuid7(runtime, `${twitterId}-mentions`);
+      const mentionsRoomId = createUniqueUuid8(runtime, `${twitterId}-mentions`);
       const mentionsRoom = {
         id: mentionsRoomId,
         name: `${username}'s Mentions`,
         source: "twitter",
-        type: ChannelType6.GROUP,
+        type: ChannelType7.GROUP,
         channelId: `${twitterId}-mentions`,
         serverId: twitterId,
         worldId
       };
-      const twitterUserId = createUniqueUuid7(runtime, twitterId);
+      const twitterUserId = createUniqueUuid8(runtime, twitterId);
       const twitterUser = {
         id: twitterUserId,
         names: [profile.screenName || username],
@@ -9752,7 +9577,7 @@ var _TwitterService = class _TwitterService extends Service {
           }
         }
       };
-      runtime.emitEvent(["TWITTER_WORLD_JOINED" /* WORLD_JOINED */, EventTypes3.WORLD_JOINED], {
+      runtime.emitEvent(["TWITTER_WORLD_JOINED" /* WORLD_JOINED */, EventTypes4.WORLD_JOINED], {
         runtime,
         world,
         rooms: [homeTimelineRoom, mentionsRoom],
@@ -9795,6 +9620,7 @@ var _TwitterService = class _TwitterService extends Service {
       if (config.TWITTER_USERNAME && // Basic auth
       config.TWITTER_PASSWORD && config.TWITTER_EMAIL) {
         logger9.info("Creating default Twitter client from character settings");
+        console.log("runtime is", runtime);
         await twitterClientManager.createClient(
           runtime,
           runtime.agentId,