@elizaos/plugin-twitter 1.0.0-alpha.20 → 1.0.0-alpha.21

package/dist/index.js

@@ -1,6 +1,10 @@
 // src/index.ts
 import {
+  ChannelType as ChannelType6,
+  EventTypes as EventTypes3,
+  Role,
   Service,
+  createUniqueUuid as createUniqueUuid7,
   logger as logger9
 } from "@elizaos/core";
 
@@ -279,12 +283,6 @@ var TwitterGuestAuth = class {
     this.jar = new CookieJar();
     this.v2Client = null;
   }
-  bearerToken;
-  jar;
-  guestToken;
-  guestCreatedAt;
-  v2Client;
-  fetch;
   cookieJar() {
     return this.jar;
   }
@@ -607,7 +605,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",
@@ -2477,10 +2474,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;
@@ -3659,9 +3652,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.
@@ -4398,7 +4388,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.
    *
@@ -4788,14 +4777,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;
@@ -4994,9 +4978,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 +5012,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 +5048,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()
@@ -5729,18 +5702,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.
@@ -6178,32 +6145,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.
@@ -6501,12 +6448,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.
@@ -6576,6 +6520,7 @@ var IdleMonitorPlugin = class {
 import { spawn } from "node:child_process";
 import {
   ChannelType,
+  EventTypes,
   ModelTypes,
   createUniqueUuid,
   logger
@@ -6584,23 +6529,20 @@ 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");
   }
@@ -6811,9 +6753,9 @@ var SttTtsPlugin2 = class {
       `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
@@ -6872,7 +6814,7 @@ var SttTtsPlugin2 = class {
         return [];
       }
     };
-    this.runtime.emitEvent(["VOICE_MESSAGE_RECEIVED"], {
+    this.runtime.emitEvent(EventTypes.VOICE_MESSAGE_RECEIVED, {
       runtime: this.runtime,
       message: memory,
       callback
@@ -6985,10 +6927,6 @@ import {
   createUniqueUuid as createUniqueUuid2,
   logger as logger2
 } 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();
@@ -7110,190 +7048,6 @@ async function fetchMediaData(attachments) {
     })
   );
 }
-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({
@@ -7366,25 +7120,15 @@ async function isAgentInSpace(client, spaceId) {
 
 // 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;
@@ -7934,8 +7678,10 @@ import {
   logger as logger5
 } 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 +7744,23 @@ 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 extends EventEmitter6 {
+  constructor(runtime, state) {
+    super();
+    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 +7772,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 +7780,9 @@ 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;
     }
@@ -8049,7 +7806,6 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
     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
@@ -8124,19 +7880,6 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
     };
     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() {
     const username = this.state?.TWITTER_USERNAME || this.runtime.getSetting("TWITTER_USERNAME");
     const password = this.state?.TWITTER_PASSWORD || this.runtime.getSetting("TWITTER_PASSWORD");
@@ -8151,28 +7894,25 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
         `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) {
+          logger5.info("Using cached cookies");
+          await this.setCookiesFromArray(cachedCookies);
+        }
+        logger5.log("Waiting for Twitter login");
         if (await this.twitterClient.isLoggedIn()) {
           logger5.info("Successfully logged in.");
           break;
@@ -8193,17 +7933,22 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
           break;
         }
       } catch (error) {
-        logger5.error(`Login attempt failed: ${error.message}`);
+        lastError = error instanceof Error ? error : new Error(String(error));
+        logger5.error(
+          `Login attempt ${retryCount + 1} failed: ${lastError.message}`
+        );
+        retryCount++;
+        if (retryCount < maxRetries) {
+          const delay = 2 ** retryCount * 1e3;
+          logger5.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) {
@@ -8417,7 +8162,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 +8171,44 @@ 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,7 +8228,110 @@ var ClientBase = class _ClientBase extends EventEmitter6 {
       throw error;
     }
   }
+  /**
+   * Fetches recent interactions (likes, retweets, quotes) for the authenticated user's tweets
+   */
+  async fetchInteractions() {
+    try {
+      const interactions = await this.requestQueue.add(
+        () => this.twitterClient.get("statuses/mentions_timeline", {
+          count: 100,
+          include_entities: true
+        })
+      );
+      return interactions.map((interaction) => ({
+        id: interaction.id_str,
+        type: this.getInteractionType(interaction),
+        userId: interaction.user.id_str,
+        username: interaction.user.screen_name,
+        name: interaction.user.name,
+        targetTweetId: interaction.in_reply_to_status_id_str || interaction.quoted_status_id_str,
+        targetTweet: interaction.quoted_status || interaction,
+        quoteTweet: interaction.is_quote_status ? interaction : void 0,
+        retweetId: interaction.retweeted_status?.id_str
+      }));
+    } catch (error) {
+      logger5.error("Error fetching Twitter interactions:", error);
+      return [];
+    }
+  }
+  /**
+   * Determines the type of interaction from a Twitter API response
+   */
+  getInteractionType(interaction) {
+    if (interaction.retweeted_status) {
+      return "retweet";
+    }
+    if (interaction.is_quote_status) {
+      return "quote";
+    }
+    return "like";
+  }
+  /**
+   * Fetches recent follower changes (new followers and unfollowers)
+   */
+  async fetchFollowerChanges() {
+    try {
+      const currentFollowers = await this.requestQueue.add(
+        () => this.twitterClient.get("followers/list", {
+          count: 200,
+          include_user_entities: false
+        })
+      );
+      const cachedFollowers = await this.getCachedFollowers();
+      const changes = [];
+      for (const follower of currentFollowers.users) {
+        if (!cachedFollowers.some(
+          (f) => f.id_str === follower.id_str
+        )) {
+          changes.push({
+            type: "followed",
+            userId: follower.id_str,
+            username: follower.screen_name,
+            name: follower.name,
+            user: follower
+          });
+        }
+      }
+      for (const cached of cachedFollowers) {
+        if (!currentFollowers.users.some((f) => f.id_str === cached.id_str)) {
+          changes.push({
+            type: "unfollowed",
+            userId: cached.id_str,
+            username: cached.screen_name,
+            name: cached.name,
+            user: cached
+          });
+        }
+      }
+      await this.cacheFollowers(currentFollowers.users);
+      return changes;
+    } catch (error) {
+      logger5.error("Error fetching Twitter follower changes:", error);
+      return [];
+    }
+  }
+  /**
+   * Gets cached followers from the database
+   */
+  async getCachedFollowers() {
+    const cached = await this.runtime.getCache(
+      `twitter/${this.profile.username}/followers`
+    );
+    return cached || [];
+  }
+  /**
+   * Caches current followers in the database
+   */
+  async cacheFollowers(followers) {
+    await this.runtime.setCache(
+      `twitter/${this.profile.username}/followers`,
+      followers
+    );
+  }
 };
