@elizaos/plugin-twitter 1.0.0-beta.41 → 1.0.0-beta.43

package/dist/index.js

@@ -1,11 +1,11 @@
 // src/index.ts
 import {
-  ChannelType as ChannelType7,
+  ChannelType as ChannelType8,
   EventType as EventType4,
   Role,
   Service,
-  createUniqueUuid as createUniqueUuid7,
-  logger as logger10
+  createUniqueUuid as createUniqueUuid8,
+  logger as logger11
 } from "@elizaos/core";
 
 // src/actions/spaceJoin.ts
@@ -4604,29 +4604,29 @@ async function unmuteSpeaker(params) {
     throw new Error(`unmuteSpeaker => ${resp.status} ${text}`);
   }
 }
-function setupCommonChatEvents(chatClient, logger11, emitter) {
+function setupCommonChatEvents(chatClient, logger12, emitter) {
   chatClient.on("occupancyUpdate", (upd) => {
-    logger11.debug("[ChatEvents] occupancyUpdate =>", upd);
+    logger12.debug("[ChatEvents] occupancyUpdate =>", upd);
     emitter.emit("occupancyUpdate", upd);
   });
   chatClient.on("guestReaction", (reaction) => {
-    logger11.debug("[ChatEvents] guestReaction =>", reaction);
+    logger12.debug("[ChatEvents] guestReaction =>", reaction);
     emitter.emit("guestReaction", reaction);
   });
   chatClient.on("muteStateChanged", (evt) => {
-    logger11.debug("[ChatEvents] muteStateChanged =>", evt);
+    logger12.debug("[ChatEvents] muteStateChanged =>", evt);
     emitter.emit("muteStateChanged", evt);
   });
   chatClient.on("speakerRequest", (req) => {
-    logger11.debug("[ChatEvents] speakerRequest =>", req);
+    logger12.debug("[ChatEvents] speakerRequest =>", req);
     emitter.emit("speakerRequest", req);
   });
   chatClient.on("newSpeakerAccepted", (info) => {
-    logger11.debug("[ChatEvents] newSpeakerAccepted =>", info);
+    logger12.debug("[ChatEvents] newSpeakerAccepted =>", info);
     emitter.emit("newSpeakerAccepted", info);
   });
   chatClient.on("newSpeakerRemoved", (info) => {
-    logger11.debug("[ChatEvents] newSpeakerRemoved =>", info);
+    logger12.debug("[ChatEvents] newSpeakerRemoved =>", info);
     emitter.emit("newSpeakerRemoved", info);
   });
 }
@@ -6699,6 +6699,31 @@ async function sendTweet(client, text, mediaData = [], tweetToReplyTo) {
     return await sendStandardTweet(client, text, tweetToReplyTo, mediaData);
   }
 }
