@elizaos/plugin-twitter 1.0.0-alpha.7 → 1.0.0-beta.1

package/dist/index.js

@@ -1,17 +1,26 @@
 // src/index.ts
 import {
+  ChannelType as ChannelType7,
+  EventType as EventType4,
+  Role,
   Service,
-  logger as logger9
+  createUniqueUuid as createUniqueUuid8,
+  logger as logger10
 } from "@elizaos/core";
 
 // src/actions/spaceJoin.ts
 import {
-  logger as logger4,
+  logger as logger5,
   stringToUuid
 } 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 logger4
+} from "@elizaos/core";
 
 // src/client/api.ts
 import { Headers as Headers2 } from "headers-polyfill";
@@ -73,7 +82,7 @@ var Platform = class _Platform {
    */
   static async importPlatform() {
     if (PLATFORM_NODE) {
-      const { platform } = await import("./node-GVRE5HAO.js");
+      const { platform } = await import("./node-IZDTQWG6.js");
       return platform;
     }
     return genericPlatform;
@@ -263,10 +272,7 @@ import { CookieJar } from "tough-cookie";
 import { TwitterApi } from "twitter-api-v2";
 function withTransform(fetchFn, transform) {
   return async (input, init) => {
-    const fetchArgs = await transform?.request?.(input, init) ?? [
-      input,
-      init
-    ];
+    const fetchArgs = await transform?.request?.(input, init) ?? [input, init];
     const res = await fetchFn(...fetchArgs);
     return await transform?.response?.(res) ?? res;
   };
@@ -279,12 +285,6 @@ var TwitterGuestAuth = class {
     this.jar = new CookieJar();
     this.v2Client = null;
   }
-  bearerToken;
-  jar;
-  guestToken;
-  guestCreatedAt;
-  v2Client;
-  fetch;
   cookieJar() {
     return this.jar;
   }
@@ -472,10 +472,7 @@ async function getProfile(username, auth) {
       responsive_web_graphql_timeline_navigation_enabled: true
     }) ?? ""
   );
-  params.set(
-    "fieldToggles",
-    stringify({ withAuxiliaryUserLabels: false }) ?? ""
-  );
+  params.set("fieldToggles", stringify({ withAuxiliaryUserLabels: false }) ?? "");
   const res = await requestApi(
     `https://twitter.com/i/api/graphql/G3KGOASz96M-Qu0nwmGXNg/UserByScreenName?${params.toString()}`,
     auth
@@ -568,9 +565,7 @@ async function getScreenNameByUserId(userId, auth) {
   if (legacy.screen_name == null || legacy.screen_name.length === 0) {
     return {
       success: false,
-      err: new Error(
-        `Either user with ID ${userId} does not exist or is private.`
-      )
+      err: new Error(`Either user with ID ${userId} does not exist or is private.`)
     };
   }
   return {
@@ -578,7 +573,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 };
@@ -607,7 +602,6 @@ var TwitterUserAuthSubtask = Type.Object({
   enter_text: Type.Optional(Type.Object({}))
 });
 var TwitterUserAuth = class extends TwitterGuestAuth {
-  userProfile;
   async isLoggedIn() {
     const res = await requestApi(
       "https://api.twitter.com/1.1/account/verify_credentials.json",
@@ -639,10 +633,7 @@ var TwitterUserAuth = class extends TwitterGuestAuth {
       } else if (next.subtask.subtask_id === "LoginEnterUserIdentifierSSO") {
         next = await this.handleEnterUserIdentifierSSO(next, username);
       } else if (next.subtask.subtask_id === "LoginEnterAlternateIdentifierSubtask") {
-        next = await this.handleEnterAlternateIdentifierSubtask(
-          next,
-          email
-        );
+        next = await this.handleEnterAlternateIdentifierSubtask(next, email);
       } else if (next.subtask.subtask_id === "LoginEnterPassword") {
         next = await this.handleEnterPassword(next, password);
       } else if (next.subtask.subtask_id === "AccountDuplicationCheck") {
@@ -651,9 +642,7 @@ var TwitterUserAuth = class extends TwitterGuestAuth {
         if (twoFactorSecret) {
           next = await this.handleTwoFactorAuthChallenge(next, twoFactorSecret);
         } else {
-          throw new Error(
-            "Requested two factor authentication code but no secret provided"
-          );
+          throw new Error("Requested two factor authentication code but no secret provided");
         }
       } else if (next.subtask.subtask_id === "LoginAcid") {
         next = await this.handleAcid(next, email);
@@ -674,11 +663,7 @@ var TwitterUserAuth = class extends TwitterGuestAuth {
     if (!this.isLoggedIn()) {
       return;
     }
-    await requestApi(
-      "https://api.twitter.com/1.1/account/logout.json",
-      this,
-      "POST"
-    );
+    await requestApi("https://api.twitter.com/1.1/account/logout.json", this, "POST");
     this.deleteToken();
     this.jar = new CookieJar2();
   }
@@ -873,9 +858,7 @@ var TwitterUserAuth = class extends TwitterGuestAuth {
     if (flow.errors?.length) {
       return {
         status: "error",
-        err: new Error(
-          `Authentication error (${flow.errors[0].code}): ${flow.errors[0].message}`
-        )
+        err: new Error(`Authentication error (${flow.errors[0].code}): ${flow.errors[0].message}`)
       };
     }
     if (typeof flow.flow_token !== "string") {
@@ -963,10 +946,7 @@ async function grokChat(options, auth) {
     return {
       conversationId,
       message: firstChunk.result.message,
-      messages: [
-        ...messages,
-        { role: "assistant", content: firstChunk.result.message }
-      ],
+      messages: [...messages, { role: "assistant", content: firstChunk.result.message }],
       rateLimit: {
         isRateLimited: true,
         message: firstChunk.result.message,
@@ -996,19 +976,17 @@ function parseDirectMessageConversations(data, userId) {
     const conversations = inboxState?.conversations || {};
     const entries = inboxState?.entries || [];
     const users = inboxState?.users || {};
-    const parsedUsers = Object.values(users).map(
-      (user) => ({
-        id: user.id_str,
-        screenName: user.screen_name,
-        name: user.name,
-        profileImageUrl: user.profile_image_url_https,
-        description: user.description,
-        verified: user.verified,
-        protected: user.protected,
-        followersCount: user.followers_count,
-        friendsCount: user.friends_count
-      })
-    );
+    const parsedUsers = Object.values(users).map((user) => ({
+      id: user.id_str,
+      screenName: user.screen_name,
+      name: user.name,
+      profileImageUrl: user.profile_image_url_https,
+      description: user.description,
+      verified: user.verified,
+      protected: user.protected,
+      followersCount: user.followers_count,
+      friendsCount: user.friends_count
+    }));
     const messagesByConversation = {};
     entries.forEach((entry) => {
       if (entry.message) {
@@ -1175,11 +1153,7 @@ async function* getUserTimeline(query, maxProfiles, fetchFunc) {
   let cursor = void 0;
   let consecutiveEmptyBatches = 0;
   while (nProfiles < maxProfiles) {
-    const batch = await fetchFunc(
-      query,
-      maxProfiles,
-      cursor
-    );
+    const batch = await fetchFunc(query, maxProfiles, cursor);
     const { profiles, next } = batch;
     cursor = next;
     if (profiles.length === 0) {
@@ -1198,11 +1172,7 @@ async function* getTweetTimeline(query, maxTweets, fetchFunc) {
   let nTweets = 0;
   let cursor = void 0;
   while (nTweets < maxTweets) {
-    const batch = await fetchFunc(
-      query,
-      maxTweets,
-      cursor
-    );
+    const batch = await fetchFunc(query, maxTweets, cursor);
     const { tweets, next } = batch;
     if (tweets.length === 0) {
       break;
@@ -1241,10 +1211,7 @@ function parseRelationshipTimeline(timeline) {
         if (itemContent?.userDisplayType === "User") {
           const userResultRaw = itemContent.user_results?.result;
           if (userResultRaw?.legacy) {
-            const profile = parseProfile(
-              userResultRaw.legacy,
-              userResultRaw.is_blue_verified
-            );
+            const profile = parseProfile(userResultRaw.legacy, userResultRaw.is_blue_verified);
             if (!profile.userId) {
               profile.userId = userResultRaw.rest_id;
             }
@@ -1273,21 +1240,11 @@ function getFollowers(userId, maxProfiles, auth) {
   });
 }
 async function fetchProfileFollowing(userId, maxProfiles, auth, cursor) {
-  const timeline = await getFollowingTimeline(
-    userId,
-    maxProfiles,
-    auth,
-    cursor
-  );
+  const timeline = await getFollowingTimeline(userId, maxProfiles, auth, cursor);
   return parseRelationshipTimeline(timeline);
 }
 async function fetchProfileFollowers(userId, maxProfiles, auth, cursor) {
-  const timeline = await getFollowersTimeline(
-    userId,
-    maxProfiles,
-    auth,
-    cursor
-  );
+  const timeline = await getFollowersTimeline(userId, maxProfiles, auth, cursor);
   return parseRelationshipTimeline(timeline);
 }
 async function getFollowingTimeline(userId, maxItems, auth, cursor) {
@@ -1360,7 +1317,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}`);
   }
@@ -1378,19 +1335,13 @@ async function followUser(username, auth) {
     "X-Twitter-Client-Language": "en",
     Authorization: `Bearer ${bearerToken}`
   });
-  await auth.installTo(
+  await auth.installTo(headers, "https://api.twitter.com/1.1/friendships/create.json");
+  const res = await auth.fetch("https://api.twitter.com/1.1/friendships/create.json", {
+    method: "POST",
     headers,
-    "https://api.twitter.com/1.1/friendships/create.json"
-  );
-  const res = await auth.fetch(
-    "https://api.twitter.com/1.1/friendships/create.json",
-    {
-      method: "POST",
-      headers,
-      body: new URLSearchParams(requestBody).toString(),
-      credentials: "include"
-    }
-  );
+    body: new URLSearchParams(requestBody).toString(),
+    credentials: "include"
+  });
   if (!res.ok) {
     throw new Error(`Failed to follow user: ${res.statusText}`);
   }
@@ -1485,22 +1436,13 @@ function reconstructTweetHtml(tweet, photos, videos) {
   return html;
 }
 function linkHashtagHtml(hashtag) {
-  return `<a href="https://twitter.com/hashtag/${hashtag.replace(
-    "#",
-    ""
-  )}">${hashtag}</a>`;
+  return `<a href="https://twitter.com/hashtag/${hashtag.replace("#", "")}">${hashtag}</a>`;
 }
 function linkCashtagHtml(cashtag) {
-  return `<a href="https://twitter.com/search?q=%24${cashtag.replace(
-    "$",
-    ""
-  )}">${cashtag}</a>`;
+  return `<a href="https://twitter.com/search?q=%24${cashtag.replace("$", "")}">${cashtag}</a>`;
 }
 function linkUsernameHtml(username) {
-  return `<a href="https://twitter.com/${username.replace(
-    "@",
-    ""
-  )}">${username}</a>`;
+  return `<a href="https://twitter.com/${username.replace("@", "")}">${username}</a>`;
 }
 function unwrapTcoUrlHtml(tweet, foundedMedia) {
   return (tco) => {
@@ -1545,9 +1487,7 @@ function parseLegacyTweet(user, tweet) {
   const hashtags = tweet.entities?.hashtags ?? [];
   const mentions = tweet.entities?.user_mentions ?? [];
   const media = tweet.extended_entities?.media ?? [];
-  const pinnedTweets = new Set(
-    user.pinned_tweet_ids_str ?? []
-  );
+  const pinnedTweets = new Set(user.pinned_tweet_ids_str ?? []);
   const urls = tweet.entities?.urls ?? [];
   const { photos, videos, sensitiveContent } = parseMediaGroups(media);
   const tw = {
@@ -1628,10 +1568,7 @@ function parseResult(result) {
   if (result?.legacy && noteTweetResultText) {
     result.legacy.full_text = noteTweetResultText;
   }
-  const tweetResult = parseLegacyTweet(
-    result?.core?.user_results?.result?.legacy,
-    result?.legacy
-  );
+  const tweetResult = parseLegacyTweet(result?.core?.user_results?.result?.legacy, result?.legacy);
   if (!tweetResult.success) {
     return tweetResult;
   }
@@ -1692,8 +1629,7 @@ function parseTimelineTweetsV2(timeline) {
 function parseTimelineEntryItemContentRaw(content, entryId, isConversation = false) {
   let result = content.tweet_results?.result ?? content.tweetResult?.result;
   if (result?.__typename === "Tweet" || result?.__typename === "TweetWithVisibilityResults" && result?.tweet) {
-    if (result?.__typename === "TweetWithVisibilityResults")
-      result = result.tweet;
+    if (result?.__typename === "TweetWithVisibilityResults") result = result.tweet;
     if (result?.legacy) {
       result.legacy.id_str = result.rest_id ?? entryId.replace("conversation-", "").replace("tweet-", "");
     }
@@ -1710,11 +1646,7 @@ function parseTimelineEntryItemContentRaw(content, entryId, isConversation = fal
   return null;
 }
 function parseAndPush(tweets, content, entryId, isConversation = false) {
-  const tweet = parseTimelineEntryItemContentRaw(
-    content,
-    entryId,
-    isConversation
-  );
+  const tweet = parseTimelineEntryItemContentRaw(content, entryId, isConversation);
   if (tweet) {
     tweets.push(tweet);
   }
@@ -1845,10 +1777,7 @@ function parseSearchTimelineUsers(timeline) {
         if (itemContent?.userDisplayType === "User") {
           const userResultRaw = itemContent.user_results?.result;
           if (userResultRaw?.legacy) {
-            const profile = parseProfile(
-              userResultRaw.legacy,
-              userResultRaw.is_blue_verified
-            );
+            const profile = parseProfile(userResultRaw.legacy, userResultRaw.is_blue_verified);
             if (!profile.userId) {
               profile.userId = userResultRaw.rest_id;
             }
@@ -1877,23 +1806,11 @@ function searchProfiles(query, maxProfiles, auth) {
   });
 }
 async function fetchSearchTweets(query, maxTweets, searchMode, auth, cursor) {
-  const timeline = await getSearchTimeline(
-    query,
-    maxTweets,
-    searchMode,
-    auth,
-    cursor
-  );
+  const timeline = await getSearchTimeline(query, maxTweets, searchMode, auth, cursor);
   return parseSearchTimelineTweets(timeline);
 }
 async function fetchSearchProfiles(query, maxProfiles, auth, cursor) {
-  const timeline = await getSearchTimeline(
-    query,
-    maxProfiles,
-    4 /* Users */,
-    auth,
-    cursor
-  );
+  const timeline = await getSearchTimeline(query, maxProfiles, 4 /* Users */, auth, cursor);
   return parseSearchTimelineUsers(timeline);
 }
 async function getSearchTimeline(query, maxItems, searchMode, auth, cursor) {
@@ -2121,9 +2038,7 @@ async function fetchBrowseSpaceTopics(auth) {
   if (data.errors && data.errors.length > 0) {
     throw new Error(`API Errors: ${JSON.stringify(data.errors)}`);
   }
-  return data.data.browse_space_topics.categories.flatMap(
-    (category) => category.subtopics
-  );
+  return data.data.browse_space_topics.categories.flatMap((category) => category.subtopics);
 }
 async function fetchCommunitySelectQuery(auth) {
   const queryId = "Lue1DfmoW2cc0225t_8z1w";
@@ -2153,9 +2068,7 @@ async function fetchCommunitySelectQuery(auth) {
   });
   await updateCookieJar(auth.cookieJar(), response.headers);
   if (!response.ok) {
-    throw new Error(
-      `Failed to fetch Community Select Query: ${await response.text()}`
-    );
+    throw new Error(`Failed to fetch Community Select Query: ${await response.text()}`);
   }
   const data = await response.json();
   if (data.errors && data.errors.length > 0) {
@@ -2192,16 +2105,11 @@ async function fetchLiveVideoStreamStatus(mediaKey, auth) {
     });
     await updateCookieJar(auth.cookieJar(), response.headers);
     if (!response.ok) {
-      throw new Error(
-        `Failed to fetch live video stream status: ${await response.text()}`
-      );
+      throw new Error(`Failed to fetch live video stream status: ${await response.text()}`);
     }
     return await response.json();
   } catch (error) {
-    console.error(
-      `Error fetching live video stream status for mediaKey ${mediaKey}:`,
-      error
-    );
+    console.error(`Error fetching live video stream status for mediaKey ${mediaKey}:`, error);
     throw error;
   }
 }
@@ -2343,7 +2251,6 @@ async function fetchFollowingTimeline(count, seenTweetIds, auth) {
     auth,
     "GET"
   );
-  console.log("res", res);
   if (!res.success) {
     if (res.err instanceof ApiError) {
       console.error("Error details:", res.err.data);
@@ -2477,10 +2384,6 @@ var endpoints = {
   ListTweets: "https://twitter.com/i/api/graphql/whF0_KH1fCkdLLoyNPMoEw/ListLatestTweetsTimeline?variables=%7B%22listId%22%3A%221736495155002106192%22%2C%22count%22%3A20%7D&features=%7B%22responsive_web_graphql_exclude_directive_enabled%22%3Atrue%2C%22verified_phone_label_enabled%22%3Afalse%2C%22creator_subscriptions_tweet_preview_api_enabled%22%3Atrue%2C%22responsive_web_graphql_timeline_navigation_enabled%22%3Atrue%2C%22responsive_web_graphql_skip_user_profile_image_extensions_enabled%22%3Afalse%2C%22c9s_tweet_anatomy_moderator_badge_enabled%22%3Atrue%2C%22tweetypie_unmention_optimization_enabled%22%3Atrue%2C%22responsive_web_edit_tweet_api_enabled%22%3Atrue%2C%22graphql_is_translatable_rweb_tweet_is_translatable_enabled%22%3Atrue%2C%22view_counts_everywhere_api_enabled%22%3Atrue%2C%22longform_notetweets_consumption_enabled%22%3Atrue%2C%22responsive_web_twitter_article_tweet_consumption_enabled%22%3Afalse%2C%22tweet_awards_web_tipping_enabled%22%3Afalse%2C%22freedom_of_speech_not_reach_fetch_enabled%22%3Atrue%2C%22standardized_nudges_misinfo%22%3Atrue%2C%22tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled%22%3Atrue%2C%22rweb_video_timestamps_enabled%22%3Atrue%2C%22longform_notetweets_rich_text_read_enabled%22%3Atrue%2C%22longform_notetweets_inline_media_enabled%22%3Atrue%2C%22responsive_web_media_download_video_enabled%22%3Afalse%2C%22responsive_web_enhance_cards_enabled%22%3Afalse%7D"
 };
 var ApiRequest = class {
-  url;
-  variables;
-  features;
-  fieldToggles;
   constructor(info) {
     this.url = info.url;
     this.variables = info.variables;
@@ -2665,10 +2568,7 @@ async function fetchTweets(userId, maxTweets, cursor, auth) {
   if (cursor != null && cursor !== "") {
     userTweetsRequest.variables.cursor = cursor;
   }
-  const res = await requestApi(
-    userTweetsRequest.toRequestUrl(),
-    auth
-  );
+  const res = await requestApi(userTweetsRequest.toRequestUrl(), auth);
   if (!res.success) {
     throw res.err;
   }
@@ -2685,10 +2585,7 @@ async function fetchTweetsAndReplies(userId, maxTweets, cursor, auth) {
   if (cursor != null && cursor !== "") {
     userTweetsRequest.variables.cursor = cursor;
   }
-  const res = await requestApi(
-    userTweetsRequest.toRequestUrl(),
-    auth
-  );
+  const res = await requestApi(userTweetsRequest.toRequestUrl(), auth);
   if (!res.success) {
     throw res.err;
   }
@@ -2726,12 +2623,7 @@ async function createCreateTweetRequestV2(text, auth, tweetId, options) {
   if (options?.poll) {
     optionsConfig = {
       expansions: ["attachments.poll_ids"],
-      pollFields: [
-        "options",
-        "duration_minutes",
-        "end_datetime",
-        "voting_status"
-      ]
+      pollFields: ["options", "duration_minutes", "end_datetime", "voting_status"]
     };
   }
   return await getTweetV2(tweetResponse.data.id, auth, optionsConfig);
@@ -2789,26 +2681,20 @@ function parseTweetV2ToV1(tweetV2, includes, defaultTweetData) {
         parsedTweet.videos.push({
           id: media.media_key,
           preview: media.preview_image_url ?? "",
-          url: media.variants?.find(
-            (variant) => variant.content_type === "video/mp4"
-          )?.url ?? ""
+          url: media.variants?.find((variant) => variant.content_type === "video/mp4")?.url ?? ""
         });
       }
     });
   }
   if (includes?.users?.length) {
-    const user = includes.users.find(
-      (user2) => user2.id === tweetV2.author_id
-    );
+    const user = includes.users.find((user2) => user2.id === tweetV2.author_id);
     if (user) {
       parsedTweet.username = user.username ?? defaultTweetData?.username ?? "";
       parsedTweet.name = user.name ?? defaultTweetData?.name ?? "";
     }
   }
   if (tweetV2?.geo?.place_id && includes?.places?.length) {
-    const place = includes.places.find(
-      (place2) => place2.id === tweetV2?.geo?.place_id
-    );
+    const place = includes.places.find((place2) => place2.id === tweetV2?.geo?.place_id);
     if (place) {
       parsedTweet.place = {
         id: place.id,
@@ -2851,9 +2737,7 @@ async function createCreateTweetRequest(text, auth, tweetId, mediaData, hideLink
   }
   if (mediaData && mediaData.length > 0) {
     const mediaIds = await Promise.all(
-      mediaData.map(
-        ({ data, mediaType }) => uploadMedia(data, auth, mediaType)
-      )
+      mediaData.map(({ data, mediaType }) => uploadMedia(data, auth, mediaType))
     );
     variables.media.media_entities = mediaIds.map((id) => ({
       media_id: id,
@@ -2943,9 +2827,7 @@ async function createCreateNoteTweetRequest(text, auth, tweetId, mediaData) {
   };
   if (mediaData && mediaData.length > 0) {
     const mediaIds = await Promise.all(
-      mediaData.map(
-        ({ data: data2, mediaType }) => uploadMedia(data2, auth, mediaType)
-      )
+      mediaData.map(({ data: data2, mediaType }) => uploadMedia(data2, auth, mediaType))
     );
     variables.media.media_entities = mediaIds.map((id) => ({
       media_id: id,
@@ -3027,10 +2909,7 @@ async function fetchListTweets(listId, maxTweets, cursor, auth) {
   if (cursor != null && cursor !== "") {
     listTweetsRequest.variables.cursor = cursor;
   }
-  const res = await requestApi(
-    listTweetsRequest.toRequestUrl(),
-    auth
-  );
+  const res = await requestApi(listTweetsRequest.toRequestUrl(), auth);
   if (!res.success) {
     throw res.err;
   }
@@ -3038,7 +2917,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;
     }
@@ -3053,7 +2932,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;
     }
@@ -3099,10 +2978,7 @@ async function getLatestTweet(user, includeRetweets, max, auth) {
 async function getTweet(id, auth) {
   const tweetDetailRequest = apiRequestFactory.createTweetDetailRequest();
   tweetDetailRequest.variables.focalTweetId = id;
-  const res = await requestApi(
-    tweetDetailRequest.toRequestUrl(),
-    auth
-  );
+  const res = await requestApi(tweetDetailRequest.toRequestUrl(), auth);
   if (!res.success) {
     throw res.err;
   }
@@ -3131,11 +3007,7 @@ async function getTweetV2(id, auth, options = defaultOptions) {
       return null;
     }
     const defaultTweetData = await getTweet(tweetData.data.id, auth);
-    const parsedTweet = parseTweetV2ToV1(
-      tweetData.data,
-      tweetData?.includes,
-      defaultTweetData
-    );
+    const parsedTweet = parseTweetV2ToV1(tweetData.data, tweetData?.includes, defaultTweetData);
     return parsedTweet;
   } catch (error) {
     console.error(`Error fetching tweet ${id}:`, error);
@@ -3161,11 +3033,7 @@ async function getTweetsV2(ids, auth, options = defaultOptions) {
       console.warn(`No tweet data found for IDs: ${ids.join(", ")}`);
       return [];
     }
-    return (await Promise.all(
-      tweetsV2.map(
-        async (tweet) => await getTweetV2(tweet.id, auth, options)
-      )
-    )).filter((tweet) => tweet !== null);
+    return (await Promise.all(tweetsV2.map(async (tweet) => await getTweetV2(tweet.id, auth, options)))).filter((tweet) => tweet !== null);
   } catch (error) {
     console.error(`Error fetching tweets for IDs: ${ids.join(", ")}`, error);
     return [];
@@ -3271,13 +3139,10 @@ async function uploadMedia(mediaData, auth, mediaType) {
       const statusParams = new URLSearchParams();
       statusParams.append("command", "STATUS");
       statusParams.append("media_id", mediaId);
-      const statusResponse = await fetch(
-        `${uploadUrl}?${statusParams.toString()}`,
-        {
-          method: "GET",
-          headers
-        }
-      );
+      const statusResponse = await fetch(`${uploadUrl}?${statusParams.toString()}`, {
+        method: "GET",
+        headers
+      });
       if (!statusResponse.ok) {
         throw new Error(await statusResponse.text());
       }
@@ -3317,9 +3182,7 @@ async function createQuoteTweetRequest(text, quotedTweetId, auth, mediaData) {
   };
   if (mediaData && mediaData.length > 0) {
     const mediaIds = await Promise.all(
-      mediaData.map(
-        ({ data, mediaType }) => uploadMedia(data, auth, mediaType)
-      )
+      mediaData.map(({ data, mediaType }) => uploadMedia(data, auth, mediaType))
     );
     variables.media.media_entities = mediaIds.map((id) => ({
       media_id: id,
@@ -3464,9 +3327,7 @@ async function createCreateLongTweetRequest(text, auth, tweetId, mediaData) {
   };
   if (mediaData && mediaData.length > 0) {
     const mediaIds = await Promise.all(
-      mediaData.map(
-        ({ data, mediaType }) => uploadMedia(data, auth, mediaType)
-      )
+      mediaData.map(({ data, mediaType }) => uploadMedia(data, auth, mediaType))
     );
     variables.media.media_entities = mediaIds.map((id) => ({
       media_id: id,
@@ -3521,10 +3382,7 @@ async function createCreateLongTweetRequest(text, auth, tweetId, mediaData) {
 async function getArticle(id, auth) {
   const tweetDetailRequest = apiRequestFactory.createTweetDetailArticleRequest();
   tweetDetailRequest.variables.focalTweetId = id;
-  const res = await requestApi(
-    tweetDetailRequest.toRequestUrl(),
-    auth
-  );
+  const res = await requestApi(tweetDetailRequest.toRequestUrl(), auth);
   if (!res.success) {
     throw res.err;
   }
@@ -3659,9 +3517,6 @@ var Client = class {
     this.token = bearerToken;
     this.useGuestAuth();
   }
-  auth;
-  authTrends;
-  token;
   /**
    * Initializes auth properties using a guest token.
    * Used when creating a new instance of this class, and when logging out.
@@ -3685,8 +3540,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);
   }
   /**
@@ -3870,11 +3725,7 @@ var Client = class {
     let cursor;
     let retrievedTweets = 0;
     while (retrievedTweets < maxTweets) {
-      const response = await this.getUserTweets(
-        userId,
-        maxTweets - retrievedTweets,
-        cursor
-      );
+      const response = await this.getUserTweets(userId, maxTweets - retrievedTweets, cursor);
       for (const tweet of response.tweets) {
         yield tweet;
         retrievedTweets++;
@@ -3930,12 +3781,7 @@ var Client = class {
     );
   }
   async sendNoteTweet(text, replyToTweetId, mediaData) {
-    return await createCreateNoteTweetRequest(
-      text,
-      this.auth,
-      replyToTweetId,
-      mediaData
-    );
+    return await createCreateNoteTweetRequest(text, this.auth, replyToTweetId, mediaData);
   }
   /**
    * Send a long tweet (Note Tweet)
@@ -3945,12 +3791,7 @@ var Client = class {
    * @returns
    */
   async sendLongTweet(text, replyToTweetId, mediaData) {
-    return await createCreateLongTweetRequest(
-      text,
-      this.auth,
-      replyToTweetId,
-      mediaData
-    );
+    return await createCreateLongTweetRequest(text, this.auth, replyToTweetId, mediaData);
   }
   /**
    * Send a tweet
@@ -3960,12 +3801,7 @@ var Client = class {
    * @returns
    */
   async sendTweetV2(text, replyToTweetId, options) {
-    return await createCreateTweetRequestV2(
-      text,
-      this.auth,
-      replyToTweetId,
-      options
-    );
+    return await createCreateTweetRequestV2(text, this.auth, replyToTweetId, options);
   }
   /**
    * Fetches tweets and replies from a Twitter user.
@@ -4134,9 +3970,7 @@ var Client = class {
    * @returns All cookies for the current session.
    */
   async getCookies() {
-    return await this.authTrends.cookieJar().getCookies(
-      typeof document !== "undefined" ? document.location.toString() : twUrl
-    );
+    return await this.authTrends.cookieJar().getCookies(typeof document !== "undefined" ? document.location.toString() : twUrl);
   }
   /**
    * Set cookies for the current session.
@@ -4191,12 +4025,7 @@ var Client = class {
    * @returns The response from the Twitter API.
    */
   async sendQuoteTweet(text, quotedTweetId, options) {
-    return await createQuoteTweetRequest(
-      text,
-      quotedTweetId,
-      this.auth,
-      options?.mediaData
-    );
+    return await createQuoteTweetRequest(text, quotedTweetId, this.auth, options?.mediaData);
   }
   /**
    * Likes a tweet with the given tweet ID.
@@ -4373,12 +4202,7 @@ var Client = class {
     let cursor;
     let prevCursor;
     while (true) {
-      const page = await fetchQuotedTweetsPage(
-        quotedTweetId,
-        maxTweetsPerPage,
-        this.auth,
-        cursor
-      );
+      const page = await fetchQuotedTweetsPage(quotedTweetId, maxTweetsPerPage, this.auth, cursor);
       if (!page.tweets || page.tweets.length === 0) {
         break;
       }
@@ -4398,7 +4222,6 @@ import { EventEmitter as EventEmitter4 } from "node:events";
 
 // src/client/spaces/logger.ts
 var Logger = class {
-  debugEnabled;
   /**
    * Constructor for initializing a new instance of the class.
    *
@@ -4473,15 +4296,11 @@ async function authorizeToken(cookie) {
     })
   });
   if (!resp.ok) {
-    throw new Error(
-      `authorizeToken => request failed with status ${resp.status}`
-    );
+    throw new Error(`authorizeToken => request failed with status ${resp.status}`);
   }
   const data = await resp.json();
   if (!data.authorization_token) {
-    throw new Error(
-      "authorizeToken => Missing authorization_token in response"
-    );
+    throw new Error("authorizeToken => Missing authorization_token in response");
   }
   return data.authorization_token;
 }
@@ -4523,9 +4342,7 @@ async function getTurnServers(cookie) {
     body: JSON.stringify({ cookie })
   });
   if (!resp.ok) {
-    throw new Error(
-      `getTurnServers => request failed with status ${resp.status}`
-    );
+    throw new Error(`getTurnServers => request failed with status ${resp.status}`);
   }
   return resp.json();
 }
@@ -4572,9 +4389,7 @@ async function createBroadcast(params) {
   });
   if (!resp.ok) {
     const text = await resp.text();
-    throw new Error(
-      `createBroadcast => request failed with status ${resp.status} ${text}`
-    );
+    throw new Error(`createBroadcast => request failed with status ${resp.status} ${text}`);
   }
   const data = await resp.json();
   return data;
@@ -4616,9 +4431,7 @@ async function startWatching(lifecycleToken, cookie) {
     body: JSON.stringify(body)
   });
   if (!resp.ok) {
-    throw new Error(
-      `startWatching => request failed with status ${resp.status}`
-    );
+    throw new Error(`startWatching => request failed with status ${resp.status}`);
   }
   const json = await resp.json();
   return json.session;
@@ -4636,9 +4449,7 @@ async function stopWatching(session, cookie) {
     body: JSON.stringify(body)
   });
   if (!resp.ok) {
-    throw new Error(
-      `stopWatching => request failed with status ${resp.status}`
-    );
+    throw new Error(`stopWatching => request failed with status ${resp.status}`);
   }
 }
 async function submitSpeakerRequest(params) {
@@ -4659,9 +4470,7 @@ async function submitSpeakerRequest(params) {
     body: JSON.stringify(body)
   });
   if (!resp.ok) {
-    throw new Error(
-      `submitSpeakerRequest => request failed with status ${resp.status}`
-    );
+    throw new Error(`submitSpeakerRequest => request failed with status ${resp.status}`);
   }
   return resp.json();
 }
@@ -4684,9 +4493,7 @@ async function cancelSpeakerRequest(params) {
     body: JSON.stringify(body)
   });
   if (!resp.ok) {
-    throw new Error(
-      `cancelSpeakerRequest => request failed with status ${resp.status}`
-    );
+    throw new Error(`cancelSpeakerRequest => request failed with status ${resp.status}`);
   }
   return resp.json();
 }
@@ -4705,9 +4512,7 @@ async function negotiateGuestStream(params) {
     body: JSON.stringify(body)
   });
   if (!resp.ok) {
-    throw new Error(
-      `negotiateGuestStream => request failed with status ${resp.status}`
-    );
+    throw new Error(`negotiateGuestStream => request failed with status ${resp.status}`);
   }
   return resp.json();
 }
@@ -4757,29 +4562,29 @@ async function unmuteSpeaker(params) {
     throw new Error(`unmuteSpeaker => ${resp.status} ${text}`);
   }
 }
-function setupCommonChatEvents(chatClient, logger10, emitter) {
+function setupCommonChatEvents(chatClient, logger11, emitter) {
   chatClient.on("occupancyUpdate", (upd) => {
-    logger10.debug("[ChatEvents] occupancyUpdate =>", upd);
+    logger11.debug("[ChatEvents] occupancyUpdate =>", upd);
     emitter.emit("occupancyUpdate", upd);
   });
   chatClient.on("guestReaction", (reaction) => {
-    logger10.debug("[ChatEvents] guestReaction =>", reaction);
+    logger11.debug("[ChatEvents] guestReaction =>", reaction);
     emitter.emit("guestReaction", reaction);
   });
   chatClient.on("muteStateChanged", (evt) => {
-    logger10.debug("[ChatEvents] muteStateChanged =>", evt);
+    logger11.debug("[ChatEvents] muteStateChanged =>", evt);
     emitter.emit("muteStateChanged", evt);
   });
   chatClient.on("speakerRequest", (req) => {
-    logger10.debug("[ChatEvents] speakerRequest =>", req);
+    logger11.debug("[ChatEvents] speakerRequest =>", req);
     emitter.emit("speakerRequest", req);
   });
   chatClient.on("newSpeakerAccepted", (info) => {
-    logger10.debug("[ChatEvents] newSpeakerAccepted =>", info);
+    logger11.debug("[ChatEvents] newSpeakerAccepted =>", info);
     emitter.emit("newSpeakerAccepted", info);
   });
   chatClient.on("newSpeakerRemoved", (info) => {
-    logger10.debug("[ChatEvents] newSpeakerRemoved =>", info);
+    logger11.debug("[ChatEvents] newSpeakerRemoved =>", info);
     emitter.emit("newSpeakerRemoved", info);
   });
 }
@@ -4788,14 +4593,9 @@ function setupCommonChatEvents(chatClient, logger10, emitter) {
 import { EventEmitter } from "node:events";
 import WebSocket from "ws";
 var ChatClient = class extends EventEmitter {
-  ws;
-  connected = false;
-  logger;
-  spaceId;
-  accessToken;
-  endpoint;
   constructor(config) {
     super();
+    this.connected = false;
     this.spaceId = config.spaceId;
     this.accessToken = config.accessToken;
     this.endpoint = config.endpoint;
@@ -4805,10 +4605,7 @@ var ChatClient = class extends EventEmitter {
    * Establishes a WebSocket connection to the chat endpoint and sets up event handlers.
    */
   async connect() {
-    const wsUrl = `${this.endpoint}/chatapi/v1/chatnow`.replace(
-      "https://",
-      "wss://"
-    );
+    const wsUrl = `${this.endpoint}/chatapi/v1/chatnow`.replace("https://", "wss://");
     this.logger.info("[ChatClient] Connecting =>", wsUrl);
     this.ws = new WebSocket(wsUrl, {
       headers: {
@@ -4873,24 +4670,22 @@ var ChatClient = class extends EventEmitter {
    */
   reactWithEmoji(emoji) {
     if (!this.ws || !this.connected) {
-      this.logger.warn(
-        "[ChatClient] Not connected or WebSocket missing; ignoring reactWithEmoji."
-      );
+      this.logger.warn("[ChatClient] Not connected or WebSocket missing; ignoring reactWithEmoji.");
       return;
     }
     const payload = JSON.stringify({
       body: JSON.stringify({ body: emoji, type: 2, v: 2 }),
       kind: 1,
       /*
-         // The 'sender' field is not required, it's not even verified by the server
-         // Instead of passing attributes down here it's easier to ignore it
-         sender: {
-           user_id: null,
-           twitter_id: null,
-           username: null,
-           display_name: null,
-         },
-         */
+      // The 'sender' field is not required, it's not even verified by the server
+      // Instead of passing attributes down here it's easier to ignore it
+      sender: {
+        user_id: null,
+        twitter_id: null,
+        username: null,
+        display_name: null,
+      },
+      */
       payload: JSON.stringify({
         room: this.spaceId,
         body: JSON.stringify({ body: emoji, type: 2, v: 2 })
@@ -4994,9 +4789,6 @@ import wrtc from "@roamhq/wrtc";
 var { nonstandard } = wrtc;
 var { RTCAudioSource, RTCAudioSink } = nonstandard;
 var JanusAudioSource = class extends EventEmitter2 {
-  source;
-  track;
-  logger;
   constructor(options) {
     super();
     this.logger = options?.logger;
@@ -5031,11 +4823,9 @@ var JanusAudioSource = class extends EventEmitter2 {
   }
 };
 var JanusAudioSink = class extends EventEmitter2 {
-  sink;
-  active = true;
-  logger;
   constructor(track, options) {
     super();
+    this.active = true;
     this.logger = options?.logger;
     if (track.kind !== "audio") {
       throw new Error("[JanusAudioSink] Provided track is not an audio track");
@@ -5069,19 +4859,13 @@ var JanusClient = class extends EventEmitter3 {
   constructor(config) {
     super();
     this.config = config;
+    this.pollActive = false;
+    // Tracks promises waiting for specific Janus events
+    this.eventWaiters = [];
+    // Tracks subscriber handle+pc for each userId we subscribe to
+    this.subscribers = /* @__PURE__ */ new Map();
     this.logger = config.logger;
   }
-  logger;
-  sessionId;
-  handleId;
-  publisherId;
-  pc;
-  localAudioSource;
-  pollActive = false;
-  // Tracks promises waiting for specific Janus events
-  eventWaiters = [];
-  // Tracks subscriber handle+pc for each userId we subscribe to
-  subscribers = /* @__PURE__ */ new Map();
   /**
    * Initializes this JanusClient for the host scenario:
    *  1) createSession()
@@ -5142,10 +4926,7 @@ var JanusClient = class extends EventEmitter3 {
     const evt = await evtPromise;
     const data = evt.plugindata?.data;
     this.publisherId = data.id;
-    this.logger.debug(
-      "[JanusClient] guest joined => publisherId=",
-      this.publisherId
-    );
+    this.logger.debug("[JanusClient] guest joined => publisherId=", this.publisherId);
     const publishers = data.publishers || [];
     this.logger.debug("[JanusClient] existing publishers =>", publishers);
     this.pc = new RTCPeerConnection({
@@ -5160,9 +4941,7 @@ var JanusClient = class extends EventEmitter3 {
     this.setupPeerEvents();
     this.enableLocalAudio();
     await this.configurePublisher(sessionUUID);
-    await Promise.all(
-      publishers.map((pub) => this.subscribeSpeaker(pub.display, pub.id))
-    );
+    await Promise.all(publishers.map((pub) => this.subscribeSpeaker(pub.display, pub.id)));
     this.logger.info("[JanusClient] Guest speaker negotiation complete");
   }
   /**
@@ -5180,9 +4959,7 @@ var JanusClient = class extends EventEmitter3 {
         'discover feed_id from "publishers"'
       );
       const list = publishersEvt.plugindata.data.publishers;
-      const pub = list.find(
-        (p) => p.display === userId || p.periscope_user_id === userId
-      );
+      const pub = list.find((p) => p.display === userId || p.periscope_user_id === userId);
       if (!pub) {
         throw new Error(
           `[JanusClient] subscribeSpeaker => No publisher found for userId=${userId}`
@@ -5238,9 +5015,7 @@ var JanusClient = class extends EventEmitter3 {
             const val = Math.abs(frame.samples[i]);
             if (val > maxVal) maxVal = val;
           }
-          this.logger.debug(
-            `[AudioSink] userId=${userId}, maxAmplitude=${maxVal}`
-          );
+          this.logger.debug(`[AudioSink] userId=${userId}, maxAmplitude=${maxVal}`);
         }
         this.emit("audioDataFromSpeaker", {
           userId,
@@ -5282,9 +5057,7 @@ var JanusClient = class extends EventEmitter3 {
    */
   enableLocalAudio() {
     if (!this.pc) {
-      this.logger.warn(
-        "[JanusClient] enableLocalAudio => No RTCPeerConnection"
-      );
+      this.logger.warn("[JanusClient] enableLocalAudio => No RTCPeerConnection");
       return;
     }
     if (this.localAudioSource) {
@@ -5402,42 +5175,31 @@ var JanusClient = class extends EventEmitter3 {
       h264_profile: "42e01f",
       dummy_publisher: false
     };
-    const resp = await fetch(
-      `${this.config.webrtcUrl}/${this.sessionId}/${this.handleId}`,
-      {
-        method: "POST",
-        headers: {
-          Authorization: this.config.credential,
-          "Content-Type": "application/json",
-          Referer: "https://x.com"
-        },
-        body: JSON.stringify({
-          janus: "message",
-          transaction,
-          body
-        })
-      }
-    );
+    const resp = await fetch(`${this.config.webrtcUrl}/${this.sessionId}/${this.handleId}`, {
+      method: "POST",
+      headers: {
+        Authorization: this.config.credential,
+        "Content-Type": "application/json",
+        Referer: "https://x.com"
+      },
+      body: JSON.stringify({
+        janus: "message",
+        transaction,
+        body
+      })
+    });
     if (!resp.ok) {
       throw new Error(`[JanusClient] createRoom failed => ${resp.status}`);
     }
     const json = await resp.json();
     this.logger.debug("[JanusClient] createRoom =>", JSON.stringify(json));
     if (json.janus === "error") {
-      throw new Error(
-        `[JanusClient] createRoom error => ${json.error?.reason || "Unknown"}`
-      );
+      throw new Error(`[JanusClient] createRoom error => ${json.error?.reason || "Unknown"}`);
     }
     if (json.plugindata?.data?.videoroom !== "created") {
-      throw new Error(
-        `[JanusClient] unexpected createRoom response => ${JSON.stringify(
-          json
-        )}`
-      );
+      throw new Error(`[JanusClient] unexpected createRoom response => ${JSON.stringify(json)}`);
     }
-    this.logger.debug(
-      `[JanusClient] Room '${this.config.roomId}' created successfully`
-    );
+    this.logger.debug(`[JanusClient] Room '${this.config.roomId}' created successfully`);
   }
   /**
    * Joins the created room as a publisher, for the host scenario.
@@ -5502,26 +5264,21 @@ var JanusClient = class extends EventEmitter3 {
       throw new Error("[JanusClient] No session for sendJanusMessage");
     }
     const transaction = this.randomTid();
-    const resp = await fetch(
-      `${this.config.webrtcUrl}/${this.sessionId}/${handleId}`,
-      {
-        method: "POST",
-        headers: {
-          Authorization: this.config.credential,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          janus: "message",
-          transaction,
-          body,
-          jsep
-        })
-      }
-    );
+    const resp = await fetch(`${this.config.webrtcUrl}/${this.sessionId}/${handleId}`, {
+      method: "POST",
+      headers: {
+        Authorization: this.config.credential,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        janus: "message",
+        transaction,
+        body,
+        jsep
+      })
+    });
     if (!resp.ok) {
-      throw new Error(
-        `[JanusClient] sendJanusMessage failed => status=${resp.status}`
-      );
+      throw new Error(`[JanusClient] sendJanusMessage failed => status=${resp.status}`);
     }
   }
   /**
@@ -5603,10 +5360,7 @@ var JanusClient = class extends EventEmitter3 {
       return;
     }
     this.pc.addEventListener("iceconnectionstatechange", () => {
-      this.logger.debug(
-        "[JanusClient] ICE state =>",
-        this.pc?.iceConnectionState
-      );
+      this.logger.debug("[JanusClient] ICE state =>", this.pc?.iceConnectionState);
       if (this.pc?.iceConnectionState === "failed") {
         this.emit("error", new Error("[JanusClient] ICE connection failed"));
       }
@@ -5664,22 +5418,19 @@ var JanusClient = class extends EventEmitter3 {
       periscope_user_id: this.config.userId
     };
     this.logger.info("[JanusClient] destroying room =>", body);
-    const resp = await fetch(
-      `${this.config.webrtcUrl}/${this.sessionId}/${this.handleId}`,
-      {
-        method: "POST",
-        headers: {
-          Authorization: this.config.credential,
-          "Content-Type": "application/json",
-          Referer: "https://x.com"
-        },
-        body: JSON.stringify({
-          janus: "message",
-          transaction,
-          body
-        })
-      }
-    );
+    const resp = await fetch(`${this.config.webrtcUrl}/${this.sessionId}/${this.handleId}`, {
+      method: "POST",
+      headers: {
+        Authorization: this.config.credential,
+        "Content-Type": "application/json",
+        Referer: "https://x.com"
+      },
+      body: JSON.stringify({
+        janus: "message",
+        transaction,
+        body
+      })
+    });
     if (!resp.ok) {
       throw new Error(`[JanusClient] destroyRoom failed => ${resp.status}`);
     }
@@ -5701,21 +5452,18 @@ var JanusClient = class extends EventEmitter3 {
       periscope_user_id: this.config.userId
     };
     this.logger.info("[JanusClient] leaving room =>", body);
-    const resp = await fetch(
-      `${this.config.webrtcUrl}/${this.sessionId}/${this.handleId}`,
-      {
-        method: "POST",
-        headers: {
-          Authorization: this.config.credential,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          janus: "message",
-          transaction,
-          body
-        })
-      }
-    );
+    const resp = await fetch(`${this.config.webrtcUrl}/${this.sessionId}/${this.handleId}`, {
+      method: "POST",
+      headers: {
+        Authorization: this.config.credential,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        janus: "message",
+        transaction,
+        body
+      })
+    });
     if (!resp.ok) {
       throw new Error(`[JanusClient] leaveRoom => error code ${resp.status}`);
     }
@@ -5729,18 +5477,12 @@ var Space = class extends EventEmitter4 {
   constructor(client, options) {
     super();
     this.client = client;
+    this.isInitialized = false;
+    this.plugins = /* @__PURE__ */ new Set();
+    this.speakers = /* @__PURE__ */ new Map();
     this.debug = options?.debug ?? false;
     this.logger = new Logger(this.debug);
   }
-  debug;
-  logger;
-  janusClient;
-  chatClient;
-  authToken;
-  broadcastInfo;
-  isInitialized = false;
-  plugins = /* @__PURE__ */ new Set();
-  speakers = /* @__PURE__ */ new Map();
   /**
    * Registers a plugin and calls its onAttach(...).
    * init(...) will be invoked once initialization is complete.
@@ -5796,16 +5538,11 @@ var Space = class extends EventEmitter4 {
     this.janusClient.on("subscribedSpeaker", ({ userId, feedId }) => {
       const speaker = this.speakers.get(userId);
       if (!speaker) {
-        this.logger.debug(
-          "[Space] subscribedSpeaker => no speaker found",
-          userId
-        );
+        this.logger.debug("[Space] subscribedSpeaker => no speaker found", userId);
         return;
       }
       speaker.janusParticipantId = feedId;
-      this.logger.debug(
-        `[Space] updated speaker => userId=${userId}, feedId=${feedId}`
-      );
+      this.logger.debug(`[Space] updated speaker => userId=${userId}, feedId=${feedId}`);
     });
     this.logger.debug("[Space] Publishing broadcast...");
     await publishBroadcast({
@@ -5827,10 +5564,7 @@ var Space = class extends EventEmitter4 {
       await this.chatClient.connect();
       this.setupChatEvents();
     }
-    this.logger.info(
-      "[Space] Initialized =>",
-      broadcast.share_url.replace("broadcasts", "spaces")
-    );
+    this.logger.info("[Space] Initialized =>", broadcast.share_url.replace("broadcasts", "spaces"));
     this.isInitialized = true;
     for (const { plugin, config: pluginConfig } of this.plugins) {
       plugin.init?.({ space: this, pluginConfig });
@@ -5864,12 +5598,7 @@ var Space = class extends EventEmitter4 {
       throw new Error("[Space] No auth token available");
     }
     this.speakers.set(userId, { userId, sessionUUID });
-    await this.callApproveEndpoint(
-      this.broadcastInfo,
-      this.authToken,
-      userId,
-      sessionUUID
-    );
+    await this.callApproveEndpoint(this.broadcastInfo, this.authToken, userId, sessionUUID);
     await this.janusClient?.subscribeSpeaker(userId);
   }
   /**
@@ -5896,9 +5625,7 @@ var Space = class extends EventEmitter4 {
     });
     if (!resp.ok) {
       const error = await resp.text();
-      throw new Error(
-        `[Space] Failed to approve speaker => ${resp.status}: ${error}`
-      );
+      throw new Error(`[Space] Failed to approve speaker => ${resp.status}: ${error}`);
     }
     this.logger.info("[Space] Speaker approved =>", userId);
   }
@@ -5917,17 +5644,10 @@ var Space = class extends EventEmitter4 {
     }
     const speaker = this.speakers.get(userId);
     if (!speaker) {
-      throw new Error(
-        `[Space] removeSpeaker => no speaker found for userId=${userId}`
-      );
+      throw new Error(`[Space] removeSpeaker => no speaker found for userId=${userId}`);
     }
     const { sessionUUID, janusParticipantId } = speaker;
-    this.logger.debug(
-      "[Space] removeSpeaker =>",
-      sessionUUID,
-      janusParticipantId,
-      speaker
-    );
+    this.logger.debug("[Space] removeSpeaker =>", sessionUUID, janusParticipantId, speaker);
     if (!sessionUUID || janusParticipantId === void 0) {
       throw new Error(
         `[Space] removeSpeaker => missing sessionUUID or feedId for userId=${userId}`
@@ -5936,9 +5656,7 @@ var Space = class extends EventEmitter4 {
     const janusHandleId = this.janusClient.getHandleId();
     const janusSessionId = this.janusClient.getSessionId();
     if (!janusHandleId || !janusSessionId) {
-      throw new Error(
-        `[Space] removeSpeaker => missing Janus handle/session for userId=${userId}`
-      );
+      throw new Error(`[Space] removeSpeaker => missing Janus handle/session for userId=${userId}`);
     }
     await this.callRemoveEndpoint(
       this.broadcastInfo,
@@ -5980,9 +5698,7 @@ var Space = class extends EventEmitter4 {
     });
     if (!resp.ok) {
       const error = await resp.text();
-      throw new Error(
-        `[Space] Failed to remove speaker => ${resp.status}: ${error}`
-      );
+      throw new Error(`[Space] Failed to remove speaker => ${resp.status}: ${error}`);
     }
     this.logger.debug("[Space] Speaker removed => sessionUUID=", sessionUUID);
   }
@@ -6178,32 +5894,12 @@ var SpaceParticipant = class extends EventEmitter5 {
   constructor(client, config) {
     super();
     this.client = client;
+    // Plugin management
+    this.plugins = /* @__PURE__ */ new Set();
     this.spaceId = config.spaceId;
     this.debug = config.debug ?? false;
     this.logger = new Logger(this.debug);
   }
-  spaceId;
-  debug;
-  logger;
-  // Basic auth/cookie data
-  cookie;
-  authToken;
-  // Chat
-  chatJwtToken;
-  chatToken;
-  chatClient;
-  // Watch session
-  lifecycleToken;
-  watchSession;
-  // HLS stream
-  hlsUrl;
-  // Speaker request + Janus
-  sessionUUID;
-  janusJwt;
-  webrtcGwUrl;
-  janusClient;
-  // Plugin management
-  plugins = /* @__PURE__ */ new Set();
   /**
    * Adds a plugin and calls its onAttach immediately.
    * init() or onJanusReady() will be invoked later at the appropriate time.
@@ -6211,10 +5907,7 @@ var SpaceParticipant = class extends EventEmitter5 {
   use(plugin, config) {
     const registration = { plugin, config };
     this.plugins.add(registration);
-    this.logger.debug(
-      "[SpaceParticipant] Plugin added =>",
-      plugin.constructor.name
-    );
+    this.logger.debug("[SpaceParticipant] Plugin added =>", plugin.constructor.name);
     plugin.onAttach?.({ space: this, pluginConfig: config });
     if (plugin.init) {
       plugin.init({ space: this, pluginConfig: config });
@@ -6225,10 +5918,7 @@ var SpaceParticipant = class extends EventEmitter5 {
    * Joins the Space as a listener: obtains HLS, chat token, etc.
    */
   async joinAsListener() {
-    this.logger.info(
-      "[SpaceParticipant] Joining space as listener =>",
-      this.spaceId
-    );
+    this.logger.info("[SpaceParticipant] Joining space as listener =>", this.spaceId);
     this.cookie = await this.client.getPeriscopeCookie();
     this.authToken = await authorizeToken(this.cookie);
     const spaceMeta = await this.client.getAudioSpaceById(this.spaceId);
@@ -6270,9 +5960,7 @@ var SpaceParticipant = class extends EventEmitter5 {
    */
   async requestSpeaker() {
     if (!this.chatJwtToken) {
-      throw new Error(
-        "[SpaceParticipant] Must join as listener first (no chat token)."
-      );
+      throw new Error("[SpaceParticipant] Must join as listener first (no chat token).");
     }
     if (!this.authToken) {
       throw new Error("[SpaceParticipant] No auth token available.");
@@ -6287,10 +5975,7 @@ var SpaceParticipant = class extends EventEmitter5 {
       authToken: this.authToken
     });
     this.sessionUUID = session_uuid;
-    this.logger.info(
-      "[SpaceParticipant] Speaker request submitted =>",
-      session_uuid
-    );
+    this.logger.info("[SpaceParticipant] Speaker request submitted =>", session_uuid);
     return { sessionUUID: session_uuid };
   }
   /**
@@ -6315,10 +6000,7 @@ var SpaceParticipant = class extends EventEmitter5 {
       chatToken: this.chatToken,
       authToken: this.authToken
     });
-    this.logger.info(
-      "[SpaceParticipant] Speaker request canceled =>",
-      this.sessionUUID
-    );
+    this.logger.info("[SpaceParticipant] Speaker request canceled =>", this.sessionUUID);
     this.sessionUUID = void 0;
   }
   /**
@@ -6327,13 +6009,9 @@ var SpaceParticipant = class extends EventEmitter5 {
    */
   async becomeSpeaker() {
     if (!this.sessionUUID) {
-      throw new Error(
-        "[SpaceParticipant] No sessionUUID (did you call requestSpeaker()?)."
-      );
+      throw new Error("[SpaceParticipant] No sessionUUID (did you call requestSpeaker()?).");
     }
-    this.logger.info(
-      "[SpaceParticipant] Negotiating speaker role via Janus..."
-    );
+    this.logger.info("[SpaceParticipant] Negotiating speaker role via Janus...");
     const turnServers = await getTurnServers(this.cookie);
     this.logger.debug("[SpaceParticipant] turnServers =>", turnServers);
     const nego = await negotiateGuestStream({
@@ -6356,16 +6034,10 @@ var SpaceParticipant = class extends EventEmitter5 {
     });
     await this.janusClient.initializeGuestSpeaker(this.sessionUUID);
     this.janusClient.on("audioDataFromSpeaker", (data) => {
-      this.logger.debug(
-        "[SpaceParticipant] Received speaker audio =>",
-        data.userId
-      );
+      this.logger.debug("[SpaceParticipant] Received speaker audio =>", data.userId);
       this.handleAudioData(data);
     });
-    this.logger.info(
-      "[SpaceParticipant] Now speaker on the Space =>",
-      this.spaceId
-    );
+    this.logger.info("[SpaceParticipant] Now speaker on the Space =>", this.spaceId);
     for (const { plugin } of this.plugins) {
       plugin.onJanusReady?.(this.janusClient);
     }
@@ -6375,9 +6047,7 @@ var SpaceParticipant = class extends EventEmitter5 {
    */
   async removeFromSpeaker() {
     if (!this.sessionUUID) {
-      throw new Error(
-        "[SpaceParticipant] No sessionUUID; cannot remove from speaker role."
-      );
+      throw new Error("[SpaceParticipant] No sessionUUID; cannot remove from speaker role.");
     }
     if (!this.authToken || !this.chatToken) {
       throw new Error("[SpaceParticipant] Missing authToken or chatToken.");
@@ -6387,9 +6057,7 @@ var SpaceParticipant = class extends EventEmitter5 {
       await this.janusClient.stop();
       this.janusClient = void 0;
     }
-    this.logger.info(
-      "[SpaceParticipant] Successfully removed from speaker role."
-    );
+    this.logger.info("[SpaceParticipant] Successfully removed from speaker role.");
   }
   /**
    * Leaves the Space gracefully:
@@ -6417,9 +6085,7 @@ var SpaceParticipant = class extends EventEmitter5 {
    */
   pushAudio(samples, sampleRate) {
     if (!this.janusClient) {
-      this.logger.warn(
-        "[SpaceParticipant] Not a speaker yet; ignoring pushAudio."
-      );
+      this.logger.warn("[SpaceParticipant] Not a speaker yet; ignoring pushAudio.");
       return;
     }
     this.janusClient.pushLocalAudio(samples, sampleRate);
@@ -6441,9 +6107,7 @@ var SpaceParticipant = class extends EventEmitter5 {
     this.chatClient.on("newSpeakerAccepted", ({ userId }) => {
       this.logger.debug("[SpaceParticipant] newSpeakerAccepted =>", userId);
       if (!this.janusClient) {
-        this.logger.warn(
-          "[SpaceParticipant] No janusClient yet; ignoring new speaker..."
-        );
+        this.logger.warn("[SpaceParticipant] No janusClient yet; ignoring new speaker...");
         return;
       }
       if (userId === this.janusClient.getHandleId()) {
@@ -6492,6 +6156,9 @@ var SpaceParticipant = class extends EventEmitter5 {
   }
 };
 
+// src/client/spaces/plugins/SttTtsPlugin.ts
+import { logger } from "@elizaos/core";
+
 // src/client/spaces/plugins/IdleMonitorPlugin.ts
 var IdleMonitorPlugin = class {
   /**
@@ -6501,12 +6168,9 @@ var IdleMonitorPlugin = class {
   constructor(idleTimeoutMs = 6e4, checkEveryMs = 1e4) {
     this.idleTimeoutMs = idleTimeoutMs;
     this.checkEveryMs = checkEveryMs;
+    this.lastSpeakerAudioMs = Date.now();
+    this.lastLocalAudioMs = Date.now();
   }
-  space;
-  logger;
-  lastSpeakerAudioMs = Date.now();
-  lastLocalAudioMs = Date.now();
-  checkInterval;
   /**
    * Called immediately after .use(plugin).
    * Allows for minimal setup, including obtaining a debug logger if desired.
@@ -6532,10 +6196,7 @@ var IdleMonitorPlugin = class {
       this.lastLocalAudioMs = Date.now();
       originalPushAudio(samples, sampleRate);
     };
-    this.checkInterval = setInterval(
-      () => this.checkIdle(),
-      this.checkEveryMs
-    );
+    this.checkInterval = setInterval(() => this.checkIdle(), this.checkEveryMs);
   }
   /**
    * Checks if we've exceeded idleTimeoutMs with no audio activity.
@@ -6546,9 +6207,7 @@ var IdleMonitorPlugin = class {
     const lastAudio = Math.max(this.lastSpeakerAudioMs, this.lastLocalAudioMs);
     const idleMs = now - lastAudio;
     if (idleMs >= this.idleTimeoutMs) {
-      this.logger?.warn(
-        `[IdleMonitorPlugin] idleTimeout => no audio for ${idleMs}ms`
-      );
+      this.logger?.warn(`[IdleMonitorPlugin] idleTimeout => no audio for ${idleMs}ms`);
       this.space?.emit("idleTimeout", { idleMs });
     }
   }
@@ -6576,38 +6235,34 @@ var IdleMonitorPlugin = class {
 import { spawn } from "node:child_process";
 import {
   ChannelType,
-  ModelTypes,
+  EventType,
+  ModelType,
   createUniqueUuid,
-  logger
+  logger as logger2
 } from "@elizaos/core";
 var VOLUME_WINDOW_SIZE = 100;
 var SPEAKING_THRESHOLD = 0.05;
 var SILENCE_DETECTION_THRESHOLD_MS = 1e3;
 var SttTtsPlugin2 = class {
-  name = "SttTtsPlugin";
-  description = "Speech-to-text (OpenAI) + conversation + TTS (ElevenLabs)";
-  runtime;
-  spaceId;
-  space;
-  janus;
-  /**
-   * userId => arrayOfChunks (PCM Int16)
-   */
-  pcmBuffers = /* @__PURE__ */ new Map();
-  // TTS queue for sequentially speaking
-  ttsQueue = [];
-  isSpeaking = false;
-  isProcessingAudio = false;
-  userSpeakingTimer = null;
-  volumeBuffers;
-  ttsAbortController = null;
+  constructor() {
+    this.name = "SttTtsPlugin";
+    this.description = "Speech-to-text (OpenAI) + conversation + TTS (ElevenLabs)";
+    /**
+     * userId => arrayOfChunks (PCM Int16)
+     */
+    this.pcmBuffers = /* @__PURE__ */ new Map();
+    // TTS queue for sequentially speaking
+    this.ttsQueue = [];
+    this.isSpeaking = false;
+    this.isProcessingAudio = false;
+    this.userSpeakingTimer = null;
+    this.ttsAbortController = null;
+  }
   onAttach(_space) {
-    logger.log("[SttTtsPlugin] onAttach => space was attached");
+    logger2.log("[SttTtsPlugin] onAttach => space was attached");
   }
   async init(params) {
-    logger.log(
-      "[SttTtsPlugin] init => Space fully ready. Subscribing to events."
-    );
+    logger2.log("[SttTtsPlugin] init => Space fully ready. Subscribing to events.");
     this.space = params.space;
     this.janus = this.space?.janusClient;
     const config = params.pluginConfig;
@@ -6642,13 +6297,10 @@ var SttTtsPlugin2 = class {
     arr.push(data.samples);
     if (!this.isSpeaking) {
       this.userSpeakingTimer = setTimeout(() => {
-        logger.log(
-          "[SttTtsPlugin] start processing audio for user =>",
-          data.userId
-        );
+        logger2.log("[SttTtsPlugin] start processing audio for user =>", data.userId);
         this.userSpeakingTimer = null;
         this.processAudio(data.userId).catch(
-          (err) => logger.error("[SttTtsPlugin] handleSilence error =>", err)
+          (err) => logger2.error("[SttTtsPlugin] handleSilence error =>", err)
         );
       }, SILENCE_DETECTION_THRESHOLD_MS);
     } else {
@@ -6673,7 +6325,7 @@ var SttTtsPlugin2 = class {
         if (this.ttsAbortController) {
           this.ttsAbortController.abort();
           this.isSpeaking = false;
-          logger.log("[SttTtsPlugin] TTS playback interrupted");
+          logger2.log("[SttTtsPlugin] TTS playback interrupted");
         }
       }
     }
@@ -6719,16 +6371,14 @@ var SttTtsPlugin2 = class {
     }
     this.isProcessingAudio = true;
     try {
-      logger.log("[SttTtsPlugin] Starting audio processing for user:", userId);
+      logger2.log("[SttTtsPlugin] Starting audio processing for user:", userId);
       const chunks = this.pcmBuffers.get(userId) || [];
       this.pcmBuffers.clear();
       if (!chunks.length) {
-        logger.warn("[SttTtsPlugin] No audio chunks for user =>", userId);
+        logger2.warn("[SttTtsPlugin] No audio chunks for user =>", userId);
         return;
       }
-      logger.log(
-        `[SttTtsPlugin] Flushing STT buffer for user=${userId}, chunks=${chunks.length}`
-      );
+      logger2.log(`[SttTtsPlugin] Flushing STT buffer for user=${userId}, chunks=${chunks.length}`);
       const totalLen = chunks.reduce((acc, c) => acc + c.length, 0);
       const merged = new Int16Array(totalLen);
       let offset = 0;
@@ -6737,19 +6387,16 @@ var SttTtsPlugin2 = class {
         offset += c.length;
       }
       const wavBuffer = await this.convertPcmToWavInMemory(merged, 48e3);
-      const sttText = await this.runtime.useModel(
-        ModelTypes.TRANSCRIPTION,
-        wavBuffer
-      );
-      logger.log(`[SttTtsPlugin] Transcription result: "${sttText}"`);
+      const sttText = await this.runtime.useModel(ModelType.TRANSCRIPTION, wavBuffer);
+      logger2.log(`[SttTtsPlugin] Transcription result: "${sttText}"`);
       if (!sttText || !sttText.trim()) {
-        logger.warn("[SttTtsPlugin] No speech recognized for user =>", userId);
+        logger2.warn("[SttTtsPlugin] No speech recognized for user =>", userId);
         return;
       }
-      logger.log(`[SttTtsPlugin] STT => user=${userId}, text="${sttText}"`);
+      logger2.log(`[SttTtsPlugin] STT => user=${userId}, text="${sttText}"`);
       await this.handleUserMessage(sttText, userId);
     } catch (error) {
-      logger.error("[SttTtsPlugin] processAudio error =>", error);
+      logger2.error("[SttTtsPlugin] processAudio error =>", error);
     } finally {
       this.isProcessingAudio = false;
     }
@@ -6762,7 +6409,7 @@ var SttTtsPlugin2 = class {
     if (!this.isSpeaking) {
       this.isSpeaking = true;
       this.processTtsQueue().catch((err) => {
-        logger.error("[SttTtsPlugin] processTtsQueue error =>", err);
+        logger2.error("[SttTtsPlugin] processTtsQueue error =>", err);
       });
     }
   }
@@ -6776,22 +6423,19 @@ var SttTtsPlugin2 = class {
       this.ttsAbortController = new AbortController();
       const { signal } = this.ttsAbortController;
       try {
-        const responseStream = await this.runtime.useModel(
-          ModelTypes.TEXT_TO_SPEECH,
-          text
-        );
+        const responseStream = await this.runtime.useModel(ModelType.TEXT_TO_SPEECH, text);
         if (!responseStream) {
-          logger.error("[SttTtsPlugin] TTS responseStream is null");
+          logger2.error("[SttTtsPlugin] TTS responseStream is null");
           continue;
         }
-        logger.log("[SttTtsPlugin] Received ElevenLabs TTS stream");
+        logger2.log("[SttTtsPlugin] Received ElevenLabs TTS stream");
         await this.streamTtsStreamToJanus(responseStream, 48e3, signal);
         if (signal.aborted) {
-          logger.log("[SttTtsPlugin] TTS interrupted after streaming");
+          logger2.log("[SttTtsPlugin] TTS interrupted after streaming");
           return;
         }
       } catch (err) {
-        logger.error("[SttTtsPlugin] TTS streaming error =>", err);
+        logger2.error("[SttTtsPlugin] TTS streaming error =>", err);
       } finally {
         this.ttsAbortController = null;
       }
@@ -6806,14 +6450,11 @@ var SttTtsPlugin2 = class {
       return null;
     }
     const numericId = userId.replace("tw-", "");
-    const roomId = createUniqueUuid(
-      this.runtime,
-      `twitter_generate_room-${this.spaceId}`
-    );
+    const roomId = createUniqueUuid(this.runtime, `twitter_generate_room-${this.spaceId}`);
     const userUuid = createUniqueUuid(this.runtime, numericId);
-    const entity = await this.runtime.getDatabaseAdapter().getEntityById(userUuid);
+    const entity = await this.runtime.getEntityById(userUuid);
     if (!entity) {
-      await this.runtime.getDatabaseAdapter().createEntity({
+      await this.runtime.createEntity({
         id: userUuid,
         names: [userId],
         agentId: this.runtime.agentId
@@ -6829,10 +6470,7 @@ var SttTtsPlugin2 = class {
     });
     await this.runtime.ensureParticipantInRoom(userUuid, roomId);
     const memory = {
-      id: createUniqueUuid(
-        this.runtime,
-        `${roomId}-voice-message-${Date.now()}`
-      ),
+      id: createUniqueUuid(this.runtime, `${roomId}-voice-message-${Date.now()}`),
       agentId: this.runtime.agentId,
       content: {
         text: userText,
@@ -6845,10 +6483,7 @@ var SttTtsPlugin2 = class {
     const callback = async (content, _files = []) => {
       try {
         const responseMemory = {
-          id: createUniqueUuid(
-            this.runtime,
-            `${memory.id}-voice-response-${Date.now()}`
-          ),
+          id: createUniqueUuid(this.runtime, `${memory.id}-voice-response-${Date.now()}`),
           entityId: this.runtime.agentId,
           agentId: this.runtime.agentId,
           content: {
@@ -6861,7 +6496,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);
@@ -6872,7 +6507,7 @@ var SttTtsPlugin2 = class {
         return [];
       }
     };
-    this.runtime.emitEvent(["VOICE_MESSAGE_RECEIVED"], {
+    this.runtime.emitEvent(EventType.VOICE_MESSAGE_RECEIVED, {
       runtime: this.runtime,
       message: memory,
       callback
@@ -6905,11 +6540,7 @@ var SttTtsPlugin2 = class {
           reject(new Error(`ffmpeg error code=${code}`));
           return;
         }
-        const samples = new Int16Array(
-          raw.buffer,
-          raw.byteOffset,
-          raw.byteLength / 2
-        );
+        const samples = new Int16Array(raw.buffer, raw.byteOffset, raw.byteLength / 2);
         resolve(samples);
       });
       ff.stdin.write(mp3Buf);
@@ -6924,7 +6555,7 @@ var SttTtsPlugin2 = class {
     const FRAME_SIZE = Math.floor(sampleRate * 0.01);
     for (let offset = 0; offset + FRAME_SIZE <= samples.length; offset += FRAME_SIZE) {
       if (this.ttsAbortController?.signal.aborted) {
-        logger.log("[SttTtsPlugin] streamToJanus interrupted");
+        logger2.log("[SttTtsPlugin] streamToJanus interrupted");
         return;
       }
       const frame = new Int16Array(FRAME_SIZE);
@@ -6938,7 +6569,7 @@ var SttTtsPlugin2 = class {
     return new Promise((resolve, reject) => {
       stream.on("data", (chunk) => {
         if (signal.aborted) {
-          logger.log("[SttTtsPlugin] Stream aborted, stopping playback");
+          logger2.log("[SttTtsPlugin] Stream aborted, stopping playback");
           stream.destroy();
           reject(new Error("TTS streaming aborted"));
           return;
@@ -6947,7 +6578,7 @@ var SttTtsPlugin2 = class {
       });
       stream.on("end", async () => {
         if (signal.aborted) {
-          logger.log("[SttTtsPlugin] Stream ended but was aborted");
+          logger2.log("[SttTtsPlugin] Stream ended but was aborted");
           return reject(new Error("TTS streaming aborted"));
         }
         const mp3Buffer = Buffer.concat(chunks);
@@ -6960,13 +6591,13 @@ var SttTtsPlugin2 = class {
         }
       });
       stream.on("error", (error) => {
-        logger.error("[SttTtsPlugin] Error in TTS stream", error);
+        logger2.error("[SttTtsPlugin] Error in TTS stream", error);
         reject(error);
       });
     });
   }
   cleanup() {
-    logger.log("[SttTtsPlugin] cleanup => releasing resources");
+    logger2.log("[SttTtsPlugin] cleanup => releasing resources");
     this.pcmBuffers.clear();
     this.userSpeakingTimer = null;
     this.ttsQueue = [];
@@ -6980,111 +6611,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
+  logger as logger3
 } from "@elizaos/core";
-var wait = (minTime = 1e3, maxTime = 3e3) => {
-  const waitTime = Math.floor(Math.random() * (maxTime - minTime + 1)) + minTime;
-  return new Promise((resolve) => setTimeout(resolve, waitTime));
-};
-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) => {
@@ -7094,206 +6625,18 @@ 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 mediaBuffer = await fs.promises.readFile(path.resolve(attachment.url));
+        const mediaType = attachment.contentType || "image/png";
         return { data: mediaBuffer, mediaType };
       }
-      throw new Error(
-        `File not found: ${attachment.url}. Make sure the path is correct.`
-      );
+      throw new Error(`File not found: ${attachment.url}. Make sure the path is correct.`);
     })
   );
 }
-async function sendTweet(client, content, roomId, twitterUsername, inReplyTo) {
-  const isLongTweet = content.text.length > 280 - 1;
-  const tweetChunks = splitTweetContent(content.text, 280 - 1);
-  const sentTweets = [];
-  let previousTweetId = inReplyTo;
-  for (const chunk of tweetChunks) {
-    let mediaData = null;
-    if (content.attachments && content.attachments.length > 0) {
-      mediaData = await fetchMediaData(content.attachments);
-    }
-    const cleanChunk = deduplicateMentions(chunk.trim());
-    const result = await client.requestQueue.add(
-      async () => isLongTweet ? client.twitterClient.sendLongTweet(
-        cleanChunk,
-        previousTweetId,
-        mediaData
-      ) : client.twitterClient.sendTweet(
-        cleanChunk,
-        previousTweetId,
-        mediaData
-      )
-    );
-    const body = await result.json();
-    const tweetResult = isLongTweet ? body?.data?.notetweet_create?.tweet_results?.result : body?.data?.create_tweet?.tweet_results?.result;
-    if (tweetResult) {
-      const finalTweet = {
-        id: tweetResult.rest_id,
-        text: tweetResult.legacy.full_text,
-        conversationId: tweetResult.legacy.conversation_id_str,
-        timestamp: new Date(tweetResult.legacy.created_at).getTime() / 1e3,
-        userId: tweetResult.legacy.user_id_str,
-        inReplyToStatusId: tweetResult.legacy.in_reply_to_status_id_str,
-        permanentUrl: `https://twitter.com/${twitterUsername}/status/${tweetResult.rest_id}`,
-        hashtags: [],
-        mentions: [],
-        photos: [],
-        thread: [],
-        urls: [],
-        videos: []
-      };
-      sentTweets.push(finalTweet);
-      previousTweetId = finalTweet.id;
-    } else {
-      logger2.error("Error sending tweet chunk:", {
-        chunk,
-        response: body
-      });
-    }
-    await wait(1e3, 2e3);
-  }
-  const memories = sentTweets.map((tweet) => ({
-    id: createUniqueUuid2(client.runtime, tweet.id),
-    agentId: client.runtime.agentId,
-    entityId: client.runtime.agentId,
-    content: {
-      tweetId: tweet.id,
-      text: tweet.text,
-      source: "twitter",
-      url: tweet.permanentUrl,
-      imageUrls: tweet.photos.map((p) => p.url) || [],
-      inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid2(client.runtime, tweet.inReplyToStatusId) : void 0
-    },
-    roomId,
-    createdAt: tweet.timestamp * 1e3
-  }));
-  return memories;
-}
-function splitTweetContent(content, maxLength) {
-  const paragraphs = content.split("\n\n").map((p) => p.trim());
-  const tweets = [];
-  let currentTweet = "";
-  for (const paragraph of paragraphs) {
-    if (!paragraph) continue;
-    if (`${currentTweet}
-
-${paragraph}`.trim().length <= maxLength) {
-      if (currentTweet) {
-        currentTweet += `
-
-${paragraph}`;
-      } else {
-        currentTweet = paragraph;
-      }
-    } else {
-      if (currentTweet) {
-        tweets.push(currentTweet.trim());
-      }
-      if (paragraph.length <= maxLength) {
-        currentTweet = paragraph;
-      } else {
-        const chunks = splitParagraph(paragraph, maxLength);
-        tweets.push(...chunks.slice(0, -1));
-        currentTweet = chunks[chunks.length - 1];
-      }
-    }
-  }
-  if (currentTweet) {
-    tweets.push(currentTweet.trim());
-  }
-  return tweets;
-}
-function extractUrls(paragraph) {
-  const urlRegex = /https?:\/\/[^\s]+/g;
-  const placeholderMap = /* @__PURE__ */ new Map();
-  let urlIndex = 0;
-  const textWithPlaceholders = paragraph.replace(urlRegex, (match) => {
-    const placeholder = `<<URL_CONSIDERER_23_${urlIndex}>>`;
-    placeholderMap.set(placeholder, match);
-    urlIndex++;
-    return placeholder;
-  });
-  return { textWithPlaceholders, placeholderMap };
-}
-function splitSentencesAndWords(text, maxLength) {
-  const sentences = text.match(/[^.!?]+[.!?]+|[^.!?]+$/g) || [text];
-  const chunks = [];
-  let currentChunk = "";
-  for (const sentence of sentences) {
-    if (`${currentChunk} ${sentence}`.trim().length <= maxLength) {
-      if (currentChunk) {
-        currentChunk += ` ${sentence}`;
-      } else {
-        currentChunk = sentence;
-      }
-    } else {
-      if (currentChunk) {
-        chunks.push(currentChunk.trim());
-      }
-      if (sentence.length <= maxLength) {
-        currentChunk = sentence;
-      } else {
-        const words = sentence.split(" ");
-        currentChunk = "";
-        for (const word of words) {
-          if (`${currentChunk} ${word}`.trim().length <= maxLength) {
-            if (currentChunk) {
-              currentChunk += ` ${word}`;
-            } else {
-              currentChunk = word;
-            }
-          } else {
-            if (currentChunk) {
-              chunks.push(currentChunk.trim());
-            }
-            currentChunk = word;
-          }
-        }
-      }
-    }
-  }
-  if (currentChunk) {
-    chunks.push(currentChunk.trim());
-  }
-  return chunks;
-}
-function deduplicateMentions(paragraph) {
-  const mentionRegex = /^@(\w+)(?:\s+@(\w+))*(\s+|$)/;
-  const matches = paragraph.match(mentionRegex);
-  if (!matches) {
-    return paragraph;
-  }
-  let mentions = matches.slice(0, 1)[0].trim().split(" ");
-  mentions = Array.from(new Set(mentions));
-  const uniqueMentionsString = mentions.join(" ");
-  const endOfMentions = paragraph.indexOf(matches[0]) + matches[0].length;
-  return `${uniqueMentionsString} ${paragraph.slice(endOfMentions)}`;
-}
-function restoreUrls(chunks, placeholderMap) {
-  return chunks.map((chunk) => {
-    return chunk.replace(/<<URL_CONSIDERER_23_(\d+)>>/g, (match) => {
-      const original = placeholderMap.get(match);
-      return original || match;
-    });
-  });
-}
-function splitParagraph(paragraph, maxLength) {
-  const { textWithPlaceholders, placeholderMap } = extractUrls(paragraph);
-  const splittedChunks = splitSentencesAndWords(
-    textWithPlaceholders,
-    maxLength
-  );
-  const restoredChunks = restoreUrls(splittedChunks, placeholderMap);
-  return restoredChunks;
-}
 async function generateFiller(runtime, fillerType) {
   try {
     const prompt = composePrompt({
@@ -7311,12 +6654,12 @@ 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();
   } catch (err) {
-    logger2.error("[generateFiller] Error generating filler:", err);
+    logger3.error("[generateFiller] Error generating filler:", err);
     return "";
   }
 }
@@ -7324,7 +6667,7 @@ async function speakFiller(runtime, sttTtsPlugin, fillerType, sleepAfterMs = 3e3
   if (!sttTtsPlugin) return;
   const text = await generateFiller(runtime, fillerType);
   if (!text) return;
-  logger2.log(`[Space] Filler (${fillerType}) => ${text}`);
+  logger3.log(`[Space] Filler (${fillerType}) => ${text}`);
   await sttTtsPlugin.speakText(text);
   if (sleepAfterMs > 0) {
     await new Promise((res) => setTimeout(res, sleepAfterMs));
@@ -7344,13 +6687,13 @@ 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);
     return topics.length ? topics : ["Random Tech Chat", "AI Thoughts"];
   } catch (err) {
-    logger2.error("[generateTopicsIfEmpty] GPT error =>", err);
+    logger3.error("[generateTopicsIfEmpty] GPT error =>", err);
     return ["Random Tech Chat", "AI Thoughts"];
   }
 }
@@ -7359,32 +6702,20 @@ async function isAgentInSpace(client, spaceId) {
   const agentName = client.state.TWITTER_USERNAME;
   return space.participants.listeners.some(
     (participant) => participant.twitter_screen_name === agentName
-  ) || space.participants.speakers.some(
-    (participant) => participant.twitter_screen_name === agentName
-  );
+  ) || space.participants.speakers.some((participant) => participant.twitter_screen_name === agentName);
 }
 
 // src/spaces.ts
 var TwitterSpaceClient = class {
-  runtime;
-  client;
-  twitterClient;
-  currentSpace;
-  spaceId;
-  startedAt;
-  checkInterval;
-  lastSpaceEndedAt;
-  sttTtsPlugin;
-  spaceStatus = "idle" /* IDLE */;
-  spaceParticipant = null;
-  participantStatus = "listener" /* LISTENER */;
-  /**
-   * We now store an array of active speakers, not just 1
-   */
-  activeSpeakers = [];
-  speakerQueue = [];
-  decisionOptions;
   constructor(client, runtime) {
+    this.spaceStatus = "idle" /* IDLE */;
+    this.spaceParticipant = null;
+    this.participantStatus = "listener" /* LISTENER */;
+    /**
+     * We now store an array of active speakers, not just 1
+     */
+    this.activeSpeakers = [];
+    this.speakerQueue = [];
     this.client = client;
     this.twitterClient = client.twitterClient;
     this.runtime = runtime;
@@ -7405,7 +6736,7 @@ var TwitterSpaceClient = class {
    * Periodic check to launch or manage space
    */
   async startPeriodicSpaceCheck() {
-    logger3.log("[Space] Starting periodic check routine...");
+    logger4.log("[Space] Starting periodic check routine...");
     const interval = 2e4;
     const routine = async () => {
       try {
@@ -7426,7 +6757,7 @@ var TwitterSpaceClient = class {
         }
         this.checkInterval = setTimeout(routine, interval);
       } catch (error) {
-        logger3.error("[Space] Error in routine =>", error);
+        logger4.error("[Space] Error in routine =>", error);
         this.checkInterval = setTimeout(routine, interval);
       }
     };
@@ -7443,11 +6774,11 @@ var TwitterSpaceClient = class {
     if (this.lastSpaceEndedAt) {
       const minIntervalMs = (this.decisionOptions.minIntervalBetweenSpacesMinutes ?? 60) * 6e4;
       if (now - this.lastSpaceEndedAt < minIntervalMs) {
-        logger3.log("[Space] Too soon since last space => skip");
+        logger4.log("[Space] Too soon since last space => skip");
         return false;
       }
     }
-    logger3.log("[Space] Deciding to launch a new Space...");
+    logger4.log("[Space] Deciding to launch a new Space...");
     return true;
   }
   async generateSpaceConfig() {
@@ -7467,7 +6798,7 @@ var TwitterSpaceClient = class {
     };
   }
   async startSpace(config) {
-    logger3.log("[Space] Starting a new Twitter Space...");
+    logger4.log("[Space] Starting a new Twitter Space...");
     try {
       this.currentSpace = new Space(this.twitterClient);
       this.spaceStatus = "idle" /* IDLE */;
@@ -7477,55 +6808,79 @@ 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)) {
-        logger3.log("[Space] Using SttTtsPlugin");
+      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)) {
+        logger4.log("[Space] Using SttTtsPlugin");
         this.currentSpace.use(this.sttTtsPlugin, {
           runtime: this.runtime,
           spaceId: this.spaceId
         });
       }
       if (this.decisionOptions.enableIdleMonitor) {
-        logger3.log("[Space] Using IdleMonitorPlugin");
+        logger4.log("[Space] Using IdleMonitorPlugin");
         this.currentSpace.use(
-          new IdleMonitorPlugin(
-            this.decisionOptions.idleKickTimeoutMs ?? 6e4,
-            1e4
-          )
+          new IdleMonitorPlugin(this.decisionOptions.idleKickTimeoutMs ?? 6e4, 1e4)
         );
       }
       this.spaceStatus = "hosting" /* HOSTING */;
-      await this.twitterClient.sendTweet(
-        broadcastInfo.share_url.replace("broadcasts", "spaces")
-      );
       const spaceUrl = broadcastInfo.share_url.replace("broadcasts", "spaces");
-      logger3.log(`[Space] Space started => ${spaceUrl}`);
+      await this.twitterClient.sendTweet(spaceUrl);
+      logger4.log(`[Space] Space started => ${spaceUrl}`);
       await speakFiller(this.client.runtime, this.sttTtsPlugin, "WELCOME");
       this.currentSpace.on("occupancyUpdate", (update) => {
-        logger3.log(`[Space] Occupancy => ${update.occupancy} participant(s).`);
+        logger4.log(`[Space] Occupancy => ${update.occupancy} participant(s).`);
       });
       this.currentSpace.on("speakerRequest", async (req) => {
-        logger3.log(
-          `[Space] Speaker request from @${req.username} (${req.userId}).`
-        );
+        logger4.log(`[Space] Speaker request from @${req.username} (${req.userId}).`);
         await this.handleSpeakerRequest(req);
       });
       this.currentSpace.on("idleTimeout", async (info) => {
-        logger3.log(`[Space] idleTimeout => no audio for ${info.idleMs} ms.`);
-        await speakFiller(
-          this.client.runtime,
-          this.sttTtsPlugin,
-          "IDLE_ENDING"
-        );
+        logger4.log(`[Space] idleTimeout => no audio for ${info.idleMs} ms.`);
+        await speakFiller(this.client.runtime, this.sttTtsPlugin, "IDLE_ENDING");
         await this.stopSpace();
       });
       process.on("SIGINT", async () => {
-        logger3.log("[Space] SIGINT => stopping space");
+        logger4.log("[Space] SIGINT => stopping space");
         await speakFiller(this.client.runtime, this.sttTtsPlugin, "CLOSING");
         await this.stopSpace();
         process.exit(0);
       });
     } catch (error) {
-      logger3.error("[Space] Error launching Space =>", error);
+      logger4.error("[Space] Error launching Space =>", error);
       this.spaceStatus = "idle" /* IDLE */;
       throw error;
     }
@@ -7536,9 +6891,7 @@ var TwitterSpaceClient = class {
   async manageCurrentSpace() {
     if (!this.spaceId || !this.currentSpace) return;
     try {
-      const audioSpace = await this.twitterClient.getAudioSpaceById(
-        this.spaceId
-      );
+      const audioSpace = await this.twitterClient.getAudioSpaceById(this.spaceId);
       const { participants } = audioSpace;
       const numSpeakers = participants.speakers?.length || 0;
       const totalListeners = participants.listeners?.length || 0;
@@ -7548,36 +6901,25 @@ var TwitterSpaceClient = class {
         const speaker = this.activeSpeakers[i];
         const elapsed = now - speaker.startTime;
         if (elapsed > maxDur) {
-          logger3.log(
-            `[Space] Speaker @${speaker.username} exceeded max duration => removing`
-          );
+          logger4.log(`[Space] Speaker @${speaker.username} exceeded max duration => removing`);
           await this.removeSpeaker(speaker.userId);
           this.activeSpeakers.splice(i, 1);
-          await speakFiller(
-            this.client.runtime,
-            this.sttTtsPlugin,
-            "SPEAKER_LEFT"
-          );
+          await speakFiller(this.client.runtime, this.sttTtsPlugin, "SPEAKER_LEFT");
         }
       }
       await this.acceptSpeakersFromQueueIfNeeded();
       if (numSpeakers > (this.decisionOptions.maxSpeakers ?? 1)) {
-        logger3.log("[Space] More than maxSpeakers => removing extras...");
+        logger4.log("[Space] More than maxSpeakers => removing extras...");
         await this.kickExtraSpeakers(participants.speakers);
       }
       const elapsedMinutes = (now - (this.startedAt || 0)) / 6e4;
       if (elapsedMinutes > (this.decisionOptions.typicalDurationMinutes ?? 30) || numSpeakers === 0 && totalListeners === 0 && elapsedMinutes > 5) {
-        logger3.log("[Space] Condition met => stopping the Space...");
-        await speakFiller(
-          this.client.runtime,
-          this.sttTtsPlugin,
-          "CLOSING",
-          4e3
-        );
+        logger4.log("[Space] Condition met => stopping the Space...");
+        await speakFiller(this.client.runtime, this.sttTtsPlugin, "CLOSING", 4e3);
         await this.stopSpace();
       }
     } catch (error) {
-      logger3.error("[Space] Error in manageCurrentSpace =>", error);
+      logger4.error("[Space] Error in manageCurrentSpace =>", error);
     }
   }
   /**
@@ -7598,11 +6940,11 @@ var TwitterSpaceClient = class {
     const audioSpace = await this.twitterClient.getAudioSpaceById(this.spaceId);
     const janusSpeakers = audioSpace?.participants?.speakers || [];
     if (janusSpeakers.length < (this.decisionOptions.maxSpeakers ?? 1)) {
-      logger3.log(`[Space] Accepting speaker @${req.username} now`);
+      logger4.log(`[Space] Accepting speaker @${req.username} now`);
       await speakFiller(this.client.runtime, this.sttTtsPlugin, "PRE_ACCEPT");
       await this.acceptSpeaker(req);
     } else {
-      logger3.log(`[Space] Adding speaker @${req.username} to the queue`);
+      logger4.log(`[Space] Adding speaker @${req.username} to the queue`);
       this.speakerQueue.push(req);
     }
   }
@@ -7616,18 +6958,18 @@ var TwitterSpaceClient = class {
         username: req.username,
         startTime: Date.now()
       });
-      logger3.log(`[Space] Speaker @${req.username} is now live`);
+      logger4.log(`[Space] Speaker @${req.username} is now live`);
     } catch (err) {
-      logger3.error(`[Space] Error approving speaker @${req.username}:`, err);
+      logger4.error(`[Space] Error approving speaker @${req.username}:`, err);
     }
   }
   async removeSpeaker(userId) {
     if (!this.currentSpace) return;
     try {
       await this.currentSpace.removeSpeaker(userId);
-      logger3.log(`[Space] Removed speaker userId=${userId}`);
+      logger4.log(`[Space] Removed speaker userId=${userId}`);
     } catch (error) {
-      logger3.error(`[Space] Error removing speaker userId=${userId} =>`, error);
+      logger4.error(`[Space] Error removing speaker userId=${userId} =>`, error);
     }
   }
   /**
@@ -7639,7 +6981,7 @@ var TwitterSpaceClient = class {
     const ms = this.decisionOptions.maxSpeakers ?? 1;
     const extras = speakers.slice(ms);
     for (const sp of extras) {
-      logger3.log(`[Space] Removing extra speaker => userId=${sp.user_id}`);
+      logger4.log(`[Space] Removing extra speaker => userId=${sp.user_id}`);
       await this.removeSpeaker(sp.user_id);
       const idx = this.activeSpeakers.findIndex((s) => s.userId === sp.user_id);
       if (idx !== -1) {
@@ -7648,13 +6990,12 @@ var TwitterSpaceClient = class {
     }
   }
   async stopSpace() {
-    if (!this.currentSpace || this.spaceStatus !== "hosting" /* HOSTING */)
-      return;
+    if (!this.currentSpace || this.spaceStatus !== "hosting" /* HOSTING */) return;
     try {
-      logger3.log("[Space] Stopping the current Space...");
+      logger4.log("[Space] Stopping the current Space...");
       await this.currentSpace.stop();
     } catch (err) {
-      logger3.error("[Space] Error stopping Space =>", err);
+      logger4.error("[Space] Error stopping Space =>", err);
     } finally {
       this.spaceStatus = "idle" /* IDLE */;
       this.spaceId = void 0;
@@ -7667,7 +7008,7 @@ var TwitterSpaceClient = class {
   }
   async startParticipant(spaceId) {
     if (this.spaceStatus !== "idle" /* IDLE */) {
-      logger3.warn("currently hosting/participating a space");
+      logger4.warn("currently hosting/participating a space");
       return null;
     }
     this.spaceParticipant = new SpaceParticipant(this.client.twitterClient, {
@@ -7681,7 +7022,7 @@ var TwitterSpaceClient = class {
         this.spaceStatus = "participating" /* PARTICIPATING */;
         return spaceId;
       } catch (error) {
-        logger3.error(`failed to join space ${error}`);
+        logger4.error(`failed to join space ${error}`);
         return null;
       }
     }
@@ -7697,14 +7038,12 @@ var TwitterSpaceClient = class {
       return;
     }
     if (this.participantStatus === "listener" /* LISTENER */) {
-      logger3.log(
-        "[SpaceParticipant] Checking if we should request to speak..."
-      );
+      logger4.log("[SpaceParticipant] Checking if we should request to speak...");
       this.participantStatus = "pending" /* PENDING */;
       const { sessionUUID } = await this.spaceParticipant.requestSpeaker();
       const handleSpeakerRemove = async (evt) => {
         if (evt.sessionUUID === sessionUUID) {
-          console.log("[SpaceParticipant] Speaker removed:", evt);
+          logger4.debug("[SpaceParticipant] Speaker removed:", evt);
           try {
             await this.spaceParticipant.removeFromSpeaker();
           } catch (err) {
@@ -7726,31 +7065,20 @@ var TwitterSpaceClient = class {
         this.participantStatus = "listener" /* LISTENER */;
         try {
           await this.spaceParticipant.cancelSpeakerRequest();
-          console.log(
-            "[SpaceParticipant] Speaker request canceled after timeout or error."
-          );
+          logger4.debug("[SpaceParticipant] Speaker request canceled after timeout or error.");
         } catch (cancelErr) {
-          console.error(
-            "[SpaceParticipant] Could not cancel the request =>",
-            cancelErr
-          );
+          console.error("[SpaceParticipant] Could not cancel the request =>", cancelErr);
         }
       });
     }
   }
   async stopParticipant() {
-    if (!this.spaceParticipant || this.spaceStatus !== "participating" /* PARTICIPATING */)
-      return;
+    if (!this.spaceParticipant || this.spaceStatus !== "participating" /* PARTICIPATING */) return;
     try {
-      logger3.log(
-        "[SpaceParticipant] Stopping the current space participant..."
-      );
+      logger4.log("[SpaceParticipant] Stopping the current space participant...");
       await this.spaceParticipant.leaveSpace();
     } catch (err) {
-      logger3.error(
-        "[SpaceParticipant] Error stopping space participant =>",
-        err
-      );
+      logger4.error("[SpaceParticipant] Error stopping space participant =>", err);
     } finally {
       this.spaceStatus = "idle" /* IDLE */;
       this.participantStatus = "listener" /* LISTENER */;
@@ -7771,7 +7099,7 @@ var TwitterSpaceClient = class {
           participant.off("newSpeakerAccepted", handler);
           try {
             await participant.becomeSpeaker();
-            console.log("[SpaceParticipant] Successfully became speaker!");
+            logger4.debug("[SpaceParticipant] Successfully became speaker!");
             resolve();
           } catch (err) {
             reject(err);
@@ -7816,13 +7144,13 @@ var spaceJoin_default = {
   description: "Join a Twitter Space to participate in live audio conversations.",
   handler: async (runtime, message, state, _options, callback, responses) => {
     if (!state) {
-      logger4.error("State is not available.");
+      logger5.error("State is not available.");
       return false;
     }
     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");
     }
@@ -7831,16 +7159,16 @@ var spaceJoin_default = {
     const client = manager.clients.get(clientKey).client;
     const spaceManager = manager.clients.get(clientKey).space;
     if (!spaceManager) {
-      logger4.error("space action - no space manager found");
+      logger5.error("space action - no space manager found");
       return false;
     }
     if (spaceManager.spaceStatus !== "idle" /* IDLE */) {
-      logger4.warn("currently hosting/participating a space");
+      logger5.warn("currently hosting/participating a space");
       return false;
     }
     const tweet = message.content.tweet;
     if (!tweet) {
-      logger4.warn("space action - no tweet found in message");
+      logger5.warn("space action - no tweet found in message");
       return false;
     }
     async function joinSpaceByUrls(tweet2) {
@@ -7856,7 +7184,7 @@ var spaceJoin_default = {
               return !!spaceJoined2;
             }
           } catch (error) {
-            logger4.error("Error joining Twitter Space:", error);
+            logger5.error("Error joining Twitter Space:", error);
           }
         }
       }
@@ -7871,7 +7199,7 @@ var spaceJoin_default = {
           }
         }
       } catch (error) {
-        logger4.error(`Error fetching tweets for ${userName}:`, error);
+        logger5.error(`Error fetching tweets for ${userName}:`, error);
       }
       return false;
     }
@@ -7927,15 +7255,16 @@ var spaceJoin_default = {
 };
 
 // src/base.ts
-import { EventEmitter as EventEmitter6 } from "node:events";
 import {
-  ChannelType as ChannelType3,
-  createUniqueUuid as createUniqueUuid3,
-  logger as logger5
+  ChannelType as ChannelType4,
+  createUniqueUuid as createUniqueUuid4,
+  logger as logger6
 } from "@elizaos/core";
 var RequestQueue = class {
-  queue = [];
-  processing = false;
+  constructor() {
+    this.queue = [];
+    this.processing = false;
+  }
   /**
    * Asynchronously adds a request to the queue, then processes the queue.
    *
@@ -7998,14 +7327,22 @@ var RequestQueue = class {
     await new Promise((resolve) => setTimeout(resolve, delay));
   }
 };
-var ClientBase = class _ClientBase extends EventEmitter6 {
-  static _twitterClients = {};
-  twitterClient;
-  runtime;
-  lastCheckedTweetId = null;
-  temperature = 0.5;
-  requestQueue = new RequestQueue();
-  profile;
+var _ClientBase = class _ClientBase {
+  constructor(runtime, state) {
+    this.lastCheckedTweetId = null;
+    this.temperature = 0.5;
+    this.requestQueue = new RequestQueue();
+    this.callback = null;
+    this.runtime = runtime;
+    this.state = state;
+    const username = state?.TWITTER_USERNAME || this.runtime.getSetting("TWITTER_USERNAME");
+    if (_ClientBase._twitterClients[username]) {
+      this.twitterClient = _ClientBase._twitterClients[username];
+    } else {
+      this.twitterClient = new Client();
+      _ClientBase._twitterClients[username] = this.twitterClient;
+    }
+  }
   /**
    * Caches a tweet in the database.
    *
@@ -8017,7 +7354,7 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
       console.warn("Tweet is undefined, skipping cache");
       return;
     }
-    this.runtime.getDatabaseAdapter().setCache(`twitter/tweets/${tweet.id}`, tweet);
+    this.runtime.setCache(`twitter/tweets/${tweet.id}`, tweet);
   }
   /**
    * Retrieves a cached tweet by its ID.
@@ -8025,7 +7362,7 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
    * @returns {Promise<Tweet | undefined>} A Promise that resolves to the cached tweet, or undefined if the tweet is not found in the cache.
    */
   async getCachedTweet(tweetId) {
-    const cached = await this.runtime.getDatabaseAdapter().getCache(`twitter/tweets/${tweetId}`);
+    const cached = await this.runtime.getCache(`twitter/tweets/${tweetId}`);
     if (!cached) {
       return void 0;
     }
@@ -8043,13 +7380,10 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
     if (cachedTweet) {
       return cachedTweet;
     }
-    const tweet = await this.requestQueue.add(
-      () => this.twitterClient.getTweet(tweetId)
-    );
+    const tweet = await this.requestQueue.add(() => this.twitterClient.getTweet(tweetId));
     await this.cacheTweet(tweet);
     return tweet;
   }
-  callback = null;
   /**
    * This method is called when the application is ready.
    * It throws an error indicating that it is not implemented in the base class
@@ -8072,17 +7406,13 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
   parseTweet(raw, depth = 0, maxDepth = 3) {
     const canRecurse = depth < maxDepth;
     const quotedStatus = raw.quoted_status_result?.result && canRecurse ? this.parseTweet(raw.quoted_status_result.result, depth + 1, maxDepth) : void 0;
-    const retweetedStatus = raw.retweeted_status_result?.result && canRecurse ? this.parseTweet(
-      raw.retweeted_status_result.result,
-      depth + 1,
-      maxDepth
-    ) : void 0;
+    const retweetedStatus = raw.retweeted_status_result?.result && canRecurse ? this.parseTweet(raw.retweeted_status_result.result, depth + 1, maxDepth) : void 0;
     const t = {
       bookmarkCount: raw.bookmarkCount ?? raw.legacy?.bookmark_count ?? void 0,
       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,
@@ -8096,7 +7426,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
       })) || []),
@@ -8116,28 +7446,14 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
       urls: raw.urls ?? raw.legacy?.entities?.urls ?? [],
       userId: raw.userId ?? raw.legacy?.user_id_str ?? void 0,
       username: raw.username ?? raw.core?.user_results?.result?.legacy?.screen_name ?? void 0,
-      videos: raw.videos ?? raw.legacy?.entities?.media?.filter(
-        (media) => media.type === "video"
-      ) ?? [],
+      videos: raw.videos ?? raw.legacy?.entities?.media?.filter((media) => media.type === "video") ?? [],
       views: raw.views?.count ? Number(raw.views.count) : 0,
       sensitiveContent: raw.sensitiveContent
     };
     return t;
   }
-  state;
-  constructor(runtime, state) {
-    super();
-    this.runtime = runtime;
-    this.state = state;
-    const username = state?.TWITTER_USERNAME || this.runtime.getSetting("TWITTER_USERNAME");
-    if (_ClientBase._twitterClients[username]) {
-      this.twitterClient = _ClientBase._twitterClients[username];
-    } else {
-      this.twitterClient = new Client();
-      _ClientBase._twitterClients[username] = this.twitterClient;
-    }
-  }
   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");
@@ -8147,68 +7463,58 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
       if (!username) missing.push("TWITTER_USERNAME");
       if (!password) missing.push("TWITTER_PASSWORD");
       if (!email) missing.push("TWITTER_EMAIL");
-      throw new Error(
-        `Missing required Twitter credentials: ${missing.join(", ")}`
-      );
+      throw new Error(`Missing required Twitter credentials: ${missing.join(", ")}`);
     }
-    let retries = (this.state?.TWITTER_RETRY_LIMIT || this.runtime.getSetting(
-      "TWITTER_RETRY_LIMIT"
-    )) ?? 3;
-    if (!username) {
-      throw new Error("Twitter username not configured");
-    }
-    const authToken = this.state?.TWITTER_COOKIES_AUTH_TOKEN || this.runtime.getSetting("TWITTER_COOKIES_AUTH_TOKEN");
-    const ct0 = this.state?.TWITTER_COOKIES_CT0 || this.runtime.getSetting("TWITTER_COOKIES_CT0");
-    const guestId = this.state?.TWITTER_COOKIES_GUEST_ID || this.runtime.getSetting("TWITTER_COOKIES_GUEST_ID");
-    const createTwitterCookies = (authToken2, ct02, guestId2) => authToken2 && ct02 && guestId2 ? [
-      { key: "auth_token", value: authToken2, domain: ".twitter.com" },
-      { key: "ct0", value: ct02, domain: ".twitter.com" },
-      { key: "guest_id", value: guestId2, domain: ".twitter.com" }
-    ] : null;
-    const cachedCookies = await this.getCachedCookies(username) || createTwitterCookies(authToken, ct0, guestId);
-    if (cachedCookies) {
-      logger5.info("Using cached cookies");
-      await this.setCookiesFromArray(cachedCookies);
-    }
-    logger5.log("Waiting for Twitter login");
-    while (retries > 0) {
+    const maxRetries = 3;
+    let retryCount = 0;
+    let lastError = null;
+    while (retryCount < maxRetries) {
       try {
+        const authToken = this.state?.TWITTER_COOKIES_AUTH_TOKEN || this.runtime.getSetting("TWITTER_COOKIES_AUTH_TOKEN");
+        const ct0 = this.state?.TWITTER_COOKIES_CT0 || this.runtime.getSetting("TWITTER_COOKIES_CT0");
+        const guestId = this.state?.TWITTER_COOKIES_GUEST_ID || this.runtime.getSetting("TWITTER_COOKIES_GUEST_ID");
+        const createTwitterCookies = (authToken2, ct02, guestId2) => authToken2 && ct02 && guestId2 ? [
+          { key: "auth_token", value: authToken2, domain: ".twitter.com" },
+          { key: "ct0", value: ct02, domain: ".twitter.com" },
+          { key: "guest_id", value: guestId2, domain: ".twitter.com" }
+        ] : null;
+        const cachedCookies = await this.getCachedCookies(username) || createTwitterCookies(authToken, ct0, guestId);
+        if (cachedCookies) {
+          logger6.info("Using cached cookies");
+          await this.setCookiesFromArray(cachedCookies);
+        }
+        logger6.log("Waiting for Twitter login");
         if (await this.twitterClient.isLoggedIn()) {
-          logger5.info("Successfully logged in.");
+          logger6.info("Successfully logged in.");
           break;
         }
-        await this.twitterClient.login(
-          username,
-          password,
-          email,
-          twitter2faSecret
-        );
+        await this.twitterClient.login(username, password, email, twitter2faSecret);
         if (await this.twitterClient.isLoggedIn()) {
-          logger5.info("Successfully logged in.");
-          logger5.info("Caching cookies");
-          await this.cacheCookies(
-            username,
-            await this.twitterClient.getCookies()
-          );
+          logger6.info("Successfully logged in.");
+          logger6.info("Caching cookies");
+          await this.cacheCookies(username, await this.twitterClient.getCookies());
           break;
         }
       } catch (error) {
-        logger5.error(`Login attempt failed: ${error.message}`);
+        lastError = error instanceof Error ? error : new Error(String(error));
+        logger6.error(`Login attempt ${retryCount + 1} failed: ${lastError.message}`);
+        retryCount++;
+        if (retryCount < maxRetries) {
+          const delay = 2 ** retryCount * 1e3;
+          logger6.info(`Retrying in ${delay / 1e3} seconds...`);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
       }
-      retries--;
-      logger5.error(
-        `Failed to login to Twitter. Retrying... (${retries} attempts left)`
+    }
+    if (retryCount >= maxRetries) {
+      throw new Error(
+        `Twitter login failed after ${maxRetries} attempts. Last error: ${lastError?.message}`
       );
-      if (retries === 0) {
-        logger5.error("Max retries reached. Exiting login process.");
-        throw new Error("Twitter login failed after maximum retries.");
-      }
-      await new Promise((resolve) => setTimeout(resolve, 2e3));
     }
     this.profile = await this.fetchProfile(username);
     if (this.profile) {
-      logger5.log("Twitter user ID:", this.profile.id);
-      logger5.log("Twitter loaded:", JSON.stringify(this.profile, null, 10));
+      logger6.log("Twitter user ID:", this.profile.id);
+      logger6.log("Twitter loaded:", JSON.stringify(this.profile, null, 10));
       this.profile = {
         id: this.profile.id,
         username: this.profile.username,
@@ -8223,20 +7529,16 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
     await this.populateTimeline();
   }
   async fetchOwnPosts(count) {
-    logger5.debug("fetching own posts");
-    const homeTimeline = await this.twitterClient.getUserTweets(
-      this.profile.id,
-      count
-    );
+    logger6.debug("fetching own posts");
+    const homeTimeline = await this.twitterClient.getUserTweets(this.profile.id, count);
     return homeTimeline.tweets.map((t) => this.parseTweet(t));
   }
   /**
    * Fetch timeline for twitter account, optionally only from followed accounts
    */
   async fetchHomeTimeline(count, following) {
-    logger5.debug("fetching home timeline");
+    logger6.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;
   }
@@ -8248,87 +7550,97 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
       try {
         const result = await this.requestQueue.add(
           async () => await Promise.race([
-            this.twitterClient.fetchSearchTweets(
-              query,
-              maxTweets,
-              searchMode,
-              cursor
-            ),
+            this.twitterClient.fetchSearchTweets(query, maxTweets, searchMode, cursor),
             timeoutPromise
           ])
         );
         return result ?? { tweets: [] };
       } catch (error) {
-        logger5.error("Error fetching search tweets:", error);
+        logger6.error("Error fetching search tweets:", error);
         return { tweets: [] };
       }
     } catch (error) {
-      logger5.error("Error fetching search tweets:", error);
+      logger6.error("Error fetching search tweets:", error);
       return { tweets: [] };
     }
   }
   async populateTimeline() {
-    logger5.debug("populating timeline...");
+    logger6.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 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);
+          logger6.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),
-            entityId,
-            content,
-            agentId: this.runtime.agentId,
-            roomId,
-            createdAt: tweet.timestamp * 1e3
-          });
+          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(
-          `Populated ${tweetsToSave2.length} missing tweets from the cache.`
-        );
+        logger6.log(`Populated ${tweetsToSave2.length} missing tweets from the cache.`);
         return;
       }
     }
@@ -8344,49 +7656,75 @@ 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 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({
+    logger6.debug({
       processingTweets: tweetsToSave.map((tweet) => tweet.id).join(",")
     });
     for (const tweet of tweetsToSave) {
-      logger5.log("Saving Tweet", tweet.id);
+      logger6.log("Saving Tweet", tweet.id);
       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),
-        entityId,
-        content,
-        agentId: this.runtime.agentId,
-        roomId,
-        createdAt: tweet.timestamp * 1e3
-      });
+      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);
@@ -8400,15 +7738,16 @@ 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
       });
       if (recentMessage.length > 0 && recentMessage[0].content === message.content) {
-        logger5.debug("Message already saved", recentMessage[0].id);
+        logger6.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,
@@ -8417,7 +7756,7 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
     }
   }
   async loadLatestCheckedTweetId() {
-    const latestCheckedTweetId = await this.runtime.getDatabaseAdapter().getCache(
+    const latestCheckedTweetId = await this.runtime.getCache(
       `twitter/${this.profile.username}/latest_checked_tweet_id`
     );
     if (latestCheckedTweetId) {
@@ -8426,34 +7765,36 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
   }
   async cacheLatestCheckedTweetId() {
     if (this.lastCheckedTweetId) {
-      await this.runtime.getDatabaseAdapter().setCache(
+      await this.runtime.setCache(
         `twitter/${this.profile.username}/latest_checked_tweet_id`,
         this.lastCheckedTweetId.toString()
       );
     }
   }
   async getCachedTimeline() {
-    const cached = await this.runtime.getDatabaseAdapter().getCache(`twitter/${this.profile.username}/timeline`);
+    const cached = await this.runtime.getCache(
+      `twitter/${this.profile.username}/timeline`
+    );
     if (!cached) {
       return void 0;
     }
     return cached;
   }
   async cacheTimeline(timeline) {
-    await this.runtime.getDatabaseAdapter().setCache(`twitter/${this.profile.username}/timeline`, timeline);
+    await this.runtime.setCache(`twitter/${this.profile.username}/timeline`, timeline);
   }
   async cacheMentions(mentions) {
-    await this.runtime.getDatabaseAdapter().setCache(`twitter/${this.profile.username}/mentions`, mentions);
+    await this.runtime.setCache(`twitter/${this.profile.username}/mentions`, mentions);
   }
   async getCachedCookies(username) {
-    const cached = await this.runtime.getDatabaseAdapter().getCache(`twitter/${username}/cookies`);
+    const cached = await this.runtime.getCache(`twitter/${username}/cookies`);
     if (!cached) {
       return void 0;
     }
     return cached;
   }
   async cacheCookies(username, cookies) {
-    await this.runtime.getDatabaseAdapter().setCache(`twitter/${username}/cookies`, cookies);
+    await this.runtime.setCache(`twitter/${username}/cookies`, cookies);
   }
   async fetchProfile(username) {
     try {
@@ -8473,66 +7814,73 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
       throw error;
     }
   }
+  /**
+   * Fetches recent interactions (likes, retweets, quotes) for the authenticated user's tweets
+   */
+  async fetchInteractions() {
+    try {
+      const username = this.profile.username;
+      const mentionsResponse = await this.requestQueue.add(
+        () => this.twitterClient.fetchSearchTweets(`@${username}`, 100, 1 /* Latest */)
+      );
+      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) {
+      logger6.error("Error fetching Twitter interactions:", error);
+      return [];
+    }
+  }
 };
+_ClientBase._twitterClients = {};
+var ClientBase = _ClientBase;
 
 // src/constants.ts
 var TWITTER_SERVICE_NAME = "twitter";
 
 // src/interactions.ts
 import {
-  ChannelType as ChannelType4,
-  ModelTypes as ModelTypes4,
+  ChannelType as ChannelType5,
+  EventType as EventType2,
+  ModelType as ModelType4,
   composePrompt as composePrompt2,
-  createUniqueUuid as createUniqueUuid4,
-  logger as logger6,
-  parseJSONObjectFromText
+  createUniqueUuid as createUniqueUuid5,
+  logger as logger7
 } from "@elizaos/core";
-var twitterMessageHandlerTemplate = `# Task: Generate dialog and actions for {{agentName}}.
-{{providers}}
-Here is the current post text again. Remember to include an action if the current post text includes a prompt that asks for one of the available actions mentioned above (does not need to be exact)
-{{currentPost}}
-{{imageDescriptions}}
-
-# Instructions: Write the next message for {{agentName}}. Include the appropriate action from the list: {{actionNames}}
-Response format should be formatted in a valid JSON block like this:
-\`\`\`json
-{ "thought": "<string>", "name": "{{agentName}}", "text": "<string>", "action": "<string>" }
-\`\`\`
 
-The "action" field should be one of the options in [Available Actions] and the "text" field should be the response you want to send. Do not including any thinking or internal reflection in the "text" field. "thought" should be a short description of what the agent is thinking about before responding, inlcuding a brief justification for the response.`;
-var twitterShouldRespondTemplate = `# INSTRUCTIONS: Determine if {{agentName}} (@{{twitterUserName}}) should respond to the message and participate in the conversation. Do not comment. Just respond with "true" or "false".
-
-Response options are RESPOND, IGNORE and STOP.
-
-For other users:
-- {{agentName}} should RESPOND to messages directed at them
-- {{agentName}} should RESPOND to conversations relevant to their background
-- {{agentName}} should IGNORE irrelevant messages
-- {{agentName}} should IGNORE very short messages unless directly addressed
-- {{agentName}} should STOP if asked to stop
-- {{agentName}} should STOP if conversation is concluded
-- {{agentName}} is in a room with other users and wants to be conversational, but not annoying.
-
-IMPORTANT:
-- {{agentName}} (aka @{{twitterUserName}}) is particularly sensitive about being annoying, so if there is any doubt, it is better to IGNORE than to RESPOND.
-- For users not in the priority list, {{agentName}} (@{{twitterUserName}}) should err on the side of IGNORE rather than RESPOND if in doubt.
-
-Recent Posts:
-{{recentPosts}}
-
-Current Post:
-{{currentPost}}
-
-Thread of Tweets You Are Replying To:
-{{formattedConversation}}
+// src/types.ts
+var ServiceType2 = {
+  TWITTER: "twitter"
+};
 
-# INSTRUCTIONS: Respond with RESPOND if {{agentName}} should respond, or IGNORE if {{agentName}} should not respond to the last message and STOP if {{agentName}} should stop participating in the conversation.
-The available options are RESPOND, IGNORE, or STOP. Choose the most appropriate option.`;
+// src/interactions.ts
+var convertToCoreTweet = (tweet) => ({
+  id: tweet.id,
+  text: tweet.text,
+  conversationId: tweet.conversationId,
+  timestamp: tweet.timestamp,
+  userId: tweet.userId,
+  username: tweet.username,
+  name: tweet.name,
+  inReplyToStatusId: tweet.inReplyToStatusId,
+  permanentUrl: tweet.permanentUrl,
+  photos: tweet.photos,
+  hashtags: tweet.hashtags,
+  mentions: tweet.mentions.map((mention) => mention.username),
+  urls: tweet.urls,
+  videos: tweet.videos,
+  thread: tweet.thread
+});
+var convertToCoreTweets = (tweets) => tweets.map(convertToCoreTweet);
 var TwitterInteractionClient = class {
-  client;
-  runtime;
-  isDryRun;
-  state;
   /**
    * Constructor for setting up a new instance with the provided client, runtime, and state.
    * @param {ClientBase} client - The client being used for communication.
@@ -8551,9 +7899,7 @@ var TwitterInteractionClient = class {
    */
   async start() {
     const handleTwitterInteractionsLoop = () => {
-      const interactionInterval = (this.state?.TWITTER_POLL_INTERVAL || this.runtime.getSetting(
-        "TWITTER_POLL_INTERVAL"
-      ) || 120) * 1e3;
+      const interactionInterval = (this.state?.TWITTER_POLL_INTERVAL || this.runtime.getSetting("TWITTER_POLL_INTERVAL") || 120) * 1e3;
       this.handleTwitterInteractions();
       setTimeout(handleTwitterInteractionsLoop, interactionInterval);
     };
@@ -8563,66 +7909,260 @@ var TwitterInteractionClient = class {
    * Asynchronously handles Twitter interactions by checking for mentions, processing tweets, and updating the last checked tweet ID.
    */
   async handleTwitterInteractions() {
-    logger6.log("Checking Twitter interactions");
+    logger7.log("Checking Twitter interactions");
     const twitterUsername = this.client.profile?.username;
     try {
-      const mentionCandidates = (await this.client.fetchSearchTweets(
-        `@${twitterUsername}`,
-        20,
-        1 /* Latest */
-      )).tweets;
-      logger6.log(
-        "Completed checking mentioned tweets:",
-        mentionCandidates.length
-      );
+      const mentionCandidates = (await this.client.fetchSearchTweets(`@${twitterUsername}`, 20, 1 /* Latest */)).tweets;
+      logger7.log("Completed checking mentioned tweets:", mentionCandidates.length);
       let uniqueTweetCandidates = [...mentionCandidates];
       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`);
+            logger7.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(
+          logger7.log("New Tweet found", tweet.permanentUrl);
+          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: {
+                ...memory,
+                source: "twitter"
+              },
+              source: "twitter",
+              callback: async (response) => {
+                logger7.info("Received message response:", response);
+                return [];
+              }
+            };
+            this.runtime.emitEvent(EventType2.MESSAGE_RECEIVED, messagePayload);
+            const mentionPayload = {
+              runtime: this.runtime,
+              message: {
+                ...memory,
+                source: "twitter"
+              },
+              tweet: convertToCoreTweet(tweet),
+              user: {
+                id: tweet.userId,
+                username: tweet.username,
+                name: tweet.name
+              },
+              source: "twitter",
+              callback: async (response) => {
+                logger7.info("Received mention response:", response);
+                return [];
+              }
+            };
+            this.runtime.emitEvent("TWITTER_MENTION_RECEIVED" /* MENTION_RECEIVED */, mentionPayload);
+          }
+          if (tweet.thread.length > 1) {
+            const threadPayload = {
+              runtime: this.runtime,
+              tweets: convertToCoreTweets(tweet.thread),
+              user: {
+                id: tweet.userId,
+                username: tweet.username,
+                name: tweet.name
+              },
+              source: "twitter"
+            };
+            if (tweet.thread[tweet.thread.length - 1].id === tweet.id) {
+              this.runtime.emitEvent("TWITTER_THREAD_UPDATED" /* THREAD_UPDATED */, {
+                ...threadPayload,
+                newTweet: convertToCoreTweet(tweet)
+              });
+            } 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);
         }
       }
+      const interactions = await this.client.fetchInteractions();
+      const handleInteraction = async (interaction) => {
+        if (interaction?.targetTweet?.conversationId) {
+          const memory = this.createMemoryObject(
+            interaction.type,
+            `${interaction.id}-${interaction.type}`,
+            interaction.userId,
+            interaction.targetTweet.conversationId
+          );
+          await this.runtime.createMemory(memory, "messages");
+          const reactionMessage = {
+            id: createUniqueUuid5(this.runtime, interaction.targetTweetId),
+            content: {
+              text: interaction.targetTweet.text,
+              source: "twitter"
+            },
+            entityId: createUniqueUuid5(this.runtime, interaction.targetTweet.userId),
+            roomId: createUniqueUuid5(this.runtime, interaction.targetTweet.conversationId),
+            agentId: this.runtime.agentId
+          };
+          const basePayload = {
+            runtime: this.runtime,
+            user: {
+              id: interaction.userId,
+              username: interaction.username,
+              name: interaction.name
+            },
+            source: "twitter"
+          };
+          switch (interaction.type) {
+            case "like": {
+              const likePayload = {
+                ...basePayload,
+                tweet: interaction.targetTweet
+              };
+              this.runtime.emitEvent("TWITTER_LIKE_RECEIVED" /* LIKE_RECEIVED */, likePayload);
+              this.runtime.emitEvent(EventType2.REACTION_RECEIVED, {
+                ...basePayload,
+                reaction: {
+                  type: "like",
+                  entityId: createUniqueUuid5(this.runtime, interaction.userId)
+                },
+                message: reactionMessage,
+                callback: async () => {
+                  return [];
+                }
+              });
+              break;
+            }
+            case "retweet": {
+              const retweetPayload = {
+                ...basePayload,
+                tweet: interaction.targetTweet,
+                retweetId: interaction.retweetId
+              };
+              this.runtime.emitEvent("TWITTER_RETWEET_RECEIVED" /* RETWEET_RECEIVED */, retweetPayload);
+              this.runtime.emitEvent(EventType2.REACTION_RECEIVED, {
+                ...basePayload,
+                reaction: {
+                  type: "retweet",
+                  entityId: createUniqueUuid5(this.runtime, interaction.userId)
+                },
+                message: reactionMessage,
+                callback: async () => {
+                  return [];
+                }
+              });
+              break;
+            }
+            case "quote": {
+              const quotePayload = {
+                ...basePayload,
+                message: reactionMessage,
+                quotedTweet: interaction.targetTweet,
+                quoteTweet: interaction.quoteTweet || interaction.targetTweet,
+                callback: async () => [],
+                reaction: {
+                  type: "quote",
+                  entityId: createUniqueUuid5(this.runtime, interaction.userId)
+                }
+              };
+              this.runtime.emitEvent("TWITTER_QUOTE_RECEIVED" /* QUOTE_RECEIVED */, quotePayload);
+              this.runtime.emitEvent(EventType2.REACTION_RECEIVED, {
+                ...basePayload,
+                reaction: {
+                  type: "quote",
+                  entityId: createUniqueUuid5(this.runtime, interaction.userId)
+                },
+                message: reactionMessage,
+                callback: async () => {
+                  return [];
+                }
+              });
+              break;
+            }
+          }
+        }
+      };
+      const processInteractions = async (interactions2) => {
+        for (const interaction of interactions2) {
+          if (interaction?.targetTweet?.conversationId) {
+            await handleInteraction(interaction);
+          }
+        }
+      };
+      const processFollowerChange = async (change, profileId) => {
+        if (change?.type && change?.userId && profileId) {
+          const followerMemory = this.createMemoryObject(
+            change.type,
+            `${change.type}-${change.userId}`,
+            change.userId,
+            profileId
+          );
+          await this.runtime.createMemory(followerMemory, "follower-changes");
+        }
+      };
       await this.client.cacheLatestCheckedTweetId();
-      logger6.log("Finished checking Twitter interactions");
+      logger7.log("Finished checking Twitter interactions");
     } catch (error) {
-      logger6.error("Error handling Twitter interactions:", error);
+      logger7.error("Error handling Twitter interactions:", error);
     }
   }
   /**
@@ -8643,10 +8183,10 @@ var TwitterInteractionClient = class {
     thread
   }) {
     if (!message.content.text) {
-      logger6.log("Skipping Tweet with no text", tweet.id);
+      logger7.log("Skipping Tweet with no text", tweet.id);
       return { text: "", actions: ["IGNORE"] };
     }
-    logger6.log("Processing Tweet: ", tweet.id);
+    logger7.log("Processing Tweet: ", tweet.id);
     const formatTweet = (tweet2) => {
       return `  ID: ${tweet2.id}
   From: ${tweet2.name} (@${tweet2.username})
@@ -8654,9 +8194,7 @@ var TwitterInteractionClient = class {
     };
     const currentPost = formatTweet(tweet);
     const formattedConversation = thread.map(
-      (tweet2) => `@${tweet2.username} (${new Date(
-        tweet2.timestamp * 1e3
-      ).toLocaleString("en-US", {
+      (tweet2) => `@${tweet2.username} (${new Date(tweet2.timestamp * 1e3).toLocaleString("en-US", {
         hour: "2-digit",
         minute: "2-digit",
         month: "short",
@@ -8667,148 +8205,117 @@ var TwitterInteractionClient = class {
     const imageDescriptionsArray = [];
     try {
       for (const photo of tweet.photos) {
-        const description = await this.runtime.useModel(
-          ModelTypes4.IMAGE_DESCRIPTION,
-          photo.url
-        );
+        const description = await this.runtime.useModel(ModelType4.IMAGE_DESCRIPTION, photo.url);
         imageDescriptionsArray.push(description);
       }
     } catch (error) {
-      logger6.error("Error Occured during describing image: ", error);
+      logger7.error("Error Occured during describing image: ", error);
     }
-    let state = await this.runtime.composeState(message);
+    const state = await this.runtime.composeState(message);
     state.values = {
       ...state.values,
       twitterUserName: this.state?.TWITTER_USERNAME || this.runtime.getSetting("TWITTER_USERNAME"),
       currentPost,
-      // TODO: move to recentMessages provider
       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);
+      logger7.log("tweet does not exist, saving");
+      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
       });
-      const message2 = {
+      await this.runtime.ensureRoomExists({
+        id: roomId,
+        name: `Conversation with ${tweet.name}`,
+        source: "twitter",
+        type: ChannelType5.GROUP,
+        channelId: tweet.conversationId,
+        worldId: createUniqueUuid5(this.runtime, tweet.userId)
+      });
+      const memory = {
         id: tweetId,
         agentId: this.runtime.agentId,
         content: {
           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: ChannelType5.GROUP
         },
         entityId,
         roomId,
         createdAt: tweet.timestamp * 1e3
       };
-      this.client.saveRequestMessage(message2, state);
+      this.client.saveRequestMessage(memory, state);
     }
     const shouldRespondPrompt = composePrompt2({
       state,
-      template: this.runtime.character.templates?.twitterShouldRespondTemplate || this.runtime.character?.templates?.shouldRespondTemplate || twitterShouldRespondTemplate
+      template: this.runtime.character.templates?.shouldRespondTemplate || ""
     });
-    const shouldRespond = await this.runtime.useModel(ModelTypes4.TEXT_SMALL, {
+    const response = await this.runtime.useModel(ModelType4.TEXT_SMALL, {
       prompt: shouldRespondPrompt
     });
-    if (!shouldRespond.includes("RESPOND")) {
-      logger6.log("Not responding to message");
-      return { text: "Response Decision:", action: shouldRespond };
+    const responseActions = (response.match(/(?:RESPOND|IGNORE|STOP)/g) || ["IGNORE"])[0];
+    if (responseActions !== "RESPOND") {
+      logger7.log(`Not responding to tweet based on shouldRespond decision: ${responseActions}`);
+      return { text: "", actions: [responseActions] };
     }
-    const prompt = composePrompt2({
-      state: {
-        ...state,
-        values: {
-          ...state.values,
-          // Convert actionNames array to string
-          actionNames: Array.isArray(state.actionNames) ? state.actionNames.join(", ") : state.actionNames || "",
-          actions: Array.isArray(state.actions) ? state.actions.join("\n") : state.actions || "",
-          // Ensure character examples are included
-          characterPostExamples: this.runtime.character.messageExamples ? this.runtime.character.messageExamples.map(
-            (example) => example.map(
-              (msg) => `${msg.name}: ${msg.content.text}${msg.content.actions ? ` (Actions: ${msg.content.actions.join(", ")})` : ""}`
-            ).join("\n")
-          ).join("\n\n") : ""
+    const callback = async (response2, tweetId2) => {
+      try {
+        const tweetToReplyTo = tweetId2 || tweet.id;
+        if (this.isDryRun) {
+          logger7.info(`[DRY RUN] Would have replied to ${tweet.username} with: ${response2.text}`);
+          return [];
         }
-      },
-      template: this.runtime.character.templates?.twitterMessageHandlerTemplate || this.runtime.character?.templates?.messageHandlerTemplate || twitterMessageHandlerTemplate
-    });
-    const responseText = await this.runtime.useModel(ModelTypes4.TEXT_LARGE, {
-      prompt
-    });
-    const response = parseJSONObjectFromText(responseText);
-    const removeQuotes = (str) => str.replace(/^['"](.*)['"]$/, "$1");
-    const replyToId = createUniqueUuid4(this.runtime, tweet.id);
-    response.inReplyTo = replyToId;
-    response.text = removeQuotes(response.text);
-    if (response.text) {
-      if (this.isDryRun) {
-        logger6.info(
-          `Dry run: Selected Post: ${tweet.id} - ${tweet.username}: ${tweet.text}
-Agent's Output:
-${response.text}`
+        logger7.info(`Replying to tweet ${tweetToReplyTo}`);
+        const replyTweetResult = await this.client.requestQueue.add(
+          () => this.client.twitterClient.post("statuses/update", {
+            status: response2.text.substring(0, 280),
+            in_reply_to_status_id: tweetToReplyTo,
+            auto_populate_reply_metadata: true
+          })
         );
-      } else {
-        try {
-          const callback = async (response2, tweetId2) => {
-            const memories = await sendTweet(
-              this.client,
-              response2,
-              message.roomId,
-              this.state?.TWITTER_USERNAME || this.runtime.getSetting("TWITTER_USERNAME"),
-              tweetId2 || tweet.id
-            );
-            return memories;
-          };
-          const responseMessages = [
-            {
-              id: createUniqueUuid4(this.runtime, tweet.id),
-              entityId: this.runtime.agentId,
-              agentId: this.runtime.agentId,
-              content: response,
-              roomId: message.roomId,
-              createdAt: Date.now()
-            }
-          ];
-          state = await this.runtime.composeState(message, ["RECENT_MESSAGES"]);
-          for (const responseMessage of responseMessages) {
-            await this.runtime.getMemoryManager("messages").createMemory(responseMessage);
-          }
-          const responseTweetId = responseMessages[responseMessages.length - 1]?.content?.tweetId;
-          await this.runtime.processActions(
-            message,
-            responseMessages,
-            state,
-            (response2) => {
-              return callback(response2, responseTweetId);
-            }
-          );
-          const responseInfo = `Context:
-
-${prompt}
-
-Selected Post: ${tweet.id} - ${tweet.username}: ${tweet.text}
-Agent's Output:
-${response.text}`;
-          await this.runtime.getDatabaseAdapter().setCache(
-            `twitter/tweet_generation_${tweet.id}.txt`,
-            responseInfo
-          );
-          await wait();
-        } catch (error) {
-          logger6.error(`Error sending response tweet: ${error}`);
+        if (!replyTweetResult) {
+          throw new Error("Failed to create tweet response");
         }
+        const responseId = createUniqueUuid5(
+          this.runtime,
+          replyTweetResult.id_str || replyTweetResult.rest_id || replyTweetResult.legacy.id_str || replyTweetResult.id
+        );
+        const responseMemory = {
+          id: responseId,
+          entityId: this.runtime.agentId,
+          agentId: this.runtime.agentId,
+          roomId: message.roomId,
+          content: {
+            ...response2,
+            inReplyTo: message.id
+          },
+          createdAt: Date.now()
+        };
+        await this.runtime.createMemory(responseMemory, "messages");
+        return [responseMemory];
+      } catch (error) {
+        logger7.error("Error replying to tweet:", error);
+        return [];
       }
-    }
+    };
+    this.runtime.emitEvent(EventType2.MESSAGE_RECEIVED, {
+      runtime: this.runtime,
+      message,
+      callback,
+      source: "twitter"
+    });
+    return { text: "", actions: ["RESPOND"] };
   }
   /**
    * Build a conversation thread based on a given tweet.
@@ -8821,112 +8328,107 @@ ${response.text}`;
     const thread = [];
     const visited = /* @__PURE__ */ new Set();
     async function processThread(currentTweet, depth = 0) {
-      logger6.log("Processing tweet:", {
+      logger7.log("Processing tweet:", {
         id: currentTweet.id,
         inReplyToStatusId: currentTweet.inReplyToStatusId,
         depth
       });
       if (!currentTweet) {
-        logger6.log("No current tweet found for thread building");
+        logger7.log("No current tweet found for thread building");
         return;
       }
       if (depth >= maxReplies) {
-        logger6.log("Reached maximum reply depth", depth);
+        logger7.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),
-          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
+        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 ? createUniqueUuid5(this.runtime, currentTweet.inReplyToStatusId) : void 0
+            },
+            createdAt: currentTweet.timestamp * 1e3,
+            roomId,
+            entityId: currentTweet.userId === this.twitterUserId ? this.runtime.agentId : createUniqueUuid5(this.runtime, currentTweet.userId)
           },
-          createdAt: currentTweet.timestamp * 1e3,
-          roomId,
-          entityId: currentTweet.userId === this.twitterUserId ? this.runtime.agentId : createUniqueUuid4(this.runtime, currentTweet.userId)
-        });
+          "messages"
+        );
       }
       if (visited.has(currentTweet.id)) {
-        logger6.log("Already visited tweet:", currentTweet.id);
+        logger7.log("Already visited tweet:", currentTweet.id);
         return;
       }
       visited.add(currentTweet.id);
       thread.unshift(currentTweet);
       if (currentTweet.inReplyToStatusId) {
-        logger6.log("Fetching parent tweet:", currentTweet.inReplyToStatusId);
+        logger7.log("Fetching parent tweet:", currentTweet.inReplyToStatusId);
         try {
-          const parentTweet = await this.twitterClient.getTweet(
-            currentTweet.inReplyToStatusId
-          );
+          const parentTweet = await this.twitterClient.getTweet(currentTweet.inReplyToStatusId);
           if (parentTweet) {
-            logger6.log("Found parent tweet:", {
+            logger7.log("Found parent tweet:", {
               id: parentTweet.id,
               text: parentTweet.text?.slice(0, 50)
             });
             await processThread(parentTweet, depth + 1);
           } else {
-            logger6.log(
-              "No parent tweet found for:",
-              currentTweet.inReplyToStatusId
-            );
+            logger7.log("No parent tweet found for:", currentTweet.inReplyToStatusId);
           }
         } catch (error) {
-          logger6.log("Error fetching parent tweet:", {
+          logger7.log("Error fetching parent tweet:", {
             tweetId: currentTweet.inReplyToStatusId,
             error
           });
         }
       } else {
-        logger6.log("Reached end of reply chain at:", currentTweet.id);
+        logger7.log("Reached end of reply chain at:", currentTweet.id);
       }
     }
     await processThread.bind(this)(tweet, 0);
     return thread;
   }
+  createMemoryObject(type, id, userId, roomId) {
+    return {
+      id: createUniqueUuid5(this.runtime, id),
+      agentId: this.runtime.agentId,
+      entityId: createUniqueUuid5(this.runtime, userId),
+      roomId: createUniqueUuid5(this.runtime, roomId),
+      content: {
+        type,
+        source: "twitter"
+      },
+      createdAt: Date.now()
+    };
+  }
 };
 
 // src/post.ts
 import {
-  ChannelType as ChannelType5,
-  ModelTypes as ModelTypes5,
-  cleanJsonResponse,
-  composePrompt as composePrompt3,
-  createUniqueUuid as createUniqueUuid5,
-  extractAttributes,
-  logger as logger7,
-  parseJSONObjectFromText as parseJSONObjectFromText2,
+  ChannelType as ChannelType6,
+  EventType as EventType3,
+  createUniqueUuid as createUniqueUuid6,
+  logger as logger8,
   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 {
-  client;
-  runtime;
-  twitterUsername;
-  isDryRun;
-  state;
   /**
    * Constructor for initializing a new Twitter client with the provided client, runtime, and state
    * @param {ClientBase} client - The client used for interacting with Twitter API
@@ -8939,62 +8441,41 @@ var TwitterPostClient = class {
     this.runtime = runtime;
     this.twitterUsername = state?.TWITTER_USERNAME || this.runtime.getSetting("TWITTER_USERNAME");
     this.isDryRun = this.state?.TWITTER_DRY_RUN || this.runtime.getSetting("TWITTER_DRY_RUN");
-    logger7.log("Twitter Client Configuration:");
-    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"}`
+    logger8.log("Twitter Client Configuration:");
+    logger8.log(`- Username: ${this.twitterUsername}`);
+    logger8.log(`- Dry Run Mode: ${this.isDryRun ? "Enabled" : "Disabled"}`);
+    logger8.log(
+      `- Auto-post: ${this.state?.TWITTER_ENABLE_POST_GENERATION || this.runtime.getSetting("TWITTER_ENABLE_POST_GENERATION") ? "disabled" : "enabled"}`
     );
-    logger7.log(
+    logger8.log(
       `- Post Interval: ${this.state?.TWITTER_POST_INTERVAL_MIN || this.runtime.getSetting("TWITTER_POST_INTERVAL_MIN")}-${this.state?.TWITTER_POST_INTERVAL_MAX || this.runtime.getSetting("TWITTER_POST_INTERVAL_MAX")} minutes`
     );
-    logger7.log(
+    logger8.log(
       `- Post Immediately: ${this.state?.TWITTER_POST_IMMEDIATELY || this.runtime.getSetting("TWITTER_POST_IMMEDIATELY") ? "enabled" : "disabled"}`
     );
     if (this.isDryRun) {
-      logger7.log(
-        "Twitter client initialized in dry run mode - no actual tweets should be posted"
-      );
+      logger8.log("Twitter client initialized in dry run mode - no actual tweets should be posted");
     }
   }
   /**
-   * Asynchronously starts the tweet generation loop.
-   * If the client's profile is not available, it initializes the client first.
-   * It generates a new tweet at random intervals specified by the TWITTER_POST_INTERVAL_MIN and TWITTER_POST_INTERVAL_MAX settings or state properties.
-   * Optionally, it can immediately generate a tweet if TWITTER_POST_IMMEDIATELY is set to true in the state or settings.
+   * Starts the Twitter post client, setting up a loop to periodically generate new tweets.
    */
   async start() {
-    if (!this.client.profile) {
-      await this.client.init();
+    logger8.log("Starting Twitter post client...");
+    const tweetGeneration = this.runtime.getSetting("TWITTER_ENABLE_TWEET_GENERATION");
+    if (tweetGeneration === false) {
+      logger8.log("Tweet generation is disabled");
+      return;
     }
     const generateNewTweetLoop = async () => {
-      let lastPost = await this.runtime.getDatabaseAdapter().getCache(`twitter/${this.twitterUsername}/lastPost`);
-      if (!lastPost) {
-        lastPost = JSON.stringify({
-          timestamp: 0
-        });
-      }
-      const lastPostTimestamp = lastPost.timestamp ?? 0;
-      const minMinutes = (this.state?.TWITTER_POST_INTERVAL_MIN || this.runtime.getSetting("TWITTER_POST_INTERVAL_MIN")) ?? 90;
-      const maxMinutes = (this.state?.TWITTER_POST_INTERVAL_MAX || this.runtime.getSetting("TWITTER_POST_INTERVAL_MAX")) ?? 180;
-      const randomMinutes = Math.floor(Math.random() * (maxMinutes - minMinutes + 1)) + minMinutes;
-      const delay = randomMinutes * 60 * 1e3;
-      if (Date.now() > lastPostTimestamp + delay) {
-        await this.generateNewTweet();
-      }
-      setTimeout(() => {
-        generateNewTweetLoop();
-      }, delay);
-      logger7.log(`Next tweet scheduled in ${randomMinutes} minutes`);
+      const interval = (this.state?.TWITTER_POST_INTERVAL || this.runtime.getSetting("TWITTER_POST_INTERVAL") || 30) * 60 * 1e3;
+      this.generateNewTweet();
+      setTimeout(generateNewTweetLoop, interval);
     };
-    if (this.state?.TWITTER_ENABLE_POST_GENERATION || this.runtime.getSetting("TWITTER_ENABLE_POST_GENERATION")) {
-      if (this.state?.TWITTER_POST_IMMEDIATELY || this.runtime.getSetting("TWITTER_POST_IMMEDIATELY")) {
-        setTimeout(() => {
-          this.generateNewTweet();
-        }, 5e3);
-      }
-      generateNewTweetLoop();
-      logger7.log("Tweet generation loop started");
+    setTimeout(generateNewTweetLoop, 60 * 1e3);
+    if (this.runtime.getSetting("TWITTER_POST_IMMEDIATELY")) {
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      this.generateNewTweet();
     }
   }
   /**
@@ -9035,32 +8516,35 @@ var TwitterPostClient = class {
    * @param {string} rawTweetContent - The raw content of the tweet.
    */
   async processAndCacheTweet(runtime, client, tweet, roomId, rawTweetContent) {
-    await runtime.getDatabaseAdapter().setCache(`twitter/${client.profile.username}/lastPost`, {
+    await runtime.setCache(`twitter/${client.profile.username}/lastPost`, {
       id: tweet.id,
       timestamp: Date.now()
     });
     await client.cacheTweet(tweet);
-    logger7.log(`Tweet posted:
+    logger8.log(`Tweet posted:
  ${tweet.permanentUrl}`);
     await runtime.ensureRoomExists({
       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),
-      entityId: runtime.agentId,
-      agentId: runtime.agentId,
-      content: {
-        text: rawTweetContent.trim(),
-        url: tweet.permanentUrl,
-        source: "twitter"
+    await runtime.createMemory(
+      {
+        id: createUniqueUuid6(this.runtime, tweet.id),
+        entityId: runtime.agentId,
+        agentId: runtime.agentId,
+        content: {
+          text: rawTweetContent.trim(),
+          url: tweet.permanentUrl,
+          source: "twitter"
+        },
+        roomId,
+        createdAt: tweet.timestamp
       },
-      roomId,
-      createdAt: tweet.timestamp
-    });
+      "messages"
+    );
   }
   /**
    * Handles sending a note tweet with optional media data.
@@ -9102,12 +8586,12 @@ var TwitterPostClient = class {
       );
       const body = await standardTweetResult.json();
       if (!body?.data?.create_tweet?.tweet_results?.result) {
-        logger7.error("Error sending tweet; Bad response:", body);
+        logger8.error("Error sending tweet; Bad response:", body);
         return;
       }
       return body.data.create_tweet.tweet_results.result;
     } catch (error) {
-      logger7.error("Error sending standard Tweet:", error);
+      logger8.error("Error sending standard Tweet:", error);
       throw error;
     }
   }
@@ -9125,124 +8609,110 @@ var TwitterPostClient = class {
    */
   async postTweet(runtime, client, tweetTextForPosting, roomId, rawTweetContent, twitterUsername, mediaData) {
     try {
-      logger7.log("Posting new tweet:\n");
+      logger8.log("Posting new tweet:\n");
       let result;
       if (tweetTextForPosting.length > 280 - 1) {
-        result = await this.handleNoteTweet(
-          client,
-          tweetTextForPosting,
-          void 0,
-          mediaData
-        );
+        result = await this.handleNoteTweet(client, tweetTextForPosting, void 0, mediaData);
       } else {
-        result = await this.sendStandardTweet(
-          client,
-          tweetTextForPosting,
-          void 0,
-          mediaData
-        );
+        result = await this.sendStandardTweet(client, tweetTextForPosting, void 0, mediaData);
       }
       const tweet = this.createTweetObject(result, client, twitterUsername);
-      await this.processAndCacheTweet(
-        runtime,
-        client,
-        tweet,
-        roomId,
-        rawTweetContent
-      );
+      await this.processAndCacheTweet(runtime, client, tweet, roomId, rawTweetContent);
     } catch (error) {
-      logger7.error("Error sending tweet:");
+      logger8.error("Error sending tweet:");
       throw error;
     }
   }
   /**
-   * Generates and posts a new tweet. If isDryRun is true, only logs what would have been posted.
-   */
-  /**
-   * Asynchronously generates a new tweet for the Twitter account associated with the agent.
-   * This method retrieves random topics of interest from the character's topics list and prompts the user to compose a tweet based on those topics.
-   * The tweet is then processed and posted on Twitter with optional media attachments.
-   * @returns {void}
+   * Handles the creation and posting of a tweet by emitting standardized events.
+   * This approach aligns with our platform-independent architecture.
    */
   async generateNewTweet() {
-    logger7.log("Generating new tweet");
     try {
-      const roomId = createUniqueUuid5(this.runtime, "twitter_generate");
-      const topics = this.runtime.character.topics.sort(() => 0.5 - Math.random()).slice(0, 10).join(", ");
-      const state = await this.runtime.composeState({
-        entityId: this.runtime.agentId,
-        roomId,
-        agentId: this.runtime.agentId,
-        content: {
-          text: topics || "",
-          actions: ["TWEET"]
+      const userId = this.client.profile?.id;
+      if (!userId) {
+        logger8.error("Cannot generate tweet: Twitter profile not available");
+        return;
+      }
+      const worldId = createUniqueUuid6(this.runtime, userId);
+      const roomId = createUniqueUuid6(this.runtime, `${userId}-home`);
+      const callback = async (content) => {
+        try {
+          if (this.isDryRun) {
+            logger8.info(`[DRY RUN] Would post tweet: ${content.text}`);
+            return [];
+          }
+          const result = await this.postToTwitter(content.text, content.mediaData);
+          const tweetId = result.rest_id || result.id_str || result.legacy?.id_str;
+          if (result) {
+            const postedTweetId = createUniqueUuid6(this.runtime, tweetId);
+            const postedMemory = {
+              id: postedTweetId,
+              entityId: this.runtime.agentId,
+              agentId: this.runtime.agentId,
+              roomId,
+              content: {
+                ...content,
+                source: "twitter",
+                channelType: ChannelType6.FEED,
+                type: "post",
+                metadata: {
+                  tweetId,
+                  postedAt: Date.now()
+                }
+              },
+              createdAt: Date.now()
+            };
+            await this.runtime.createMemory(postedMemory, "messages");
+            return [postedMemory];
+          }
+          return [];
+        } catch (error) {
+          logger8.error("Error posting tweet:", error);
+          return [];
         }
-      });
-      state.values = {
-        ...state.values,
-        twitterUserName: this.client.profile.username
       };
-      const prompt = composePrompt3({
-        state,
-        template: this.runtime.character.templates?.twitterPostTemplate || twitterPostTemplate
-      });
-      logger7.debug(`generate post prompt:
-${prompt}`);
-      const response = await this.runtime.useModel(ModelTypes5.TEXT_SMALL, {
-        prompt
+      this.runtime.emitEvent([EventType3.POST_GENERATED, "TWITTER_POST_GENERATED" /* POST_GENERATED */], {
+        runtime: this.runtime,
+        callback,
+        worldId,
+        userId,
+        roomId
       });
-      const rawTweetContent = cleanJsonResponse(response);
-      let tweetTextForPosting = null;
-      let mediaData = null;
-      const parsedResponse = parseJSONObjectFromText2(rawTweetContent);
-      if (parsedResponse?.text) {
-        tweetTextForPosting = parsedResponse.text;
-      } else {
-        tweetTextForPosting = rawTweetContent.trim();
-      }
-      if (parsedResponse?.attachments && parsedResponse?.attachments.length > 0) {
-        mediaData = await fetchMediaData(parsedResponse.attachments);
-      }
-      if (!tweetTextForPosting) {
-        const parsingText = extractAttributes(rawTweetContent, ["text"]).text;
-        if (parsingText) {
-          tweetTextForPosting = truncateToCompleteSentence(
-            extractAttributes(rawTweetContent, ["text"]).text,
-            280 - 1
-          );
+    } catch (error) {
+      logger8.error("Error generating tweet:", error);
+    }
+  }
+  /**
+   * Posts content to Twitter
+   * @param {string} text The tweet text to post
+   * @param {MediaData[]} mediaData Optional media to attach to the tweet
+   * @returns {Promise<any>} The result from the Twitter API
+   */
+  async postToTwitter(text, mediaData = []) {
+    try {
+      const mediaIds = [];
+      if (mediaData && mediaData.length > 0) {
+        for (const media of mediaData) {
+          try {
+            logger8.warn("Media upload not currently supported with the modern Twitter API");
+          } catch (error) {
+            logger8.error("Error uploading media:", error);
+          }
         }
       }
-      if (!tweetTextForPosting) {
-        tweetTextForPosting = rawTweetContent;
-      }
-      tweetTextForPosting = truncateToCompleteSentence(
-        tweetTextForPosting,
-        280 - 1
+      const result = await this.client.requestQueue.add(
+        () => this.client.twitterClient.sendTweet(text.substring(0, 280))
       );
-      const removeQuotes = (str) => str.replace(/^['"](.*)['"]$/, "$1");
-      const fixNewLines = (str) => str.replaceAll(/\\n/g, "\n\n");
-      tweetTextForPosting = removeQuotes(fixNewLines(tweetTextForPosting));
-      if (this.isDryRun) {
-        logger7.info(`Dry run: would have posted tweet: ${tweetTextForPosting}`);
-        return;
-      }
-      try {
-        logger7.log(`Posting new tweet:
- ${tweetTextForPosting}`);
-        this.postTweet(
-          this.runtime,
-          this.client,
-          tweetTextForPosting,
-          roomId,
-          rawTweetContent,
-          this.twitterUsername,
-          mediaData
-        );
-      } catch (error) {
-        logger7.error("Error sending tweet:", error);
+      const body = await result.json();
+      if (!body?.data?.create_tweet?.tweet_results?.result) {
+        logger8.error("Error sending tweet; Bad response:", body);
+        return null;
       }
+      return body.data.create_tweet.tweet_results.result;
     } catch (error) {
-      logger7.error("Error generating new tweet:", error);
+      logger8.error("Error posting to Twitter:", error);
+      throw error;
     }
   }
   async stop() {
@@ -9251,18 +8721,11 @@ ${prompt}`);
 
 // src/tests.ts
 import {
-  ModelTypes as ModelTypes6,
-  createUniqueUuid as createUniqueUuid6,
-  logger as logger8,
+  ModelType as ModelType6,
+  createUniqueUuid as createUniqueUuid7,
+  logger as logger9,
   stringToUuid as stringToUuid2
 } from "@elizaos/core";
-
-// src/types.ts
-var ServiceTypes2 = {
-  TWITTER: "twitter"
-};
-
-// src/tests.ts
 var TEST_IMAGE_URL = "https://github.com/elizaOS/awesome-eliza/blob/main/assets/eliza-logo.jpg?raw=true";
 var TEST_IMAGE = {
   id: "mock-image-id",
@@ -9275,14 +8738,13 @@ var TEST_IMAGE = {
   alt_text: "mock image"
 };
 var TwitterTestSuite = class {
-  name = "twitter";
-  twitterClient = null;
-  tests;
   /**
    * Constructor for TestSuite class.
    * Initializes an array of test functions to be executed.
    */
   constructor() {
+    this.name = "twitter";
+    this.twitterClient = null;
     this.tests = [
       {
         name: "Initialize Twitter Client",
@@ -9315,16 +8777,14 @@ 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");
       }
       const clientId = stringToUuid2("default");
-      this.twitterClient = manager.clients.get(
-        manager.getClientKey(clientId, runtime.agentId)
-      );
+      this.twitterClient = manager.clients.get(manager.getClientKey(clientId, runtime.agentId));
       if (this.twitterClient) {
-        logger8.success("TwitterClient initialized successfully.");
+        logger9.debug("TwitterClient initialized successfully.");
       } else {
         throw new Error("TwitterClient failed to initialize.");
       }
@@ -9345,7 +8805,7 @@ var TwitterTestSuite = class {
       if (!profile || !profile.id) {
         throw new Error("Profile fetch failed.");
       }
-      logger8.log("Successfully fetched Twitter profile:", profile);
+      logger9.log("Successfully fetched Twitter profile:", profile);
     } catch (error) {
       throw new Error(`Error fetching Twitter profile: ${error}`);
     }
@@ -9364,9 +8824,7 @@ var TwitterTestSuite = class {
         5,
         1 /* Latest */
       );
-      console.log(
-        `Successfully fetched ${tweets.tweets.length} search tweets.`
-      );
+      logger9.debug(`Successfully fetched ${tweets.tweets.length} search tweets.`);
     } catch (error) {
       throw new Error(`Error fetching search tweets: ${error}`);
     }
@@ -9384,9 +8842,7 @@ var TwitterTestSuite = class {
       if (!timeline || timeline.length === 0) {
         throw new Error("No tweets in home timeline.");
       }
-      logger8.log(
-        `Successfully fetched ${timeline.length} tweets from home timeline.`
-      );
+      logger9.log(`Successfully fetched ${timeline.length} tweets from home timeline.`);
     } catch (error) {
       throw new Error(`Error fetching home timeline: ${error}`);
     }
@@ -9403,7 +8859,7 @@ var TwitterTestSuite = class {
       if (!posts || posts.length === 0) {
         throw new Error("No own posts found.");
       }
-      logger8.log(`Successfully fetched ${posts.length} own posts.`);
+      logger9.log(`Successfully fetched ${posts.length} own posts.`);
     } catch (error) {
       throw new Error(`Error fetching own posts: ${error}`);
     }
@@ -9417,7 +8873,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(
@@ -9428,7 +8884,7 @@ var TwitterTestSuite = class {
         tweetText,
         "test-username"
       );
-      logger8.success("Successfully posted a test tweet.");
+      logger9.success("Successfully posted a test tweet.");
     } catch (error) {
       throw new Error(`Error posting a tweet: ${error}`);
     }
@@ -9442,12 +8898,9 @@ 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,
-        "image_post"
-      );
+      const tweetText = await this.generateRandomTweetContent(runtime, "image_post");
       const mediaData = await fetchMediaData([TEST_IMAGE]);
       await postClient.postTweet(
         runtime,
@@ -9458,7 +8911,7 @@ var TwitterTestSuite = class {
         "test-username",
         mediaData
       );
-      logger8.success("Successfully posted a test tweet.");
+      logger9.success("Successfully posted a test tweet.");
     } catch (error) {
       throw new Error(`Error posting a tweet: ${error}`);
     }
@@ -9474,7 +8927,7 @@ var TwitterTestSuite = class {
     try {
       const postClient = this.twitterClient.post;
       await postClient.generateNewTweet();
-      logger8.success("Successfully generated a new tweet.");
+      logger9.success("Successfully generated a new tweet.");
     } catch (error) {
       throw new Error(`Error generating new tweet: ${error}`);
     }
@@ -9508,12 +8961,12 @@ 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: []
       });
-      logger8.success("Correct response decision.");
+      logger9.success("Correct response decision.");
     } catch (error) {
       throw new Error(`Error handling tweet response: ${error}`);
     }
@@ -9545,7 +8998,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
     });
   }
@@ -9553,30 +9006,22 @@ var TwitterTestSuite = class {
 
 // src/index.ts
 var TwitterClientInstance = class {
-  client;
-  post;
-  interaction;
-  space;
-  service;
   constructor(runtime, state) {
     this.client = new ClientBase(runtime, state);
     this.post = new TwitterPostClient(this.client, runtime, state);
-    this.interaction = new TwitterInteractionClient(
-      this.client,
-      runtime,
-      state
-    );
+    this.interaction = new TwitterInteractionClient(this.client, runtime, state);
     if (runtime.getSetting("TWITTER_SPACES_ENABLE") === true) {
       this.space = new TwitterSpaceClient(this.client, runtime);
     }
     this.service = TwitterService.getInstance();
   }
 };
-var TwitterService = class _TwitterService extends Service {
-  static serviceType = TWITTER_SERVICE_NAME;
-  capabilityDescription = "The agent is able to send and receive messages on twitter";
-  static instance;
-  clients = /* @__PURE__ */ new Map();
+var _TwitterService = class _TwitterService extends Service {
+  constructor() {
+    super(...arguments);
+    this.capabilityDescription = "The agent is able to send and receive messages on twitter";
+    this.clients = /* @__PURE__ */ new Map();
+  }
   static getInstance() {
     if (!_TwitterService.instance) {
       _TwitterService.instance = new _TwitterService();
@@ -9584,14 +9029,13 @@ var TwitterService = class _TwitterService extends Service {
     return _TwitterService.instance;
   }
   async createClient(runtime, clientId, state) {
-    console.log("Creating client", clientId);
     if (runtime.getSetting("TWITTER_2FA_SECRET") === null) {
       runtime.setSetting("TWITTER_2FA_SECRET", void 0, false);
     }
     try {
       const existingClient = this.getClient(clientId, runtime.agentId);
       if (existingClient) {
-        logger9.info(`Twitter client already exists for ${clientId}`);
+        logger10.info(`Twitter client already exists for ${clientId}`);
         return existingClient;
       }
       const client = new TwitterClientInstance(runtime, state);
@@ -9606,13 +9050,91 @@ var TwitterService = class _TwitterService extends Service {
         client.interaction.start();
       }
       this.clients.set(this.getClientKey(clientId, runtime.agentId), client);
-      logger9.info(`Created Twitter client for ${clientId}`);
+      await this.emitServerJoinedEvent(runtime, client);
+      logger10.info(`Created Twitter client for ${clientId}`);
       return client;
     } catch (error) {
-      logger9.error(`Failed to create Twitter client for ${clientId}:`, error);
+      logger10.error(`Failed to create Twitter client for ${clientId}:`, error);
       throw error;
     }
   }
+  /**
+   * Emits a standardized WORLD_JOINED event for Twitter
+   * @param runtime The agent runtime
+   * @param client The Twitter client instance
+   */
+  async emitServerJoinedEvent(runtime, client) {
+    try {
+      if (!client.client.profile) {
+        logger10.warn("Twitter profile not available yet, can't emit WORLD_JOINED event");
+        return;
+      }
+      const profile = client.client.profile;
+      const twitterId = profile.id;
+      const username = profile.username;
+      const worldId = createUniqueUuid8(runtime, twitterId);
+      const world = {
+        id: worldId,
+        name: `${username}'s Twitter`,
+        agentId: runtime.agentId,
+        serverId: twitterId,
+        metadata: {
+          ownership: { ownerId: twitterId },
+          roles: {
+            [twitterId]: Role.OWNER
+          },
+          twitter: {
+            username,
+            id: twitterId
+          }
+        }
+      };
+      const homeTimelineRoomId = createUniqueUuid8(runtime, `${twitterId}-home`);
+      const homeTimelineRoom = {
+        id: homeTimelineRoomId,
+        name: `${username}'s Timeline`,
+        source: "twitter",
+        type: ChannelType7.FEED,
+        channelId: `${twitterId}-home`,
+        serverId: twitterId,
+        worldId
+      };
+      const mentionsRoomId = createUniqueUuid8(runtime, `${twitterId}-mentions`);
+      const mentionsRoom = {
+        id: mentionsRoomId,
+        name: `${username}'s Mentions`,
+        source: "twitter",
+        type: ChannelType7.GROUP,
+        channelId: `${twitterId}-mentions`,
+        serverId: twitterId,
+        worldId
+      };
+      const twitterUserId = createUniqueUuid8(runtime, twitterId);
+      const twitterUser = {
+        id: twitterUserId,
+        names: [profile.screenName || username],
+        agentId: runtime.agentId,
+        metadata: {
+          twitter: {
+            id: twitterId,
+            username,
+            screenName: profile.screenName || username,
+            name: profile.screenName || username
+          }
+        }
+      };
+      runtime.emitEvent(["TWITTER_WORLD_JOINED" /* WORLD_JOINED */, EventType4.WORLD_JOINED], {
+        runtime,
+        world,
+        rooms: [homeTimelineRoom, mentionsRoom],
+        users: [twitterUser],
+        source: "twitter"
+      });
+      logger10.info(`Emitted WORLD_JOINED event for Twitter account ${username}`);
+    } catch (error) {
+      logger10.error("Failed to emit WORLD_JOINED event for Twitter:", error);
+    }
+  }
   getClient(clientId, agentId) {
     return this.clients.get(this.getClientKey(clientId, agentId));
   }
@@ -9623,9 +9145,9 @@ var TwitterService = class _TwitterService extends Service {
       try {
         await client.service.stop();
         this.clients.delete(key);
-        logger9.info(`Stopped Twitter client for ${clientId}`);
+        logger10.info(`Stopped Twitter client for ${clientId}`);
       } catch (error) {
-        logger9.error(`Error stopping Twitter client for ${clientId}:`, error);
+        logger10.error(`Error stopping Twitter client for ${clientId}:`, error);
       }
     }
   }
@@ -9643,15 +9165,11 @@ var TwitterService = class _TwitterService extends Service {
     try {
       if (config.TWITTER_USERNAME && // Basic auth
       config.TWITTER_PASSWORD && config.TWITTER_EMAIL) {
-        logger9.info("Creating default Twitter client from character settings");
-        await twitterClientManager.createClient(
-          runtime,
-          runtime.agentId,
-          config
-        );
+        logger10.info("Creating default Twitter client from character settings");
+        await twitterClientManager.createClient(runtime, runtime.agentId, config);
       }
     } catch (error) {
-      logger9.error("Failed to create default Twitter client:", error);
+      logger10.error("Failed to create default Twitter client:", error);
     }
     return twitterClientManager;
   }
@@ -9664,7 +9182,7 @@ var TwitterService = class _TwitterService extends Service {
         await client.service.stop();
         this.clients.delete(key);
       } catch (error) {
-        logger9.error(`Error stopping Twitter client ${key}:`, error);
+        logger10.error(`Error stopping Twitter client ${key}:`, error);
       }
     }
   }
@@ -9672,6 +9190,8 @@ var TwitterService = class _TwitterService extends Service {
     return `${clientId}-${agentId}`;
   }
 };
+_TwitterService.serviceType = TWITTER_SERVICE_NAME;
+var TwitterService = _TwitterService;
 var twitterPlugin = {
   name: TWITTER_SERVICE_NAME,
   description: "Twitter client with per-server instance management",