+_ClientBase._twitterClients = {};
+var ClientBase = _ClientBase;
 
 // src/constants.ts
 var TWITTER_SERVICE_NAME = "twitter";
@@ -8481,58 +8339,38 @@ var TWITTER_SERVICE_NAME = "twitter";
 // src/interactions.ts
 import {
   ChannelType as ChannelType4,
+  EventTypes as EventTypes2,
   ModelTypes as ModelTypes4,
   composePrompt as composePrompt2,
   createUniqueUuid as createUniqueUuid4,
-  logger as logger6,
-  parseJSONObjectFromText
+  logger as logger6
 } 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 ServiceTypes2 = {
+  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.
@@ -8611,6 +8449,68 @@ var TwitterInteractionClient = class {
             entityId,
             roomId
           };
+          if (tweet.text.includes(`@${twitterUsername}`)) {
+            const messagePayload = {
+              runtime: this.runtime,
+              message: {
+                ...message,
+                content: {
+                  ...message.content,
+                  source: "twitter"
+                },
+                roomId: message.roomId
+              },
+              source: "twitter",
+              callback: async (response) => {
+                logger6.info("Received message response:", response);
+                return [];
+              }
+            };
+            this.runtime.emitEvent(EventTypes2.MESSAGE_RECEIVED, messagePayload);
+            const mentionPayload = {
+              runtime: this.runtime,
+              message: {
+                ...message,
+                content: {
+                  ...message.content,
+                  source: "twitter"
+                },
+                roomId: message.roomId
+              },
+              tweet: convertToCoreTweet(tweet),
+              user: {
+                id: tweet.userId,
+                username: tweet.username,
+                name: tweet.name
+              },
+              source: "twitter",
+              callback: async (response) => {
+                logger6.info("Received mention response:", response);
+                return [];
+              }
+            };
+            this.runtime.emitEvent("TWITTER_MENTION_RECEIVED" /* MENTION_RECEIVED */, mentionPayload);
+          }
+          if (thread.length > 1) {
+            const threadPayload = {
+              runtime: this.runtime,
+              tweets: convertToCoreTweets(thread),
+              user: {
+                id: tweet.userId,
+                username: tweet.username,
+                name: tweet.name
+              },
+              source: "twitter"
+            };
+            if (thread[thread.length - 1].id === tweet.id) {
+              this.runtime.emitEvent("TWITTER_THREAD_UPDATED" /* THREAD_UPDATED */, {
+                ...threadPayload,
+                newTweet: convertToCoreTweet(tweet)
+              });
+            } else if (thread[0].id === tweet.id) {
+              this.runtime.emitEvent("TWITTER_THREAD_CREATED" /* THREAD_CREATED */, threadPayload);
+            }
+          }
           await this.handleTweet({
             tweet,
             message,
@@ -8619,6 +8519,156 @@ var TwitterInteractionClient = class {
           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.getMemoryManager("interactions").createMemory(memory);
+          const reactionMessage = {
+            id: createUniqueUuid4(this.runtime, interaction.targetTweetId),
+            content: {
+              text: interaction.targetTweet.text,
+              source: "twitter"
+            },
+            entityId: createUniqueUuid4(this.runtime, interaction.targetTweet.userId),
+            roomId: createUniqueUuid4(this.runtime, interaction.targetTweet.conversationId),
+            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(EventTypes2.REACTION_RECEIVED, {
+                ...basePayload,
+                reaction: {
+                  type: "like",
+                  entityId: createUniqueUuid4(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(EventTypes2.REACTION_RECEIVED, {
+                ...basePayload,
+                reaction: {
+                  type: "retweet",
+                  entityId: createUniqueUuid4(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: createUniqueUuid4(this.runtime, interaction.userId)
+                }
+              };
+              this.runtime.emitEvent("TWITTER_QUOTE_RECEIVED" /* QUOTE_RECEIVED */, quotePayload);
+              this.runtime.emitEvent(EventTypes2.REACTION_RECEIVED, {
+                ...basePayload,
+                reaction: {
+                  type: "quote",
+                  entityId: createUniqueUuid4(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.getMemoryManager("follower-changes").createMemory(followerMemory);
+        }
+      };
+      const followerChanges = await this.client.fetchFollowerChanges();
+      for (const change of followerChanges) {
+        const changeId = createUniqueUuid4(this.runtime, `${change.type}-${change.userId}`);
+        const existingChange = await this.runtime.getMemoryManager("follower-changes").getMemoryById(changeId);
+        if (existingChange) continue;
+        const entityId = createUniqueUuid4(this.runtime, change.userId);
+        const basePayload = {
+          runtime: this.runtime,
+          user: {
+            id: change.userId,
+            username: change.username,
+            name: change.name
+          },
+          source: "twitter"
+        };
+        if (change.type === "followed") {
+          const userFollowedPayload = {
+            ...basePayload,
+            follower: change.user,
+            entityId: createUniqueUuid4(this.runtime, change.userId),
+            roomId: createUniqueUuid4(this.runtime, this.client.profile.id)
+          };
+          this.runtime.emitEvent("TWITTER_USER_FOLLOWED" /* USER_FOLLOWED */, userFollowedPayload);
+        } else if (change.type === "unfollowed") {
+          const userUnfollowedPayload = {
+            ...basePayload,
+            unfollower: change.user,
+            entityId: createUniqueUuid4(this.runtime, change.userId),
+            roomId: createUniqueUuid4(this.runtime, this.client.profile.id)
+          };
+          this.runtime.emitEvent("TWITTER_USER_UNFOLLOWED" /* USER_UNFOLLOWED */, userUnfollowedPayload);
+        }
+        await processFollowerChange(change, this.client.profile.id);
+      }
       await this.client.cacheLatestCheckedTweetId();
       logger6.log("Finished checking Twitter interactions");
     } catch (error) {
@@ -8676,12 +8726,11 @@ var TwitterInteractionClient = class {
     } catch (error) {
       logger6.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);
@@ -8698,117 +8747,96 @@ var TwitterInteractionClient = class {
         source: "twitter",
         type: ChannelType4.GROUP
       });
-      const message2 = {
+      await this.runtime.ensureRoomExists({
+        id: roomId,
+        name: `Conversation with ${tweet.name}`,
+        source: "twitter",
+        type: ChannelType4.GROUP,
+        channelId: tweet.conversationId,
+        worldId: createUniqueUuid4(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 ? createUniqueUuid4(this.runtime, tweet.inReplyToStatusId) : void 0,
+          source: "twitter",
+          channelType: ChannelType4.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(ModelTypes4.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") {
+      logger6.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) {
+          logger6.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}`
+        logger6.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 = createUniqueUuid4(
+          this.runtime,
+          replyTweetResult.id_str
+        );
+        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.getMemoryManager("messages").createMemory(responseMemory);
+        return [responseMemory];
+      } catch (error) {
+        logger6.error("Error replying to tweet:", error);
+        return [];
       }
-    }
+    };
+    this.runtime.emitEvent(EventTypes2.MESSAGE_RECEIVED, {
+      runtime: this.runtime,
+      message,
+      callback,
+      source: "twitter"
+    });
+    return { text: "", actions: ["RESPOND"] };
   }
   /**
    * Build a conversation thread based on a given tweet.
@@ -8898,18 +8926,29 @@ ${response.text}`;
     await processThread.bind(this)(tweet, 0);
     return thread;
   }
+  createMemoryObject(type, id, userId, roomId) {
+    return {
+      id: createUniqueUuid4(this.runtime, id),
+      agentId: this.runtime.agentId,
+      entityId: createUniqueUuid4(this.runtime, userId),
+      roomId: createUniqueUuid4(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,
+  parseJSONObjectFromText,
   truncateToCompleteSentence
 } from "@elizaos/core";
 
@@ -8922,11 +8961,6 @@ Your response should not contain any questions. Brief, concise statements only.
 
 // 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
@@ -8941,7 +8975,7 @@ var TwitterPostClient = class {
     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(`- 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"}`
     );
@@ -8958,44 +8992,21 @@ var TwitterPostClient = class {
     }
   }
   /**
-   * 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();
+    logger7.log("Starting Twitter post client...");
+    const tweetGeneration = this.runtime.getSetting("TWITTER_ENABLE_TWEET_GENERATION");
+    if (tweetGeneration === false) {
+      logger7.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);
   }
   /**
    * Creates a Tweet object based on the tweet result, client information, and Twitter username.
@@ -9035,7 +9046,7 @@ 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()
     });
@@ -9156,95 +9167,169 @@ var TwitterPostClient = class {
     }
   }
   /**
-   * 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"]
-        }
-      });
-      state.values = {
-        ...state.values,
-        twitterUserName: this.client.profile.username
-      };
-      const prompt = composePrompt3({
+      logger7.log("Generating new tweet...");
+      const userId = this.client.profile?.id;
+      if (!userId) {
+        logger7.error("Cannot generate tweet: Twitter profile not available");
+        return;
+      }
+      const worldId = createUniqueUuid5(this.runtime, userId);
+      const timelineRoomId = createUniqueUuid5(this.runtime, `${userId}-home`);
+      const state = await this.runtime.composeState(null, [
+        "CHARACTER",
+        "RECENT_MESSAGES",
+        "TIME"
+      ]);
+      const tweetPrompt = composePrompt3({
         state,
         template: this.runtime.character.templates?.twitterPostTemplate || twitterPostTemplate
       });
-      logger7.debug(`generate post prompt:
-${prompt}`);
-      const response = await this.runtime.useModel(ModelTypes5.TEXT_SMALL, {
-        prompt
+      const response = await this.runtime.useModel(ModelTypes5.TEXT_LARGE, {
+        prompt: tweetPrompt
       });
-      const rawTweetContent = cleanJsonResponse(response);
-      let tweetTextForPosting = null;
-      let mediaData = null;
-      const parsedResponse = parseJSONObjectFromText2(rawTweetContent);
-      if (parsedResponse?.text) {
-        tweetTextForPosting = parsedResponse.text;
-      } else {
-        tweetTextForPosting = rawTweetContent.trim();
+      const jsonResponse = parseJSONObjectFromText(response);
+      if (!jsonResponse || !jsonResponse.text) {
+        logger7.error("Failed to generate valid tweet content");
+        return;
       }
-      if (parsedResponse?.attachments && parsedResponse?.attachments.length > 0) {
-        mediaData = await fetchMediaData(parsedResponse.attachments);
+      const cleanedText = this.cleanupTweetText(jsonResponse.text);
+      const mediaData = [];
+      if (jsonResponse.imagePrompt) {
+        try {
+          const imagePromptMedia = Array.isArray(jsonResponse.imagePrompt) ? jsonResponse.imagePrompt.map((prompt) => ({
+            url: prompt,
+            contentType: "image/png"
+          })) : [{
+            url: jsonResponse.imagePrompt,
+            contentType: "image/png"
+          }];
+          const fetchedMedia = await fetchMediaData(imagePromptMedia);
+          mediaData.push(...fetchedMedia);
+        } catch (error) {
+          logger7.error("Error fetching media for tweet:", error);
+        }
       }
-      if (!tweetTextForPosting) {
-        const parsingText = extractAttributes(rawTweetContent, ["text"]).text;
-        if (parsingText) {
-          tweetTextForPosting = truncateToCompleteSentence(
-            extractAttributes(rawTweetContent, ["text"]).text,
-            280 - 1
-          );
+      const tweetId = createUniqueUuid5(this.runtime, `tweet-${Date.now()}`);
+      const memory = {
+        id: tweetId,
+        entityId: this.runtime.agentId,
+        agentId: this.runtime.agentId,
+        roomId: timelineRoomId,
+        content: {
+          text: cleanedText,
+          source: "twitter",
+          channelType: ChannelType5.FEED,
+          thought: jsonResponse.thought || "",
+          plan: jsonResponse.plan || "",
+          type: "post"
+        },
+        createdAt: Date.now()
+      };
+      const callback = async (content) => {
+        try {
+          if (this.isDryRun) {
+            logger7.info(`[DRY RUN] Would post tweet: ${content.text}`);
+            return [];
+          }
+          const result = await this.postToTwitter(content.text, mediaData);
+          if (result) {
+            const postedTweetId = createUniqueUuid5(
+              this.runtime,
+              result.id_str
+            );
+            const postedMemory = {
+              id: postedTweetId,
+              entityId: this.runtime.agentId,
+              agentId: this.runtime.agentId,
+              roomId: timelineRoomId,
+              content: {
+                ...content,
+                source: "twitter",
+                channelType: ChannelType5.FEED,
+                type: "post",
+                metadata: {
+                  tweetId: result.id_str,
+                  postedAt: Date.now()
+                }
+              },
+              createdAt: Date.now()
+            };
+            await this.runtime.getMemoryManager("messages").createMemory(postedMemory);
+            return [postedMemory];
+          }
+          return [];
+        } catch (error) {
+          logger7.error("Error posting tweet:", error);
+          return [];
+        }
+      };
+      this.runtime.emitEvent(["TWITTER_POST_GENERATED", "POST_GENERATED"], {
+        runtime: this.runtime,
+        message: memory,
+        callback,
+        source: "twitter"
+      });
+    } catch (error) {
+      logger7.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 {
+            const uploadResult = await this.client.requestQueue.add(
+              () => this.client.twitterClient.post("media/upload", {
+                media_data: Buffer.isBuffer(media.data) ? media.data : Buffer.from(String(media.data).split(",")[1], "base64")
+              })
+            );
+            if (uploadResult && uploadResult.media_id_string) {
+              mediaIds.push(uploadResult.media_id_string);
+            }
+          } catch (error) {
+            logger7.error("Error uploading media:", error);
+          }
         }
       }
-      if (!tweetTextForPosting) {
-        tweetTextForPosting = rawTweetContent;
+      const tweetParams = {
+        status: text.substring(0, 280)
+        // Twitter's character limit
+      };
+      if (mediaIds.length > 0) {
+        tweetParams.media_ids = mediaIds.join(",");
       }
-      tweetTextForPosting = truncateToCompleteSentence(
-        tweetTextForPosting,
-        280 - 1
+      const result = await this.client.requestQueue.add(
+        () => this.client.twitterClient.post("statuses/update", tweetParams)
       );
-      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);
-      }
+      return result;
     } catch (error) {
-      logger7.error("Error generating new tweet:", error);
+      logger7.error("Error posting to Twitter:", error);
+      throw error;
     }
   }
+  /**
+   * Cleans up a tweet text by removing quotes and fixing newlines
+   */
+  cleanupTweetText(text) {
+    let cleanedText = text.replace(/^['"](.*)['"]$/, "$1");
+    cleanedText = cleanedText.replaceAll(/\\n/g, "\n\n");
+    if (cleanedText.length > 280) {
+      cleanedText = truncateToCompleteSentence(cleanedText, 280);
+    }
+    return cleanedText;
+  }
   async stop() {
   }
 };
@@ -9256,13 +9341,6 @@ import {
   logger as logger8,
   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 +9353,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",
@@ -9553,11 +9630,6 @@ 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);
@@ -9572,11 +9644,12 @@ var TwitterClientInstance = class {
     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();
@@ -9606,6 +9679,7 @@ var TwitterService = class _TwitterService extends Service {
         client.interaction.start();
       }
       this.clients.set(this.getClientKey(clientId, runtime.agentId), client);
+      await this.emitServerJoinedEvent(runtime, client);
       logger9.info(`Created Twitter client for ${clientId}`);
       return client;
     } catch (error) {
@@ -9613,6 +9687,83 @@ var TwitterService = class _TwitterService extends Service {
       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) {
+        logger9.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 = createUniqueUuid7(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 = createUniqueUuid7(runtime, `${twitterId}-home`);
+      const homeTimelineRoom = {
+        id: homeTimelineRoomId,
+        name: `${username}'s Timeline`,
+        source: "twitter",
+        type: ChannelType6.FEED,
+        channelId: `${twitterId}-home`,
+        serverId: twitterId,
+        worldId
+      };
+      const mentionsRoomId = createUniqueUuid7(runtime, `${twitterId}-mentions`);
+      const mentionsRoom = {
+        id: mentionsRoomId,
+        name: `${username}'s Mentions`,
+        source: "twitter",
+        type: ChannelType6.GROUP,
+        channelId: `${twitterId}-mentions`,
+        serverId: twitterId,
+        worldId
+      };
+      const twitterUserId = createUniqueUuid7(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 */, EventTypes3.WORLD_JOINED], {
+        runtime,
+        world,
+        rooms: [homeTimelineRoom, mentionsRoom],
+        users: [twitterUser],
+        source: "twitter"
+      });
+      logger9.info(`Emitted WORLD_JOINED event for Twitter account ${username}`);
+    } catch (error) {
+      logger9.error("Failed to emit WORLD_JOINED event for Twitter:", error);
+    }
+  }
   getClient(clientId, agentId) {
     return this.clients.get(this.getClientKey(clientId, agentId));
   }
@@ -9672,6 +9823,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",