+var parseActionResponseFromText = (text) => {
+  const actions = {
+    like: false,
+    retweet: false,
+    quote: false,
+    reply: false
+  };
+  const likePattern = /\[LIKE\]/i;
+  const retweetPattern = /\[RETWEET\]/i;
+  const quotePattern = /\[QUOTE\]/i;
+  const replyPattern = /\[REPLY\]/i;
+  actions.like = likePattern.test(text);
+  actions.retweet = retweetPattern.test(text);
+  actions.quote = quotePattern.test(text);
+  actions.reply = replyPattern.test(text);
+  const lines = text.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "[LIKE]") actions.like = true;
+    if (trimmed === "[RETWEET]") actions.retweet = true;
+    if (trimmed === "[QUOTE]") actions.quote = true;
+    if (trimmed === "[REPLY]") actions.reply = true;
+  }
+  return { actions };
+};
 async function generateFiller(runtime, fillerType) {
   try {
     const prompt = composePrompt({
@@ -8428,8 +8453,7 @@ import {
   ChannelType as ChannelType6,
   EventType as EventType3,
   createUniqueUuid as createUniqueUuid6,
-  logger as logger8,
-  parseBooleanFromText
+  logger as logger8
 } from "@elizaos/core";
 var TwitterPostClient = class {
   /**
@@ -8447,12 +8471,6 @@ var TwitterPostClient = class {
     logger8.log("Twitter Client Configuration:");
     logger8.log(`- Username: ${this.twitterUsername}`);
     logger8.log(`- Dry Run Mode: ${this.isDryRun ? "Enabled" : "Disabled"}`);
-    this.state.isTwitterEnabled = parseBooleanFromText(
-      String(
-        this.state?.TWITTER_ENABLE_POST_GENERATION || this.runtime.getSetting("TWITTER_ENABLE_POST_GENERATION") || ""
-      )
-    );
-    logger8.log(`- Auto-post: ${this.state.isTwitterEnabled ? "enabled" : "disabled"}`);
     logger8.log(
       `- Post Interval: ${this.state?.TWITTER_POST_INTERVAL_MIN || this.runtime.getSetting("TWITTER_POST_INTERVAL_MIN") || 90}-${this.state?.TWITTER_POST_INTERVAL_MAX || this.runtime.getSetting("TWITTER_POST_INTERVAL_MAX") || 180} minutes`
     );
@@ -8468,11 +8486,6 @@ var TwitterPostClient = class {
    */
   async start() {
     logger8.log("Starting Twitter post client...");
-    const tweetGeneration = this.state.isTwitterEnabled;
-    if (tweetGeneration === false) {
-      logger8.log("Tweet generation is disabled");
-      return;
-    }
     const generateNewTweetLoop = async () => {
       const minPostMinutes = this.state?.TWITTER_POST_INTERVAL_MIN || this.runtime.getSetting("TWITTER_POST_INTERVAL_MIN") || 90;
       const maxPostMinutes = this.state?.TWITTER_POST_INTERVAL_MAX || this.runtime.getSetting("TWITTER_POST_INTERVAL_MAX") || 180;
@@ -8599,8 +8612,370 @@ var TwitterPostClient = class {
   }
 };
 
-// src/tests.ts
+// src/timeline.ts
+import {
+  ChannelType as ChannelType7,
+  composePromptFromState,
+  createUniqueUuid as createUniqueUuid7,
+  ModelType as ModelType5,
+  parseKeyValueXml
+} from "@elizaos/core";
 import { logger as logger9 } from "@elizaos/core";
+
+// src/templates.ts
+var twitterActionTemplate = `
+# INSTRUCTIONS: Determine actions for {{agentName}} (@{{twitterUserName}}) based on:
+{{bio}}
+{{postDirections}}
+
+Guidelines:
+- ONLY engage with content that DIRECTLY relates to character's core interests
+- Direct mentions are priority IF they are on-topic
+- Skip ALL content that is:
+  - Off-topic or tangentially related
+  - From high-profile accounts unless explicitly relevant
+  - Generic/viral content without specific relevance
+  - Political/controversial unless central to character
+  - Promotional/marketing unless directly relevant
+
+Actions (respond only with tags):
+[LIKE] - Perfect topic match AND aligns with character (9.8/10)
+[RETWEET] - Exceptional content that embodies character's expertise (9.5/10)
+[QUOTE] - Can add substantial domain expertise (9.5/10)
+[REPLY] - Can contribute meaningful, expert-level insight (9.5/10)
+`;
+var quoteTweetTemplate = `# Task: Write a quote tweet in the voice, style, and perspective of {{agentName}} @{{twitterUserName}}.
+
+{{bio}}
+{{postDirections}}
+
+<response>
+  <thought>Your thought here, explaining why the quote tweet is meaningful or how it connects to what {{agentName}} cares about</thought>
+  <post>The quote tweet content here, under 280 characters, without emojis, no questions</post>
+</response>
+
+Your quote tweet should be:
+- A reaction, agreement, disagreement, or expansion of the original tweet
+- Personal and unique to {{agentName}}\u2019s style and point of view
+- 1 to 3 sentences long, chosen at random
+- No questions, no emojis, concise
+- Use "\\n\\n" (double spaces) between multiple sentences
+- Max 280 characters including line breaks
+
+Your output must ONLY contain the XML block.`;
+var replyTweetTemplate = `# Task: Write a reply tweet in the voice, style, and perspective of {{agentName}} @{{twitterUserName}}.
+
+{{bio}}
+{{postDirections}}
+
+<response>
+  <thought>Your thought here, explaining why this reply is meaningful or how it connects to what {{agentName}} cares about</thought>
+  <post>The reply tweet content here, under 280 characters, without emojis, no questions</post>
+</response>
+
+Your reply should be:
+- A direct response, agreement, disagreement, or personal take on the original tweet
+- Reflective of {{agentName}}\u2019s unique voice and values
+- 1 to 2 sentences long, chosen at random
+- No questions, no emojis, concise
+- Use "\\n\\n" (double spaces) between multiple sentences if needed
+- Max 280 characters including line breaks
+
+Your output must ONLY contain the XML block.`;
+
+// src/timeline.ts
+var TwitterTimelineClient = class {
+  constructor(client, runtime, state) {
+    this.client = client;
+    this.twitterClient = client.twitterClient;
+    this.runtime = runtime;
+    this.state = state;
+    this.timelineType = this.state?.TWITTER_TIMELINE_MODE || this.runtime.getSetting("TWITTER_TIMELINE_MODE");
+  }
+  async start() {
+    const handleTwitterTimelineLoop = () => {
+      const interactionInterval = (this.state?.TWITTER_TIMELINE_POLL_INTERVAL || this.runtime.getSetting("TWITTER_TIMELINE_POLL_INTERVAL") || 120) * 1e3;
+      this.handleTimeline();
+      setTimeout(handleTwitterTimelineLoop, interactionInterval);
+    };
+    handleTwitterTimelineLoop();
+  }
+  async getTimeline(count) {
+    const twitterUsername = this.client.profile?.username;
+    const homeTimeline = this.timelineType === "following" /* Following */ ? await this.twitterClient.fetchFollowingTimeline(count, []) : await this.twitterClient.fetchHomeTimeline(count, []);
+    return homeTimeline.map((tweet) => ({
+      id: tweet.rest_id,
+      name: tweet.core?.user_results?.result?.legacy?.name,
+      username: tweet.core?.user_results?.result?.legacy?.screen_name,
+      text: tweet.legacy?.full_text,
+      inReplyToStatusId: tweet.legacy?.in_reply_to_status_id_str,
+      timestamp: new Date(tweet.legacy?.created_at).getTime() / 1e3,
+      userId: tweet.legacy?.user_id_str,
+      conversationId: tweet.legacy?.conversation_id_str,
+      permanentUrl: `https://twitter.com/${tweet.core?.user_results?.result?.legacy?.screen_name}/status/${tweet.rest_id}`,
+      hashtags: tweet.legacy?.entities?.hashtags || [],
+      mentions: tweet.legacy?.entities?.user_mentions || [],
+      photos: tweet.legacy?.entities?.media?.filter((media) => media.type === "photo").map((media) => ({
+        id: media.id_str,
+        url: media.media_url_https,
+        // Store media_url_https as url
+        alt_text: media.alt_text
+      })) || [],
+      thread: tweet.thread || [],
+      urls: tweet.legacy?.entities?.urls || [],
+      videos: tweet.legacy?.entities?.media?.filter((media) => media.type === "video") || []
+    })).filter((tweet) => tweet.username !== twitterUsername);
+  }
+  createTweetId(runtime, tweet) {
+    return createUniqueUuid7(runtime, tweet.id);
+  }
+  formMessage(runtime, tweet) {
+    return {
+      id: this.createTweetId(runtime, tweet),
+      agentId: runtime.agentId,
+      content: {
+        text: tweet.text,
+        url: tweet.permanentUrl,
+        imageUrls: tweet.photos?.map((photo) => photo.url) || [],
+        inReplyTo: tweet.inReplyToStatusId ? createUniqueUuid7(runtime, tweet.inReplyToStatusId) : void 0,
+        source: "twitter",
+        channelType: ChannelType7.GROUP,
+        tweet
+      },
+      entityId: createUniqueUuid7(runtime, tweet.userId),
+      roomId: createUniqueUuid7(runtime, tweet.conversationId),
+      createdAt: tweet.timestamp * 1e3
+    };
+  }
+  async handleTimeline() {
+    console.log("Start Hanldeling Twitter Timeline");
+    const tweets = await this.getTimeline(20);
+    const maxActionsPerCycle = 20;
+    const tweetDecisions = [];
+    for (const tweet of tweets) {
+      try {
+        const tweetId = this.createTweetId(this.runtime, tweet);
+        const memory = await this.runtime.getMemoryById(tweetId);
+        if (memory) {
+          console.log(`Already processed tweet ID: ${tweet.id}`);
+          continue;
+        }
+        const roomId = createUniqueUuid7(this.runtime, tweet.conversationId);
+        const message = this.formMessage(this.runtime, tweet);
+        let state = await this.runtime.composeState(message);
+        const actionRespondPrompt = composePromptFromState({
+          state,
+          template: this.runtime.character.templates?.twitterActionTemplate || twitterActionTemplate
+        }) + `
+Tweet:
+${tweet.text}
+
+# Respond with qualifying action tags only.
+
+Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appropriate. Each action must be on its own line. Your response must only include the chosen actions.`;
+        const actionResponse = await this.runtime.useModel(ModelType5.TEXT_SMALL, {
+          prompt: actionRespondPrompt
+        });
+        if (!actionResponse) {
+          logger9.log(`No valid actions generated for tweet ${tweet.id}`);
+          continue;
+        }
+        const { actions } = parseActionResponseFromText(actionResponse.trim());
+        tweetDecisions.push({
+          tweet,
+          actionResponse: actions,
+          tweetState: state,
+          roomId
+        });
+      } catch (error) {
+        logger9.error(`Error processing tweet ${tweet.id}:`, error);
+        continue;
+      }
+    }
+    const rankByActionRelevance = (arr) => {
+      return arr.sort((a, b) => {
+        const countTrue = (obj) => Object.values(obj).filter(Boolean).length;
+        const countA = countTrue(a.actionResponse);
+        const countB = countTrue(b.actionResponse);
+        if (countA !== countB) {
+          return countB - countA;
+        }
+        if (a.actionResponse.like !== b.actionResponse.like) {
+          return a.actionResponse.like ? -1 : 1;
+        }
+        return 0;
+      });
+    };
+    const prioritizedTweets = rankByActionRelevance(tweetDecisions);
+    this.processTimelineActions(prioritizedTweets);
+  }
+  async processTimelineActions(tweetDecisions) {
+    const results = [];
+    for (const decision of tweetDecisions) {
+      const { actionResponse, tweetState, roomId, tweet } = decision;
+      const entityId = createUniqueUuid7(this.runtime, tweet.userId);
+      const worldId = createUniqueUuid7(this.runtime, tweet.userId);
+      await this.ensureTweetWorldContext(tweet, roomId, worldId, entityId);
+      try {
+        const message = this.formMessage(this.runtime, tweet);
+        await Promise.all([
+          this.runtime.addEmbeddingToMemory(message),
+          this.runtime.createMemory(message, "messages")
+        ]);
+        if (actionResponse.like) {
+          this.handleLikeAction(tweet);
+        }
+        if (actionResponse.retweet) {
+          this.handleRetweetAction(tweet);
+        }
+        if (actionResponse.quote) {
+          this.handleQuoteAction(tweet);
+        }
+        if (actionResponse.reply) {
+          this.handleReplyAction(tweet);
+        }
+      } catch (error) {
+        logger9.error(`Error processing tweet ${tweet.id}:`, error);
+        continue;
+      }
+    }
+    return results;
+  }
+  async ensureTweetWorldContext(tweet, roomId, worldId, entityId) {
+    await this.runtime.ensureWorldExists({
+      id: worldId,
+      name: `${tweet.name}'s Twitter`,
+      agentId: this.runtime.agentId,
+      serverId: tweet.userId,
+      metadata: {
+        ownership: { ownerId: tweet.userId },
+        twitter: {
+          username: tweet.username,
+          id: tweet.userId,
+          name: tweet.name
+        }
+      }
+    });
+    await this.runtime.ensureConnection({
+      entityId,
+      roomId,
+      userName: tweet.username,
+      name: tweet.name,
+      source: "twitter",
+      type: ChannelType7.GROUP,
+      channelId: tweet.conversationId,
+      serverId: tweet.userId,
+      worldId
+    });
+    await this.runtime.ensureRoomExists({
+      id: roomId,
+      name: `Conversation with ${tweet.name}`,
+      source: "twitter",
+      type: ChannelType7.GROUP,
+      channelId: tweet.conversationId,
+      serverId: tweet.userId,
+      worldId
+    });
+  }
+  async handleLikeAction(tweet) {
+    try {
+      await this.twitterClient.likeTweet(tweet.id);
+      logger9.log(`Liked tweet ${tweet.id}`);
+    } catch (error) {
+      logger9.error(`Error liking tweet ${tweet.id}:`, error);
+    }
+  }
+  async handleRetweetAction(tweet) {
+    try {
+      await this.twitterClient.retweet(tweet.id);
+      logger9.log(`Retweeted tweet ${tweet.id}`);
+    } catch (error) {
+      logger9.error(`Error retweeting tweet ${tweet.id}:`, error);
+    }
+  }
+  async handleQuoteAction(tweet) {
+    try {
+      const message = this.formMessage(this.runtime, tweet);
+      let state = await this.runtime.composeState(message);
+      const quotePrompt = composePromptFromState({
+        state,
+        template: this.runtime.character.templates?.quoteTweetTemplate || quoteTweetTemplate
+      }) + `
+You are responding to this tweet:
+${tweet.text}`;
+      const quoteResponse = await this.runtime.useModel(ModelType5.TEXT_SMALL, {
+        prompt: quotePrompt
+      });
+      const responseObject = parseKeyValueXml(quoteResponse);
+      if (responseObject.post) {
+        const result = await this.client.requestQueue.add(
+          async () => await this.twitterClient.sendQuoteTweet(responseObject.post, tweet.id)
+        );
+        const body = await result.json();
+        if (body?.data?.create_tweet?.tweet_results?.result) {
+          logger9.log("Successfully posted quote tweet");
+        } else {
+          logger9.error("Quote tweet creation failed:", body);
+        }
+        const responseId = createUniqueUuid7(this.runtime, body.rest_id);
+        const responseMemory = {
+          id: responseId,
+          entityId: this.runtime.agentId,
+          agentId: this.runtime.agentId,
+          roomId: message.roomId,
+          content: {
+            ...responseObject,
+            inReplyTo: message.id
+          },
+          createdAt: Date.now()
+        };
+        await this.runtime.createMemory(responseMemory, "messages");
+      }
+    } catch (error) {
+      logger9.error("Error in quote tweet generation:", error);
+    }
+  }
+  async handleReplyAction(tweet) {
+    try {
+      const message = this.formMessage(this.runtime, tweet);
+      let state = await this.runtime.composeState(message);
+      const replyPrompt = composePromptFromState({
+        state,
+        template: this.runtime.character.templates?.replyTweetTemplate || replyTweetTemplate
+      }) + `
+You are responding to this tweet:
+${tweet.text}`;
+      const replyResponse = await this.runtime.useModel(ModelType5.TEXT_SMALL, {
+        prompt: replyPrompt
+      });
+      const responseObject = parseKeyValueXml(replyResponse);
+      if (responseObject.post) {
+        const tweetResult = await sendTweet(this.client, responseObject.post, [], tweet.id);
+        if (!tweetResult) {
+          throw new Error("Failed to get tweet result from response");
+        }
+        const responseId = createUniqueUuid7(this.runtime, tweetResult.rest_id);
+        const responseMemory = {
+          id: responseId,
+          entityId: this.runtime.agentId,
+          agentId: this.runtime.agentId,
+          roomId: message.roomId,
+          content: {
+            ...responseObject,
+            inReplyTo: message.id
+          },
+          createdAt: Date.now()
+        };
+        await this.runtime.createMemory(responseMemory, "messages");
+      }
+    } catch (error) {
+      logger9.error("Error in quote tweet generation:", error);
+    }
+  }
+};
+
+// src/tests.ts
+import { logger as logger10 } from "@elizaos/core";
 var ClientBaseTestSuite = class {
   constructor() {
     this.name = "twitter-client-base";
@@ -8660,7 +9035,7 @@ var ClientBaseTestSuite = class {
     if (client.state.TWITTER_DRY_RUN !== true) {
       throw new Error("Client state TWITTER_DRY_RUN mismatch.");
     }
-    logger9.success("ClientBase instance created with correct configuration.");
+    logger10.success("ClientBase instance created with correct configuration.");
   }
   async testPostIntervals() {
     const client = new ClientBase(this.mockRuntime, this.mockConfig);
@@ -8676,7 +9051,7 @@ var ClientBaseTestSuite = class {
     if (client.state.TWITTER_POST_INTERVAL_MAX !== 180) {
       throw new Error("Client state TWITTER_POST_INTERVAL_MAX mismatch.");
     }
-    logger9.success("ClientBase initialized with correct post intervals.");
+    logger10.success("ClientBase initialized with correct post intervals.");
   }
 };
 
@@ -8684,8 +9059,15 @@ var ClientBaseTestSuite = class {
 var TwitterClientInstance = class {
   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);
+    if (runtime.getSetting("TWITTER_ENABLE_POST_GENERATION") === true) {
+      this.post = new TwitterPostClient(this.client, runtime, state);
+    }
+    if (runtime.getSetting("TWITTER_INTERACTION_ENABLE") === true) {
+      this.interaction = new TwitterInteractionClient(this.client, runtime, state);
+    }
+    if (runtime.getSetting("TWITTER_TIMELINE_ENABLE") === true) {
+      this.timeline = new TwitterTimelineClient(this.client, runtime, state);
+    }
     if (runtime.getSetting("TWITTER_SPACES_ENABLE") === true) {
       this.space = new TwitterSpaceClient(this.client, runtime);
     }
@@ -8711,7 +9093,7 @@ var _TwitterService = class _TwitterService extends Service {
     try {
       const existingClient = this.getClient(clientId, runtime.agentId);
       if (existingClient) {
-        logger10.info(`Twitter client already exists for ${clientId}`);
+        logger11.info(`Twitter client already exists for ${clientId}`);
         return existingClient;
       }
       const client = new TwitterClientInstance(runtime, state);
@@ -8725,12 +9107,15 @@ var _TwitterService = class _TwitterService extends Service {
       if (client.interaction) {
         client.interaction.start();
       }
+      if (client.timeline) {
+        client.timeline.start();
+      }
       this.clients.set(this.getClientKey(clientId, runtime.agentId), client);
       await this.emitServerJoinedEvent(runtime, client);
-      logger10.info(`Created Twitter client for ${clientId}`);
+      logger11.info(`Created Twitter client for ${clientId}`);
       return client;
     } catch (error) {
-      logger10.error(`Failed to create Twitter client for ${clientId}:`, error);
+      logger11.error(`Failed to create Twitter client for ${clientId}:`, error);
       throw error;
     }
   }
@@ -8742,13 +9127,13 @@ var _TwitterService = class _TwitterService extends Service {
   async emitServerJoinedEvent(runtime, client) {
     try {
       if (!client.client.profile) {
-        logger10.warn("Twitter profile not available yet, can't emit WORLD_JOINED event");
+        logger11.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 worldId = createUniqueUuid8(runtime, twitterId);
       const world = {
         id: worldId,
         name: `${username}'s Twitter`,
@@ -8765,27 +9150,27 @@ var _TwitterService = class _TwitterService extends Service {
           }
         }
       };
-      const homeTimelineRoomId = createUniqueUuid7(runtime, `${twitterId}-home`);
+      const homeTimelineRoomId = createUniqueUuid8(runtime, `${twitterId}-home`);
       const homeTimelineRoom = {
         id: homeTimelineRoomId,
         name: `${username}'s Timeline`,
         source: "twitter",
-        type: ChannelType7.FEED,
+        type: ChannelType8.FEED,
         channelId: `${twitterId}-home`,
         serverId: twitterId,
         worldId
       };
-      const mentionsRoomId = createUniqueUuid7(runtime, `${twitterId}-mentions`);
+      const mentionsRoomId = createUniqueUuid8(runtime, `${twitterId}-mentions`);
       const mentionsRoom = {
         id: mentionsRoomId,
         name: `${username}'s Mentions`,
         source: "twitter",
-        type: ChannelType7.GROUP,
+        type: ChannelType8.GROUP,
         channelId: `${twitterId}-mentions`,
         serverId: twitterId,
         worldId
       };
-      const twitterUserId = createUniqueUuid7(runtime, twitterId);
+      const twitterUserId = createUniqueUuid8(runtime, twitterId);
       const twitterUser = {
         id: twitterUserId,
         names: [profile.screenName || username],
@@ -8806,9 +9191,9 @@ var _TwitterService = class _TwitterService extends Service {
         users: [twitterUser],
         source: "twitter"
       });
-      logger10.info(`Emitted WORLD_JOINED event for Twitter account ${username}`);
+      logger11.info(`Emitted WORLD_JOINED event for Twitter account ${username}`);
     } catch (error) {
-      logger10.error("Failed to emit WORLD_JOINED event for Twitter:", error);
+      logger11.error("Failed to emit WORLD_JOINED event for Twitter:", error);
     }
   }
   getClient(clientId, agentId) {
@@ -8821,9 +9206,9 @@ var _TwitterService = class _TwitterService extends Service {
       try {
         await client.service.stop();
         this.clients.delete(key);
-        logger10.info(`Stopped Twitter client for ${clientId}`);
+        logger11.info(`Stopped Twitter client for ${clientId}`);
       } catch (error) {
-        logger10.error(`Error stopping Twitter client for ${clientId}:`, error);
+        logger11.error(`Error stopping Twitter client for ${clientId}:`, error);
       }
     }
   }
@@ -8841,11 +9226,11 @@ var _TwitterService = class _TwitterService extends Service {
     try {
       if (config.TWITTER_USERNAME && // Basic auth
       config.TWITTER_PASSWORD && config.TWITTER_EMAIL) {
-        logger10.info("Creating default Twitter client from character settings");
+        logger11.info("Creating default Twitter client from character settings");
         await twitterClientManager.createClient(runtime, runtime.agentId, config);
       }
     } catch (error) {
-      logger10.error("Failed to create default Twitter client:", error);
+      logger11.error("Failed to create default Twitter client:", error);
     }
     return twitterClientManager;
   }
@@ -8858,7 +9243,7 @@ var _TwitterService = class _TwitterService extends Service {
         await client.service.stop();
         this.clients.delete(key);
       } catch (error) {
-        logger10.error(`Error stopping Twitter client ${key}:`, error);
+        logger11.error(`Error stopping Twitter client ${key}:`, error);
       }
     }
   }