@elizaos/plugin-twitter 1.0.13 → 1.0.14

package/dist/index.js

@@ -11,7 +11,7 @@ import {
   Role,
   Service,
   createUniqueUuid as createUniqueUuid6,
-  logger as logger6
+  logger as logger7
 } from "@elizaos/core";
 
 // src/base.ts
@@ -21,154 +21,6 @@ import {
   logger
 } from "@elizaos/core";
 
-// src/client/api.ts
-import { Headers } from "headers-polyfill";
-
-// src/client/errors.ts
-var ApiError = class _ApiError extends Error {
-  /**
-   * Constructor for creating a new instance of the class.
-   *
-   * @param response The response object.
-   * @param data The data object.
-   * @param message The message string.
-   */
-  constructor(response, data, message) {
-    super(message);
-    this.response = response;
-    this.data = data;
-  }
-  /**
-   * Creates an instance of ApiError based on a Response object.
-   *
-   * @param {Response} response The Response object to parse.
-   * @returns {Promise<ApiError>} A new instance of ApiError with the parsed data and status.
-   */
-  static async fromResponse(response) {
-    let data = void 0;
-    try {
-      data = await response.json();
-    } catch {
-      try {
-        data = await response.text();
-      } catch {
-      }
-    }
-    return new _ApiError(response, data, `Response status: ${response.status}`);
-  }
-};
-
-// src/client/api.ts
-async function requestApi(url, auth, method = "GET", body) {
-  const headers = new Headers({
-    "Content-Type": "application/json"
-  });
-  let res;
-  do {
-    try {
-      res = await fetch(url, {
-        method,
-        headers,
-        credentials: "include",
-        ...body && { body: JSON.stringify(body) }
-      });
-    } catch (err) {
-      if (!(err instanceof Error)) {
-        throw err;
-      }
-      return {
-        success: false,
-        err: new Error("Failed to perform request.")
-      };
-    }
-    if (res.status === 429) {
-      const xRateLimitRemaining = res.headers.get("x-rate-limit-remaining");
-      const xRateLimitReset = res.headers.get("x-rate-limit-reset");
-      if (xRateLimitRemaining === "0" && xRateLimitReset) {
-        const currentTime = (/* @__PURE__ */ new Date()).valueOf() / 1e3;
-        const timeDeltaMs = 1e3 * (Number.parseInt(xRateLimitReset) - currentTime);
-        await new Promise((resolve) => setTimeout(resolve, timeDeltaMs));
-      }
-    }
-  } while (res.status === 429);
-  if (!res.ok) {
-    return {
-      success: false,
-      err: await ApiError.fromResponse(res)
-    };
-  }
-  const transferEncoding = res.headers.get("transfer-encoding");
-  if (transferEncoding === "chunked") {
-    const reader = typeof res.body?.getReader === "function" ? res.body.getReader() : null;
-    if (!reader) {
-      try {
-        const text = await res.text();
-        try {
-          const value = JSON.parse(text);
-          return { success: true, value };
-        } catch (_e) {
-          return { success: true, value: { text } };
-        }
-      } catch (_e) {
-        return {
-          success: false,
-          err: new Error("No readable stream available and cant parse")
-        };
-      }
-    }
-    let chunks = "";
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      chunks += new TextDecoder().decode(value);
-    }
-    try {
-      const value = JSON.parse(chunks);
-      return { success: true, value };
-    } catch (_e) {
-      return { success: true, value: { text: chunks } };
-    }
-  }
-  const contentType = res.headers.get("content-type");
-  if (contentType?.includes("application/json")) {
-    const value = await res.json();
-    return { success: true, value };
-  }
-  return { success: true, value: {} };
-}
-function addApiFeatures(o) {
-  return {
-    ...o,
-    rweb_lists_timeline_redesign_enabled: true,
-    responsive_web_graphql_exclude_directive_enabled: true,
-    verified_phone_label_enabled: false,
-    creator_subscriptions_tweet_preview_api_enabled: true,
-    responsive_web_graphql_timeline_navigation_enabled: true,
-    responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
-    tweetypie_unmention_optimization_enabled: true,
-    responsive_web_edit_tweet_api_enabled: true,
-    graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
-    view_counts_everywhere_api_enabled: true,
-    longform_notetweets_consumption_enabled: true,
-    tweet_awards_web_tipping_enabled: false,
-    freedom_of_speech_not_reach_fetch_enabled: true,
-    standardized_nudges_misinfo: true,
-    longform_notetweets_rich_text_read_enabled: true,
-    responsive_web_enhance_cards_enabled: false,
-    subscriptions_verification_info_enabled: true,
-    subscriptions_verification_info_reason_enabled: true,
-    subscriptions_verification_info_verified_since_enabled: true,
-    super_follow_badge_privacy_enabled: false,
-    super_follow_exclusive_tweet_notifications_enabled: false,
-    super_follow_tweet_api_enabled: false,
-    super_follow_user_api_enabled: false,
-    android_graphql_skip_api_media_color_palette: false,
-    creator_subscriptions_subscription_count_enabled: false,
-    blue_business_profile_image_shape_enabled: false,
-    unified_cards_ad_metadata_container_dynamic_card_content_query_enabled: false
-  };
-}
-
 // src/client/auth.ts
 import { TwitterApi } from "twitter-api-v2";
 var TwitterAuth = class {
@@ -273,172 +125,110 @@ var TwitterAuth = class {
 };
 
 // src/client/profile.ts
-import stringify from "json-stable-stringify";
 function getAvatarOriginalSizeUrl(avatarUrl) {
   return avatarUrl ? avatarUrl.replace("_normal", "") : void 0;
 }
-function parseProfile(user, isBlueVerified) {
+function parseV2Profile(user) {
   const profile = {
-    avatar: getAvatarOriginalSizeUrl(user.profile_image_url_https),
-    banner: user.profile_banner_url,
+    avatar: getAvatarOriginalSizeUrl(user.profile_image_url),
     biography: user.description,
-    followersCount: user.followers_count,
-    followingCount: user.friends_count,
-    friendsCount: user.friends_count,
-    mediaCount: user.media_count,
+    followersCount: user.public_metrics?.followers_count,
+    followingCount: user.public_metrics?.following_count,
+    friendsCount: user.public_metrics?.following_count,
+    tweetsCount: user.public_metrics?.tweet_count,
     isPrivate: user.protected ?? false,
-    isVerified: user.verified,
-    likesCount: user.favourites_count,
-    listedCount: user.listed_count,
-    location: user.location,
+    isVerified: user.verified ?? false,
+    likesCount: user.public_metrics?.like_count,
+    listedCount: user.public_metrics?.listed_count,
+    location: user.location || "",
     name: user.name,
-    pinnedTweetIds: user.pinned_tweet_ids_str,
-    tweetsCount: user.statuses_count,
-    url: `https://twitter.com/${user.screen_name}`,
-    userId: user.id_str,
-    username: user.screen_name,
-    isBlueVerified: isBlueVerified ?? false,
-    canDm: user.can_dm
+    pinnedTweetIds: user.pinned_tweet_id ? [user.pinned_tweet_id] : [],
+    url: `https://twitter.com/${user.username}`,
+    userId: user.id,
+    username: user.username,
+    isBlueVerified: user.verified_type === "blue"
   };
-  if (user.created_at != null) {
-    profile.joined = new Date(Date.parse(user.created_at));
+  if (user.created_at) {
+    profile.joined = new Date(user.created_at);
   }
-  const urls = user.entities?.url?.urls;
-  if (urls?.length != null && urls?.length > 0) {
-    profile.website = urls[0].expanded_url;
+  if (user.entities?.url?.urls?.length > 0) {
+    profile.website = user.entities.url.urls[0].expanded_url;
   }
   return profile;
 }
 async function getProfile(username, auth) {
-  const params = new URLSearchParams();
-  params.set(
-    "variables",
-    stringify({
-      screen_name: username,
-      withSafetyModeUserFields: true
-    }) ?? ""
-  );
-  params.set(
-    "features",
-    stringify({
-      hidden_profile_likes_enabled: false,
-      hidden_profile_subscriptions_enabled: false,
-      // Auth-restricted
-      responsive_web_graphql_exclude_directive_enabled: true,
-      verified_phone_label_enabled: false,
-      subscriptions_verification_info_is_identity_verified_enabled: false,
-      subscriptions_verification_info_verified_since_enabled: true,
-      highlights_tweets_tab_ui_enabled: true,
-      creator_subscriptions_tweet_preview_api_enabled: true,
-      responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
-      responsive_web_graphql_timeline_navigation_enabled: true
-    }) ?? ""
-  );
-  params.set(
-    "fieldToggles",
-    stringify({ withAuxiliaryUserLabels: false }) ?? ""
-  );
-  const res = await requestApi(
-    `https://twitter.com/i/api/graphql/G3KGOASz96M-Qu0nwmGXNg/UserByScreenName?${params.toString()}`,
-    auth
-  );
-  if (!res.success) {
-    return res;
-  }
-  const { value } = res;
-  const { errors } = value;
-  if (errors != null && errors.length > 0) {
-    return {
-      success: false,
-      err: new Error(errors[0].message)
-    };
-  }
-  if (!value.data || !value.data.user || !value.data.user.result) {
+  if (!auth) {
     return {
       success: false,
-      err: new Error("User not found.")
+      err: new Error("Not authenticated")
     };
   }
-  const { result: user } = value.data.user;
-  const { legacy } = user;
-  if (user.rest_id == null || user.rest_id.length === 0) {
+  try {
+    const client = auth.getV2Client();
+    const user = await client.v2.userByUsername(username, {
+      "user.fields": [
+        "id",
+        "name",
+        "username",
+        "created_at",
+        "description",
+        "entities",
+        "location",
+        "pinned_tweet_id",
+        "profile_image_url",
+        "protected",
+        "public_metrics",
+        "url",
+        "verified",
+        "verified_type"
+      ]
+    });
+    if (!user.data) {
+      return {
+        success: false,
+        err: new Error(`User ${username} not found`)
+      };
+    }
     return {
-      success: false,
-      err: new Error("rest_id not found.")
+      success: true,
+      value: parseV2Profile(user.data)
     };
-  }
-  legacy.id_str = user.rest_id;
-  if (legacy.screen_name == null || legacy.screen_name.length === 0) {
+  } catch (error) {
     return {
       success: false,
-      err: new Error(`Either ${username} does not exist or is private.`)
+      err: new Error(error.message || "Failed to fetch profile")
     };
   }
-  return {
-    success: true,
-    value: parseProfile(user.legacy, user.is_blue_verified)
-  };
 }
 var idCache = /* @__PURE__ */ new Map();
 async function getScreenNameByUserId(userId, auth) {
-  const params = new URLSearchParams();
-  params.set(
-    "variables",
-    stringify({
-      userId,
-      withSafetyModeUserFields: true
-    }) ?? ""
-  );
-  params.set(
-    "features",
-    stringify({
-      hidden_profile_subscriptions_enabled: true,
-      rweb_tipjar_consumption_enabled: true,
-      responsive_web_graphql_exclude_directive_enabled: true,
-      verified_phone_label_enabled: false,
-      highlights_tweets_tab_ui_enabled: true,
-      responsive_web_twitter_article_notes_tab_enabled: true,
-      subscriptions_feature_can_gift_premium: false,
-      creator_subscriptions_tweet_preview_api_enabled: true,
-      responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
-      responsive_web_graphql_timeline_navigation_enabled: true
-    }) ?? ""
-  );
-  const res = await requestApi(
-    `https://twitter.com/i/api/graphql/xf3jd90KKBCUxdlI_tNHZw/UserByRestId?${params.toString()}`,
-    auth
-  );
-  if (!res.success) {
-    return res;
-  }
-  const { value } = res;
-  const { errors } = value;
-  if (errors != null && errors.length > 0) {
+  if (!auth) {
     return {
       success: false,
-      err: new Error(errors[0].message)
+      err: new Error("Not authenticated")
     };
   }
-  if (!value.data || !value.data.user || !value.data.user.result) {
+  try {
+    const client = auth.getV2Client();
+    const user = await client.v2.user(userId, {
+      "user.fields": ["username"]
+    });
+    if (!user.data || !user.data.username) {
+      return {
+        success: false,
+        err: new Error(`User with ID ${userId} not found`)
+      };
+    }
     return {
-      success: false,
-      err: new Error("User not found.")
+      success: true,
+      value: user.data.username
     };
-  }
-  const { result: user } = value.data.user;
-  const { legacy } = user;
-  if (legacy.screen_name == null || legacy.screen_name.length === 0) {
+  } catch (error) {
     return {
       success: false,
-      err: new Error(
-        `Either user with ID ${userId} does not exist or is private.`
-      )
+      err: new Error(error.message || "Failed to fetch user")
     };
   }
-  return {
-    success: true,
-    value: legacy.screen_name
-  };
 }
 async function getEntityIdByScreenName(screenName, auth) {
   const cached = idCache.get(screenName);
@@ -464,202 +254,215 @@ async function getEntityIdByScreenName(screenName, auth) {
 }
 
 // src/client/relationships.ts
-import stringify2 from "json-stable-stringify";
-
-// src/client/timeline-async.ts
-async function* getUserTimeline(query, maxProfiles, fetchFunc) {
-  let nProfiles = 0;
-  let cursor = void 0;
-  let consecutiveEmptyBatches = 0;
-  while (nProfiles < maxProfiles) {
-    const batch = await fetchFunc(
-      query,
-      maxProfiles,
-      cursor
-    );
-    const { profiles, next } = batch;
-    cursor = next;
-    if (profiles.length === 0) {
-      consecutiveEmptyBatches++;
-      if (consecutiveEmptyBatches > 5) break;
-    } else consecutiveEmptyBatches = 0;
-    for (const profile of profiles) {
-      if (nProfiles < maxProfiles) yield profile;
-      else break;
-      nProfiles++;
-    }
-    if (!next) break;
-  }
+import { Headers } from "headers-polyfill";
+function parseV2UserToProfile(user) {
+  return {
+    avatar: user.profile_image_url?.replace("_normal", ""),
+    biography: user.description,
+    followersCount: user.public_metrics?.followers_count,
+    followingCount: user.public_metrics?.following_count,
+    friendsCount: user.public_metrics?.following_count,
+    tweetsCount: user.public_metrics?.tweet_count,
+    isPrivate: user.protected ?? false,
+    isVerified: user.verified ?? false,
+    likesCount: user.public_metrics?.like_count,
+    listedCount: user.public_metrics?.listed_count,
+    location: user.location || "",
+    name: user.name,
+    pinnedTweetIds: user.pinned_tweet_id ? [user.pinned_tweet_id] : [],
+    url: `https://twitter.com/${user.username}`,
+    userId: user.id,
+    username: user.username,
+    isBlueVerified: user.verified_type === "blue",
+    joined: user.created_at ? new Date(user.created_at) : void 0,
+    website: user.entities?.url?.urls?.[0]?.expanded_url
+  };
 }
-async function* getTweetTimeline(query, maxTweets, fetchFunc) {
-  let nTweets = 0;
-  let cursor = void 0;
-  while (nTweets < maxTweets) {
-    const batch = await fetchFunc(
-      query,
-      maxTweets,
-      cursor
-    );
-    const { tweets, next } = batch;
-    if (tweets.length === 0) {
-      break;
-    }
-    for (const tweet of tweets) {
-      if (nTweets < maxTweets) {
-        cursor = next;
-        yield tweet;
-      } else {
+async function* getFollowing(userId, maxProfiles, auth) {
+  if (!auth) {
+    throw new Error("Not authenticated");
+  }
+  const client = auth.getV2Client();
+  let count = 0;
+  let paginationToken;
+  try {
+    while (count < maxProfiles) {
+      const response = await client.v2.following(userId, {
+        max_results: Math.min(maxProfiles - count, 100),
+        pagination_token: paginationToken,
+        "user.fields": [
+          "id",
+          "name",
+          "username",
+          "created_at",
+          "description",
+          "entities",
+          "location",
+          "pinned_tweet_id",
+          "profile_image_url",
+          "protected",
+          "public_metrics",
+          "url",
+          "verified",
+          "verified_type"
+        ]
+      });
+      if (!response.data || response.data.length === 0) {
         break;
       }
-      nTweets++;
+      for (const user of response.data) {
+        if (count >= maxProfiles) break;
+        yield parseV2UserToProfile(user);
+        count++;
+      }
+      paginationToken = response.meta?.next_token;
+      if (!paginationToken) break;
     }
+  } catch (error) {
+    console.error("Error fetching following:", error);
+    throw error;
   }
 }
-
-// src/client/timeline-relationship.ts
-function parseRelationshipTimeline(timeline) {
-  let bottomCursor;
-  let topCursor;
-  const profiles = [];
-  const instructions = timeline.data?.user?.result?.timeline?.timeline?.instructions ?? [];
-  for (const instruction of instructions) {
-    if (instruction.type === "TimelineAddEntries" || instruction.type === "TimelineReplaceEntry") {
-      if (instruction.entry?.content?.cursorType === "Bottom") {
-        bottomCursor = instruction.entry.content.value;
-        continue;
-      }
-      if (instruction.entry?.content?.cursorType === "Top") {
-        topCursor = instruction.entry.content.value;
-        continue;
+async function* getFollowers(userId, maxProfiles, auth) {
+  if (!auth) {
+    throw new Error("Not authenticated");
+  }
+  const client = auth.getV2Client();
+  let count = 0;
+  let paginationToken;
+  try {
+    while (count < maxProfiles) {
+      const response = await client.v2.followers(userId, {
+        max_results: Math.min(maxProfiles - count, 100),
+        pagination_token: paginationToken,
+        "user.fields": [
+          "id",
+          "name",
+          "username",
+          "created_at",
+          "description",
+          "entities",
+          "location",
+          "pinned_tweet_id",
+          "profile_image_url",
+          "protected",
+          "public_metrics",
+          "url",
+          "verified",
+          "verified_type"
+        ]
+      });
+      if (!response.data || response.data.length === 0) {
+        break;
       }
-      const entries = instruction.entries ?? [];
-      for (const entry of entries) {
-        const itemContent = entry.content?.itemContent;
-        if (itemContent?.userDisplayType === "User") {
-          const userResultRaw = itemContent.user_results?.result;
-          if (userResultRaw?.legacy) {
-            const profile = parseProfile(
-              userResultRaw.legacy,
-              userResultRaw.is_blue_verified
-            );
-            if (!profile.userId) {
-              profile.userId = userResultRaw.rest_id;
-            }
-            profiles.push(profile);
-          }
-        } else if (entry.content?.cursorType === "Bottom") {
-          bottomCursor = entry.content.value;
-        } else if (entry.content?.cursorType === "Top") {
-          topCursor = entry.content.value;
-        }
+      for (const user of response.data) {
+        if (count >= maxProfiles) break;
+        yield parseV2UserToProfile(user);
+        count++;
       }
+      paginationToken = response.meta?.next_token;
+      if (!paginationToken) break;
     }
+  } catch (error) {
+    console.error("Error fetching followers:", error);
+    throw error;
   }
-  return { profiles, next: bottomCursor, previous: topCursor };
-}
-
-// src/client/relationships.ts
-function getFollowing(userId, maxProfiles, auth) {
-  return getUserTimeline(userId, maxProfiles, (q, mt, c) => {
-    return fetchProfileFollowing(q, mt, auth, c);
-  });
-}
-function getFollowers(userId, maxProfiles, auth) {
-  return getUserTimeline(userId, maxProfiles, (q, mt, c) => {
-    return fetchProfileFollowers(q, mt, auth, c);
-  });
 }
 async function fetchProfileFollowing(userId, maxProfiles, auth, cursor) {
-  const timeline = await getFollowingTimeline(
-    userId,
-    maxProfiles,
-    auth,
-    cursor
-  );
-  return parseRelationshipTimeline(timeline);
-}
-async function fetchProfileFollowers(userId, maxProfiles, auth, cursor) {
-  const timeline = await getFollowersTimeline(
-    userId,
-    maxProfiles,
-    auth,
-    cursor
-  );
-  return parseRelationshipTimeline(timeline);
-}
-async function getFollowingTimeline(userId, maxItems, auth, cursor) {
-  if (!auth.isLoggedIn()) {
-    throw new Error("Client is not logged-in for profile following.");
-  }
-  if (maxItems > 50) {
-    maxItems = 50;
+  if (!auth) {
+    throw new Error("Not authenticated");
   }
-  const variables = {
-    userId,
-    count: maxItems,
-    includePromotedContent: false
-  };
-  const features2 = addApiFeatures({
-    responsive_web_twitter_article_tweet_consumption_enabled: false,
-    tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
-    longform_notetweets_inline_media_enabled: true,
-    responsive_web_media_download_video_enabled: false
-  });
-  if (cursor != null && cursor !== "") {
-    variables.cursor = cursor;
-  }
-  const params = new URLSearchParams();
-  params.set("features", stringify2(features2) ?? "");
-  params.set("variables", stringify2(variables) ?? "");
-  const res = await requestApi(
-    `https://twitter.com/i/api/graphql/iSicc7LrzWGBgDPL0tM_TQ/Following?${params.toString()}`,
-    auth
-  );
-  if (!res.success) {
-    throw res.err;
+  const client = auth.getV2Client();
+  try {
+    const response = await client.v2.following(userId, {
+      max_results: Math.min(maxProfiles, 100),
+      pagination_token: cursor,
+      "user.fields": [
+        "id",
+        "name",
+        "username",
+        "created_at",
+        "description",
+        "entities",
+        "location",
+        "pinned_tweet_id",
+        "profile_image_url",
+        "protected",
+        "public_metrics",
+        "url",
+        "verified",
+        "verified_type"
+      ]
+    });
+    const profiles = response.data?.map(parseV2UserToProfile) || [];
+    return {
+      profiles,
+      next: response.meta?.next_token
+    };
+  } catch (error) {
+    console.error("Error fetching following profiles:", error);
+    throw error;
   }
-  return res.value;
 }
-async function getFollowersTimeline(userId, maxItems, auth, cursor) {
-  if (!auth.isLoggedIn()) {
-    throw new Error("Client is not logged-in for profile followers.");
-  }
-  if (maxItems > 50) {
-    maxItems = 50;
+async function fetchProfileFollowers(userId, maxProfiles, auth, cursor) {
+  if (!auth) {
+    throw new Error("Not authenticated");
   }
-  const variables = {
-    userId,
-    count: maxItems,
-    includePromotedContent: false
-  };
-  const features2 = addApiFeatures({
-    responsive_web_twitter_article_tweet_consumption_enabled: false,
-    tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
-    longform_notetweets_inline_media_enabled: true,
-    responsive_web_media_download_video_enabled: false
-  });
-  if (cursor != null && cursor !== "") {
-    variables.cursor = cursor;
-  }
-  const params = new URLSearchParams();
-  params.set("features", stringify2(features2) ?? "");
-  params.set("variables", stringify2(variables) ?? "");
-  const res = await requestApi(
-    `https://twitter.com/i/api/graphql/rRXFSG5vR6drKr5M37YOTw/Followers?${params.toString()}`,
-    auth
-  );
-  if (!res.success) {
-    throw res.err;
+  const client = auth.getV2Client();
+  try {
+    const response = await client.v2.followers(userId, {
+      max_results: Math.min(maxProfiles, 100),
+      pagination_token: cursor,
+      "user.fields": [
+        "id",
+        "name",
+        "username",
+        "created_at",
+        "description",
+        "entities",
+        "location",
+        "pinned_tweet_id",
+        "profile_image_url",
+        "protected",
+        "public_metrics",
+        "url",
+        "verified",
+        "verified_type"
+      ]
+    });
+    const profiles = response.data?.map(parseV2UserToProfile) || [];
+    return {
+      profiles,
+      next: response.meta?.next_token
+    };
+  } catch (error) {
+    console.error("Error fetching follower profiles:", error);
+    throw error;
   }
-  return res.value;
 }
 async function followUser(username, auth) {
-  console.warn(
-    "Follow user functionality is not supported in Twitter API v2 client"
-  );
-  throw new Error(
-    "Follow user functionality not implemented for Twitter API v2"
-  );
+  if (!auth) {
+    throw new Error("Not authenticated");
+  }
+  const client = auth.getV2Client();
+  try {
+    const userResponse = await client.v2.userByUsername(username);
+    if (!userResponse.data) {
+      throw new Error(`User ${username} not found`);
+    }
+    const meResponse = await client.v2.me();
+    if (!meResponse.data) {
+      throw new Error("Failed to get authenticated user");
+    }
+    const result = await client.v2.follow(meResponse.data.id, userResponse.data.id);
+    return new Response(JSON.stringify(result), {
+      status: result.data?.following ? 200 : 400,
+      headers: new Headers({ "Content-Type": "application/json" })
+    });
+  } catch (error) {
+    console.error("Error following user:", error);
+    throw error;
+  }
 }
 
 // src/client/search.ts
@@ -795,449 +598,6 @@ async function* searchQuotedTweets(quotedTweetId, maxTweets, auth) {
   const query = `url:"twitter.com/*/status/${quotedTweetId}"`;
   yield* searchTweets(query, maxTweets, 1 /* Latest */, auth);
 }
-var fetchSearchTweets = async (query, maxTweets, searchMode, auth, cursor) => {
-  throw new Error(
-    "fetchSearchTweets is deprecated. Use searchTweets generator instead."
-  );
-};
-var fetchSearchProfiles = async (query, maxProfiles, auth, cursor) => {
-  throw new Error(
-    "fetchSearchProfiles is deprecated. Use searchProfiles generator instead."
-  );
-};
-
-// src/client/timeline-following.ts
-async function fetchFollowingTimeline(count, seenTweetIds, auth) {
-  const variables = {
-    count,
-    includePromotedContent: true,
-    latestControlAvailable: true,
-    requestContext: "launch",
-    seenTweetIds
-  };
-  const features2 = {
-    profile_label_improvements_pcf_label_in_post_enabled: true,
-    rweb_tipjar_consumption_enabled: true,
-    responsive_web_graphql_exclude_directive_enabled: true,
-    verified_phone_label_enabled: false,
-    creator_subscriptions_tweet_preview_api_enabled: true,
-    responsive_web_graphql_timeline_navigation_enabled: true,
-    responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
-    communities_web_enable_tweet_community_results_fetch: true,
-    c9s_tweet_anatomy_moderator_badge_enabled: true,
-    articles_preview_enabled: true,
-    responsive_web_edit_tweet_api_enabled: true,
-    graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
-    view_counts_everywhere_api_enabled: true,
-    longform_notetweets_consumption_enabled: true,
-    responsive_web_twitter_article_tweet_consumption_enabled: true,
-    tweet_awards_web_tipping_enabled: false,
-    creator_subscriptions_quote_tweet_preview_enabled: false,
-    freedom_of_speech_not_reach_fetch_enabled: true,
-    standardized_nudges_misinfo: true,
-    tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
-    rweb_video_timestamps_enabled: true,
-    longform_notetweets_rich_text_read_enabled: true,
-    longform_notetweets_inline_media_enabled: true,
-    responsive_web_enhance_cards_enabled: false
-  };
-  const res = await requestApi(
-    `https://x.com/i/api/graphql/K0X1xbCZUjttdK8RazKAlw/HomeLatestTimeline?variables=${encodeURIComponent(
-      JSON.stringify(variables)
-    )}&features=${encodeURIComponent(JSON.stringify(features2))}`,
-    auth,
-    "GET"
-  );
-  if (!res.success) {
-    if (res.err instanceof ApiError) {
-      console.error("Error details:", res.err.data);
-    }
-    throw res.err;
-  }
-  const home = res.value?.data?.home.home_timeline_urt?.instructions;
-  if (!home) {
-    return [];
-  }
-  const entries = [];
-  for (const instruction of home) {
-    if (instruction.type === "TimelineAddEntries") {
-      for (const entry of instruction.entries ?? []) {
-        entries.push(entry);
-      }
-    }
-  }
-  const tweets = entries.map((entry) => entry.content.itemContent?.tweet_results?.result).filter((tweet) => tweet !== void 0);
-  return tweets;
-}
-
-// src/client/timeline-home.ts
-async function fetchHomeTimeline(count, seenTweetIds, auth) {
-  const variables = {
-    count,
-    includePromotedContent: true,
-    latestControlAvailable: true,
-    requestContext: "launch",
-    withCommunity: true,
-    seenTweetIds
-  };
-  const features2 = {
-    rweb_tipjar_consumption_enabled: true,
-    responsive_web_graphql_exclude_directive_enabled: true,
-    verified_phone_label_enabled: false,
-    creator_subscriptions_tweet_preview_api_enabled: true,
-    responsive_web_graphql_timeline_navigation_enabled: true,
-    responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
-    communities_web_enable_tweet_community_results_fetch: true,
-    c9s_tweet_anatomy_moderator_badge_enabled: true,
-    articles_preview_enabled: true,
-    responsive_web_edit_tweet_api_enabled: true,
-    graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
-    view_counts_everywhere_api_enabled: true,
-    longform_notetweets_consumption_enabled: true,
-    responsive_web_twitter_article_tweet_consumption_enabled: true,
-    tweet_awards_web_tipping_enabled: false,
-    creator_subscriptions_quote_tweet_preview_enabled: false,
-    freedom_of_speech_not_reach_fetch_enabled: true,
-    standardized_nudges_misinfo: true,
-    tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
-    rweb_video_timestamps_enabled: true,
-    longform_notetweets_rich_text_read_enabled: true,
-    longform_notetweets_inline_media_enabled: true,
-    responsive_web_enhance_cards_enabled: false
-  };
-  const res = await requestApi(
-    `https://x.com/i/api/graphql/HJFjzBgCs16TqxewQOeLNg/HomeTimeline?variables=${encodeURIComponent(
-      JSON.stringify(variables)
-    )}&features=${encodeURIComponent(JSON.stringify(features2))}`,
-    auth,
-    "GET"
-  );
-  if (!res.success) {
-    if (res.err instanceof ApiError) {
-      console.error("Error details:", res.err.data);
-    }
-    throw res.err;
-  }
-  const home = res.value?.data?.home.home_timeline_urt?.instructions;
-  if (!home) {
-    return [];
-  }
-  const entries = [];
-  for (const instruction of home) {
-    if (instruction.type === "TimelineAddEntries") {
-      for (const entry of instruction.entries ?? []) {
-        entries.push(entry);
-      }
-    }
-  }
-  const tweets = entries.map((entry) => entry.content.itemContent?.tweet_results?.result).filter((tweet) => tweet !== void 0);
-  return tweets;
-}
-
-// src/client/type-util.ts
-function isFieldDefined(key) {
-  return (value) => isDefined(value[key]);
-}
-function isDefined(value) {
-  return value != null;
-}
-
-// src/client/timeline-tweet-util.ts
-var reHashtag = /\B(\#\S+\b)/g;
-var reCashtag = /\B(\$\S+\b)/g;
-var reTwitterUrl = /https:(\/\/t\.co\/([A-Za-z0-9]|[A-Za-z]){10})/g;
-var reUsername = /\B(\@\S{1,15}\b)/g;
-function parseMediaGroups(media) {
-  const photos = [];
-  const videos = [];
-  let sensitiveContent = void 0;
-  for (const m of media.filter(isFieldDefined("id_str")).filter(isFieldDefined("media_url_https"))) {
-    if (m.type === "photo") {
-      photos.push({
-        id: m.id_str,
-        url: m.media_url_https,
-        alt_text: m.ext_alt_text
-      });
-    } else if (m.type === "video") {
-      videos.push(parseVideo(m));
-    }
-    const sensitive = m.ext_sensitive_media_warning;
-    if (sensitive != null) {
-      sensitiveContent = sensitive.adult_content || sensitive.graphic_violence || sensitive.other;
-    }
-  }
-  return { sensitiveContent, photos, videos };
-}
-function parseVideo(m) {
-  const video = {
-    id: m.id_str,
-    preview: m.media_url_https
-  };
-  let maxBitrate = 0;
-  const variants = m.video_info?.variants ?? [];
-  for (const variant of variants) {
-    const bitrate = variant.bitrate;
-    if (bitrate != null && bitrate > maxBitrate && variant.url != null) {
-      let variantUrl = variant.url;
-      const stringStart = 0;
-      const tagSuffixIdx = variantUrl.indexOf("?tag=10");
-      if (tagSuffixIdx !== -1) {
-        variantUrl = variantUrl.substring(stringStart, tagSuffixIdx + 1);
-      }
-      video.url = variantUrl;
-      maxBitrate = bitrate;
-    }
-  }
-  return video;
-}
-function reconstructTweetHtml(tweet, photos, videos) {
-  const media = [];
-  let html = tweet.full_text ?? "";
-  html = html.replace(reHashtag, linkHashtagHtml);
-  html = html.replace(reCashtag, linkCashtagHtml);
-  html = html.replace(reUsername, linkUsernameHtml);
-  html = html.replace(reTwitterUrl, unwrapTcoUrlHtml(tweet, media));
-  for (const { url } of photos) {
-    if (media.indexOf(url) !== -1) {
-      continue;
-    }
-    html += `<br><img src="${url}"/>`;
-  }
-  for (const { preview: url } of videos) {
-    if (media.indexOf(url) !== -1) {
-      continue;
-    }
-    html += `<br><img src="${url}"/>`;
-  }
-  html = html.replace(/\n/g, "<br>");
-  return html;
-}
-function linkHashtagHtml(hashtag) {
-  return `<a href="https://twitter.com/hashtag/${hashtag.replace("#", "")}">${hashtag}</a>`;
-}
-function linkCashtagHtml(cashtag) {
-  return `<a href="https://twitter.com/search?q=%24${cashtag.replace("$", "")}">${cashtag}</a>`;
-}
-function linkUsernameHtml(username) {
-  return `<a href="https://twitter.com/${username.replace("@", "")}">${username}</a>`;
-}
-function unwrapTcoUrlHtml(tweet, foundedMedia) {
-  return (tco) => {
-    for (const entity of tweet.entities?.urls ?? []) {
-      if (tco === entity.url && entity.expanded_url != null) {
-        return `<a href="${entity.expanded_url}">${tco}</a>`;
-      }
-    }
-    for (const entity of tweet.extended_entities?.media ?? []) {
-      if (tco === entity.url && entity.media_url_https != null) {
-        foundedMedia.push(entity.media_url_https);
-        return `<br><a href="${tco}"><img src="${entity.media_url_https}"/></a>`;
-      }
-    }
-    return tco;
-  };
-}
-
-// src/client/timeline-v2.ts
-function parseLegacyTweet(user, tweet) {
-  if (tweet == null) {
-    return {
-      success: false,
-      err: new Error("Tweet was not found in the timeline object.")
-    };
-  }
-  if (user == null) {
-    return {
-      success: false,
-      err: new Error("User was not found in the timeline object.")
-    };
-  }
-  if (!tweet.id_str) {
-    if (!tweet.conversation_id_str) {
-      return {
-        success: false,
-        err: new Error("Tweet ID was not found in object.")
-      };
-    }
-    tweet.id_str = tweet.conversation_id_str;
-  }
-  const hashtags = tweet.entities?.hashtags ?? [];
-  const mentions = tweet.entities?.user_mentions ?? [];
-  const media = tweet.extended_entities?.media ?? [];
-  const pinnedTweets = new Set(
-    user.pinned_tweet_ids_str ?? []
-  );
-  const urls = tweet.entities?.urls ?? [];
-  const { photos, videos, sensitiveContent } = parseMediaGroups(media);
-  const tw = {
-    bookmarkCount: tweet.bookmark_count,
-    conversationId: tweet.conversation_id_str,
-    id: tweet.id_str,
-    hashtags: hashtags.filter(isFieldDefined("text")).map((hashtag) => hashtag.text),
-    likes: tweet.favorite_count,
-    mentions: mentions.filter(isFieldDefined("id_str")).map((mention) => ({
-      id: mention.id_str,
-      username: mention.screen_name,
-      name: mention.name
-    })),
-    name: user.name,
-    permanentUrl: `https://twitter.com/${user.screen_name}/status/${tweet.id_str}`,
-    photos,
-    replies: tweet.reply_count,
-    retweets: tweet.retweet_count,
-    text: tweet.full_text,
-    thread: [],
-    urls: urls.filter(isFieldDefined("expanded_url")).map((url) => url.expanded_url),
-    userId: tweet.user_id_str,
-    username: user.screen_name,
-    videos,
-    isQuoted: false,
-    isReply: false,
-    isRetweet: false,
-    isPin: false,
-    sensitiveContent: false
-  };
-  if (tweet.created_at) {
-    tw.timeParsed = new Date(Date.parse(tweet.created_at));
-    tw.timestamp = Math.floor(tw.timeParsed.valueOf() / 1e3);
-  }
-  if (tweet.place?.id) {
-    tw.place = tweet.place;
-  }
-  const quotedStatusIdStr = tweet.quoted_status_id_str;
-  const inReplyToStatusIdStr = tweet.in_reply_to_status_id_str;
-  const retweetedStatusIdStr = tweet.retweeted_status_id_str;
-  const retweetedStatusResult = tweet.retweeted_status_result?.result;
-  if (quotedStatusIdStr) {
-    tw.isQuoted = true;
-    tw.quotedStatusId = quotedStatusIdStr;
-  }
-  if (inReplyToStatusIdStr) {
-    tw.isReply = true;
-    tw.inReplyToStatusId = inReplyToStatusIdStr;
-  }
-  if (retweetedStatusIdStr || retweetedStatusResult) {
-    tw.isRetweet = true;
-    tw.retweetedStatusId = retweetedStatusIdStr;
-    if (retweetedStatusResult) {
-      const parsedResult = parseLegacyTweet(
-        retweetedStatusResult?.core?.user_results?.result?.legacy,
-        retweetedStatusResult?.legacy
-      );
-      if (parsedResult.success) {
-        tw.retweetedStatus = parsedResult.tweet;
-      }
-    }
-  }
-  const views = Number.parseInt(tweet.ext_views?.count ?? "");
-  if (!Number.isNaN(views)) {
-    tw.views = views;
-  }
-  if (pinnedTweets.has(tweet.id_str)) {
-    tw.isPin = true;
-  }
-  if (sensitiveContent) {
-    tw.sensitiveContent = true;
-  }
-  tw.html = reconstructTweetHtml(tweet, tw.photos, tw.videos);
-  return { success: true, tweet: tw };
-}
-function parseResult(result) {
-  const noteTweetResultText = result?.note_tweet?.note_tweet_results?.result?.text;
-  if (result?.legacy && noteTweetResultText) {
-    result.legacy.full_text = noteTweetResultText;
-  }
-  const tweetResult = parseLegacyTweet(
-    result?.core?.user_results?.result?.legacy,
-    result?.legacy
-  );
-  if (!tweetResult.success) {
-    return tweetResult;
-  }
-  if (!tweetResult.tweet.views && result?.views?.count) {
-    const views = Number.parseInt(result.views.count);
-    if (!Number.isNaN(views)) {
-      tweetResult.tweet.views = views;
-    }
-  }
-  const quotedResult = result?.quoted_status_result?.result;
-  if (quotedResult) {
-    if (quotedResult.legacy && quotedResult.rest_id) {
-      quotedResult.legacy.id_str = quotedResult.rest_id;
-    }
-    const quotedTweetResult = parseResult(quotedResult);
-    if (quotedTweetResult.success) {
-      tweetResult.tweet.quotedStatus = quotedTweetResult.tweet;
-    }
-  }
-  return tweetResult;
-}
-var expectedEntryTypes = ["tweet", "profile-conversation"];
-function parseTimelineTweetsV2(timeline) {
-  let bottomCursor;
-  let topCursor;
-  const tweets = [];
-  const instructions = timeline.data?.user?.result?.timeline_v2?.timeline?.instructions ?? [];
-  for (const instruction of instructions) {
-    const entries = instruction.entries ?? [];
-    for (const entry of entries) {
-      const entryContent = entry.content;
-      if (!entryContent) continue;
-      if (entryContent.cursorType === "Bottom") {
-        bottomCursor = entryContent.value;
-        continue;
-      }
-      if (entryContent.cursorType === "Top") {
-        topCursor = entryContent.value;
-        continue;
-      }
-      const idStr = entry.entryId;
-      if (!expectedEntryTypes.some((entryType) => idStr.startsWith(entryType))) {
-        continue;
-      }
-      if (entryContent.itemContent) {
-        parseAndPush(tweets, entryContent.itemContent, idStr);
-      } else if (entryContent.items) {
-        for (const item of entryContent.items) {
-          if (item.item?.itemContent) {
-            parseAndPush(tweets, item.item.itemContent, idStr);
-          }
-        }
-      }
-    }
-  }
-  return { tweets, next: bottomCursor, previous: topCursor };
-}
-function parseTimelineEntryItemContentRaw(content, entryId, isConversation = false) {
-  let result = content.tweet_results?.result ?? content.tweetResult?.result;
-  if (result?.__typename === "Tweet" || result?.__typename === "TweetWithVisibilityResults" && result?.tweet) {
-    if (result?.__typename === "TweetWithVisibilityResults")
-      result = result.tweet;
-    if (result?.legacy) {
-      result.legacy.id_str = result.rest_id ?? entryId.replace("conversation-", "").replace("tweet-", "");
-    }
-    const tweetResult = parseResult(result);
-    if (tweetResult.success) {
-      if (isConversation) {
-        if (content?.tweetDisplayType === "SelfThread") {
-          tweetResult.tweet.isSelfThread = true;
-        }
-      }
-      return tweetResult.tweet;
-    }
-  }
-  return null;
-}
-function parseAndPush(tweets, content, entryId, isConversation = false) {
-  const tweet = parseTimelineEntryItemContentRaw(
-    content,
-    entryId,
-    isConversation
-  );
-  if (tweet) {
-    tweets.push(tweet);
-  }
-}
 
 // src/client/tweets.ts
 var defaultOptions = {
@@ -1318,13 +678,6 @@ var defaultOptions = {
     "place_type"
   ]
 };
-var features = addApiFeatures({
-  interactive_text_enabled: true,
-  longform_notetweets_inline_media_enabled: false,
-  responsive_web_text_conversations_enabled: false,
-  tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: false,
-  vibe_api_enabled: false
-});
 async function fetchTweets(userId, maxTweets, cursor, auth) {
   const client = auth.getV2Client();
   try {
@@ -1360,7 +713,7 @@ async function fetchTweets(userId, maxTweets, cursor, auth) {
       next: response.meta.next_token
     };
   } catch (error) {
-    throw new Error(`Failed to fetch tweets: ${error.message}`);
+    throw new Error(`Failed to fetch tweets: ${error?.message || error}`);
   }
 }
 async function fetchTweetsAndReplies(userId, maxTweets, cursor, auth) {
@@ -1397,7 +750,7 @@ async function fetchTweetsAndReplies(userId, maxTweets, cursor, auth) {
       next: response.meta.next_token
     };
   } catch (error) {
-    throw new Error(`Failed to fetch tweets and replies: ${error.message}`);
+    throw new Error(`Failed to fetch tweets and replies: ${error?.message || error}`);
   }
 }
 async function createCreateTweetRequestV2(text, auth, tweetId, options) {
@@ -1442,45 +795,50 @@ async function createCreateTweetRequestV2(text, auth, tweetId, options) {
   }
   return await getTweetV2(tweetResponse.data.id, auth, optionsConfig);
 }
-function parseTweetV2ToV1(tweetV2, includes, defaultTweetData) {
-  let parsedTweet;
-  if (defaultTweetData != null) {
-    parsedTweet = defaultTweetData;
-  }
-  parsedTweet = {
+function parseTweetV2ToV1(tweetV2, includes) {
+  const parsedTweet = {
     id: tweetV2.id,
-    text: tweetV2.text ?? defaultTweetData?.text ?? "",
-    hashtags: tweetV2.entities?.hashtags?.map((tag) => tag.tag) ?? defaultTweetData?.hashtags ?? [],
+    text: tweetV2.text ?? "",
+    hashtags: tweetV2.entities?.hashtags?.map((tag) => tag.tag) ?? [],
     mentions: tweetV2.entities?.mentions?.map((mention) => ({
       id: mention.id,
       username: mention.username
-    })) ?? defaultTweetData?.mentions ?? [],
-    urls: tweetV2.entities?.urls?.map((url) => url.url) ?? defaultTweetData?.urls ?? [],
-    likes: tweetV2.public_metrics?.like_count ?? defaultTweetData?.likes ?? 0,
-    retweets: tweetV2.public_metrics?.retweet_count ?? defaultTweetData?.retweets ?? 0,
-    replies: tweetV2.public_metrics?.reply_count ?? defaultTweetData?.replies ?? 0,
-    views: tweetV2.public_metrics?.impression_count ?? defaultTweetData?.views ?? 0,
-    userId: tweetV2.author_id ?? defaultTweetData?.userId,
-    conversationId: tweetV2.conversation_id ?? defaultTweetData?.conversationId,
-    photos: defaultTweetData?.photos ?? [],
-    videos: defaultTweetData?.videos ?? [],
-    poll: defaultTweetData?.poll ?? null,
-    username: defaultTweetData?.username ?? "",
-    name: defaultTweetData?.name ?? "",
-    place: defaultTweetData?.place,
-    thread: defaultTweetData?.thread ?? []
+    })) ?? [],
+    urls: tweetV2.entities?.urls?.map((url) => url.url) ?? [],
+    likes: tweetV2.public_metrics?.like_count ?? 0,
+    retweets: tweetV2.public_metrics?.retweet_count ?? 0,
+    replies: tweetV2.public_metrics?.reply_count ?? 0,
+    quotes: tweetV2.public_metrics?.quote_count ?? 0,
+    views: tweetV2.public_metrics?.impression_count ?? 0,
+    userId: tweetV2.author_id,
+    conversationId: tweetV2.conversation_id,
+    photos: [],
+    videos: [],
+    poll: null,
+    username: "",
+    name: "",
+    thread: [],
+    timestamp: tweetV2.created_at ? new Date(tweetV2.created_at).getTime() / 1e3 : Date.now() / 1e3,
+    permanentUrl: `https://twitter.com/i/status/${tweetV2.id}`,
+    // Check for referenced tweets
+    isReply: tweetV2.referenced_tweets?.some((ref) => ref.type === "replied_to") ?? false,
+    isRetweet: tweetV2.referenced_tweets?.some((ref) => ref.type === "retweeted") ?? false,
+    isQuoted: tweetV2.referenced_tweets?.some((ref) => ref.type === "quoted") ?? false,
+    inReplyToStatusId: tweetV2.referenced_tweets?.find((ref) => ref.type === "replied_to")?.id,
+    quotedStatusId: tweetV2.referenced_tweets?.find((ref) => ref.type === "quoted")?.id,
+    retweetedStatusId: tweetV2.referenced_tweets?.find((ref) => ref.type === "retweeted")?.id
   };
   if (includes?.polls?.length) {
     const poll = includes.polls[0];
     parsedTweet.poll = {
       id: poll.id,
-      end_datetime: poll.end_datetime ? poll.end_datetime : defaultTweetData?.poll?.end_datetime ? defaultTweetData?.poll?.end_datetime : void 0,
+      end_datetime: poll.end_datetime,
       options: poll.options.map((option) => ({
         position: option.position,
         label: option.label,
         votes: option.votes
       })),
-      voting_status: poll.voting_status ?? defaultTweetData?.poll?.voting_status
+      voting_status: poll.voting_status
     };
   }
   if (includes?.media?.length) {
@@ -1507,8 +865,8 @@ function parseTweetV2ToV1(tweetV2, includes, defaultTweetData) {
       (user2) => user2.id === tweetV2.author_id
     );
     if (user) {
-      parsedTweet.username = user.username ?? defaultTweetData?.username ?? "";
-      parsedTweet.name = user.name ?? defaultTweetData?.name ?? "";
+      parsedTweet.username = user.username ?? "";
+      parsedTweet.name = user.name ?? "";
     }
   }
   if (tweetV2?.geo?.place_id && includes?.places?.length) {
@@ -1518,11 +876,11 @@ function parseTweetV2ToV1(tweetV2, includes, defaultTweetData) {
     if (place) {
       parsedTweet.place = {
         id: place.id,
-        full_name: place.full_name ?? defaultTweetData?.place?.full_name ?? "",
-        country: place.country ?? defaultTweetData?.place?.country ?? "",
-        country_code: place.country_code ?? defaultTweetData?.place?.country_code ?? "",
-        name: place.name ?? defaultTweetData?.place?.name ?? "",
-        place_type: place.place_type ?? defaultTweetData?.place?.place_type
+        full_name: place.full_name ?? "",
+        country: place.country ?? "",
+        country_code: place.country_code ?? "",
+        name: place.name ?? "",
+        place_type: place.place_type
       };
     }
   }
@@ -1552,7 +910,7 @@ async function createCreateTweetRequest(text, auth, tweetId, mediaData, hideLink
       data: result
     };
   } catch (error) {
-    throw new Error(`Failed to create tweet: ${error.message}`);
+    throw new Error(`Failed to create tweet: ${error?.message || error}`);
   }
 }
 async function createCreateNoteTweetRequest(text, auth, tweetId, mediaData) {
@@ -1611,35 +969,71 @@ async function deleteTweet(tweetId, auth) {
     throw new Error(`Failed to delete tweet: ${error.message}`);
   }
 }
-function getTweets(user, maxTweets, auth) {
-  return getTweetTimeline(user, maxTweets, async (q, mt, c) => {
-    const userIdRes = await getEntityIdByScreenName(q, auth);
-    if (!userIdRes.success) {
-      throw userIdRes.err;
-    }
-    const { value: userId } = userIdRes;
-    return fetchTweets(userId, mt, c, auth);
-  });
+async function* getTweets(user, maxTweets, auth) {
+  const userIdRes = await getEntityIdByScreenName(user, auth);
+  if (!userIdRes.success) {
+    throw userIdRes.err;
+  }
+  const { value: userId } = userIdRes;
+  let cursor;
+  let totalFetched = 0;
+  while (totalFetched < maxTweets) {
+    const response = await fetchTweets(userId, maxTweets - totalFetched, cursor, auth);
+    for (const tweet of response.tweets) {
+      yield tweet;
+      totalFetched++;
+      if (totalFetched >= maxTweets) break;
+    }
+    cursor = response.next;
+    if (!cursor) break;
+  }
 }
-function getTweetsByUserId(userId, maxTweets, auth) {
-  return getTweetTimeline(userId, maxTweets, (q, mt, c) => {
-    return fetchTweets(q, mt, c, auth);
-  });
+async function* getTweetsByUserId(userId, maxTweets, auth) {
+  let cursor;
+  let totalFetched = 0;
+  while (totalFetched < maxTweets) {
+    const response = await fetchTweets(userId, maxTweets - totalFetched, cursor, auth);
+    for (const tweet of response.tweets) {
+      yield tweet;
+      totalFetched++;
+      if (totalFetched >= maxTweets) break;
+    }
+    cursor = response.next;
+    if (!cursor) break;
+  }
 }
-function getTweetsAndReplies(user, maxTweets, auth) {
-  return getTweetTimeline(user, maxTweets, async (q, mt, c) => {
-    const userIdRes = await getEntityIdByScreenName(q, auth);
-    if (!userIdRes.success) {
-      throw userIdRes.err;
-    }
-    const { value: userId } = userIdRes;
-    return fetchTweetsAndReplies(userId, mt, c, auth);
-  });
+async function* getTweetsAndReplies(user, maxTweets, auth) {
+  const userIdRes = await getEntityIdByScreenName(user, auth);
+  if (!userIdRes.success) {
+    throw userIdRes.err;
+  }
+  const { value: userId } = userIdRes;
+  let cursor;
+  let totalFetched = 0;
+  while (totalFetched < maxTweets) {
+    const response = await fetchTweetsAndReplies(userId, maxTweets - totalFetched, cursor, auth);
+    for (const tweet of response.tweets) {
+      yield tweet;
+      totalFetched++;
+      if (totalFetched >= maxTweets) break;
+    }
+    cursor = response.next;
+    if (!cursor) break;
+  }
 }
-function getTweetsAndRepliesByUserId(userId, maxTweets, auth) {
-  return getTweetTimeline(userId, maxTweets, (q, mt, c) => {
-    return fetchTweetsAndReplies(q, mt, c, auth);
-  });
+async function* getTweetsAndRepliesByUserId(userId, maxTweets, auth) {
+  let cursor;
+  let totalFetched = 0;
+  while (totalFetched < maxTweets) {
+    const response = await fetchTweetsAndReplies(userId, maxTweets - totalFetched, cursor, auth);
+    for (const tweet of response.tweets) {
+      yield tweet;
+      totalFetched++;
+      if (totalFetched >= maxTweets) break;
+    }
+    cursor = response.next;
+    if (!cursor) break;
+  }
 }
 async function getTweetWhere(tweets, query) {
   const isCallback = typeof query === "function";
@@ -1723,11 +1117,9 @@ async function getTweetV2(id, auth, options = defaultOptions) {
       console.warn(`Tweet data not found for ID: ${id}`);
       return null;
     }
-    const defaultTweetData = await getTweet(tweetData.data.id, auth);
     const parsedTweet = parseTweetV2ToV1(
       tweetData.data,
-      tweetData?.includes,
-      defaultTweetData
+      tweetData?.includes
     );
     return parsedTweet;
   } catch (error) {
@@ -1817,19 +1209,6 @@ async function retweet(tweetId, auth) {
 async function createCreateLongTweetRequest(text, auth, tweetId, mediaData) {
   return createCreateTweetRequest(text, auth, tweetId, mediaData);
 }
-async function getArticle(id, auth) {
-  const tweet = await getTweet(id, auth);
-  if (!tweet) {
-    return null;
-  }
-  return {
-    id: tweet.id || id,
-    articleId: id,
-    title: "",
-    previewText: tweet.text?.substring(0, 100) || "",
-    text: tweet.text || ""
-  };
-}
 async function fetchRetweetersPage(tweetId, auth, cursor, count = 40) {
   console.warn("Fetching retweeters not implemented for Twitter API v2");
   return {
@@ -1859,7 +1238,6 @@ async function getAllRetweeters(tweetId, auth) {
 }
 
 // src/client/client.ts
-var UserTweetsUrl = "https://twitter.com/i/api/graphql/E3opETHurmVJflFsUBVuUQ/UserTweets";
 var Client = class {
   /**
    * Creates a new Client object.
@@ -1924,8 +1302,17 @@ var Client = class {
    * @param cursor The search cursor, which can be passed into further requests for more results.
    * @returns A page of results, containing a cursor that can be used in further requests.
    */
-  fetchSearchTweets(query, maxTweets, searchMode, cursor) {
-    return fetchSearchTweets(query, maxTweets, searchMode, this.auth, cursor);
+  async fetchSearchTweets(query, maxTweets, searchMode, cursor) {
+    const tweets = [];
+    const generator = searchTweets(query, maxTweets, searchMode, this.auth);
+    for await (const tweet of generator) {
+      tweets.push(tweet);
+    }
+    return {
+      tweets,
+      // v2 API doesn't provide cursor-based pagination for search
+      next: void 0
+    };
   }
   /**
    * Fetches profiles from Twitter.
@@ -1934,8 +1321,17 @@ var Client = class {
    * @param cursor The search cursor, which can be passed into further requests for more results.
    * @returns A page of results, containing a cursor that can be used in further requests.
    */
-  fetchSearchProfiles(query, maxProfiles, cursor) {
-    return fetchSearchProfiles(query, maxProfiles, this.auth, cursor);
+  async fetchSearchProfiles(query, maxProfiles, cursor) {
+    const profiles = [];
+    const generator = searchProfiles(query, maxProfiles, this.auth);
+    for await (const profile of generator) {
+      profiles.push(profile);
+    }
+    return {
+      profiles,
+      // v2 API doesn't provide cursor-based pagination for search
+      next: void 0
+    };
   }
   /**
    * Fetches list tweets from Twitter.
@@ -1986,82 +1382,101 @@ var Client = class {
     return fetchProfileFollowers(userId, maxProfiles, this.auth, cursor);
   }
   /**
-   * Fetches the home timeline for the current user. (for you feed)
+   * Fetches the home timeline for the current user using Twitter API v2.
+   * Note: Twitter API v2 doesn't distinguish between "For You" and "Following" feeds.
    * @param count The number of tweets to fetch.
-   * @param seenTweetIds An array of tweet IDs that have already been seen.
-   * @returns A promise that resolves to the home timeline response.
+   * @param seenTweetIds An array of tweet IDs that have already been seen (not used in v2).
+   * @returns A promise that resolves to an array of tweets.
    */
   async fetchHomeTimeline(count, seenTweetIds) {
-    return await fetchHomeTimeline(count, seenTweetIds, this.auth);
+    if (!this.auth) {
+      throw new Error("Not authenticated");
+    }
+    const client = this.auth.getV2Client();
+    try {
+      const timeline = await client.v2.homeTimeline({
+        max_results: Math.min(count, 100),
+        "tweet.fields": [
+          "id",
+          "text",
+          "created_at",
+          "author_id",
+          "referenced_tweets",
+          "entities",
+          "public_metrics",
+          "attachments",
+          "conversation_id"
+        ],
+        "user.fields": ["id", "name", "username", "profile_image_url"],
+        "media.fields": ["url", "preview_image_url", "type"],
+        expansions: [
+          "author_id",
+          "attachments.media_keys",
+          "referenced_tweets.id"
+        ]
+      });
+      const tweets = [];
+      for await (const tweet of timeline) {
+        tweets.push(parseTweetV2ToV1(tweet, timeline.includes));
+        if (tweets.length >= count) break;
+      }
+      return tweets;
+    } catch (error) {
+      console.error("Failed to fetch home timeline:", error);
+      throw error;
+    }
   }
   /**
-   * Fetches the home timeline for the current user. (following feed)
+   * Fetches the home timeline for the current user (same as fetchHomeTimeline in v2).
+   * Twitter API v2 doesn't provide separate "Following" timeline endpoint.
    * @param count The number of tweets to fetch.
-   * @param seenTweetIds An array of tweet IDs that have already been seen.
-   * @returns A promise that resolves to the home timeline response.
+   * @param seenTweetIds An array of tweet IDs that have already been seen (not used in v2).
+   * @returns A promise that resolves to an array of tweets.
    */
   async fetchFollowingTimeline(count, seenTweetIds) {
-    return await fetchFollowingTimeline(count, seenTweetIds, this.auth);
+    return this.fetchHomeTimeline(count, seenTweetIds);
   }
   async getUserTweets(userId, maxTweets = 200, cursor) {
-    if (maxTweets > 200) {
-      maxTweets = 200;
-    }
-    const variables = {
-      userId,
-      count: maxTweets,
-      includePromotedContent: true,
-      withQuickPromoteEligibilityTweetFields: true,
-      withVoice: true,
-      withV2Timeline: true
-    };
-    if (cursor) {
-      variables.cursor = cursor;
-    }
-    const features2 = {
-      rweb_tipjar_consumption_enabled: true,
-      responsive_web_graphql_exclude_directive_enabled: true,
-      verified_phone_label_enabled: false,
-      creator_subscriptions_tweet_preview_api_enabled: true,
-      responsive_web_graphql_timeline_navigation_enabled: true,
-      responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
-      communities_web_enable_tweet_community_results_fetch: true,
-      c9s_tweet_anatomy_moderator_badge_enabled: true,
-      articles_preview_enabled: true,
-      responsive_web_edit_tweet_api_enabled: true,
-      graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
-      view_counts_everywhere_api_enabled: true,
-      longform_notetweets_consumption_enabled: true,
-      responsive_web_twitter_article_tweet_consumption_enabled: true,
-      tweet_awards_web_tipping_enabled: false,
-      creator_subscriptions_quote_tweet_preview_enabled: false,
-      freedom_of_speech_not_reach_fetch_enabled: true,
-      standardized_nudges_misinfo: true,
-      tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
-      rweb_video_timestamps_enabled: true,
-      longform_notetweets_rich_text_read_enabled: true,
-      longform_notetweets_inline_media_enabled: true,
-      responsive_web_enhance_cards_enabled: false
-    };
-    const fieldToggles = {
-      withArticlePlainText: false
-    };
-    const res = await requestApi(
-      `${UserTweetsUrl}?variables=${encodeURIComponent(
-        JSON.stringify(variables)
-      )}&features=${encodeURIComponent(JSON.stringify(features2))}&fieldToggles=${encodeURIComponent(
-        JSON.stringify(fieldToggles)
-      )}`,
-      this.auth
-    );
-    if (!res.success) {
-      throw res.err;
+    if (!this.auth) {
+      throw new Error("Not authenticated");
+    }
+    const client = this.auth.getV2Client();
+    try {
+      const response = await client.v2.userTimeline(userId, {
+        max_results: Math.min(maxTweets, 100),
+        "tweet.fields": [
+          "id",
+          "text",
+          "created_at",
+          "author_id",
+          "referenced_tweets",
+          "entities",
+          "public_metrics",
+          "attachments",
+          "conversation_id"
+        ],
+        "user.fields": ["id", "name", "username", "profile_image_url"],
+        "media.fields": ["url", "preview_image_url", "type"],
+        expansions: [
+          "author_id",
+          "attachments.media_keys",
+          "referenced_tweets.id"
+        ],
+        pagination_token: cursor
+      });
+      const tweets = [];
+      for await (const tweet of response) {
+        tweets.push(parseTweetV2ToV1(tweet, response.includes));
+        if (tweets.length >= maxTweets) break;
+      }
+      return {
+        tweets,
+        next: response.meta?.next_token
+      };
+    } catch (error) {
+      console.error("Failed to fetch user tweets:", error);
+      throw error;
     }
-    const timelineV2 = parseTimelineTweetsV2(res.value);
-    return {
-      tweets: timelineV2.tweets,
-      next: timelineV2.next
-    };
   }
   async *getUserTweetsIterator(userId, maxTweets = 200) {
     let cursor;
@@ -2344,32 +1759,6 @@ var Client = class {
       "Logout is not applicable when using Twitter API v2 credentials"
     );
   }
-  /**
-   * Sets the optional cookie to be used in requests.
-   * @param _cookie The cookie to be used in requests.
-   * @deprecated This function no longer represents any part of Twitter's auth flow.
-   * @returns This client instance.
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  withCookie(_cookie) {
-    console.warn(
-      "Warning: Client#withCookie is deprecated and will be removed in a later version. Use Client#login or Client#setCookies instead."
-    );
-    return this;
-  }
-  /**
-   * Sets the optional CSRF token to be used in requests.
-   * @param _token The CSRF token to be used in requests.
-   * @deprecated This function no longer represents any part of Twitter's auth flow.
-   * @returns This client instance.
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  withXCsrfToken(_token) {
-    console.warn(
-      "Warning: Client#withXCsrfToken is deprecated and will be removed in a later version."
-    );
-    return this;
-  }
   /**
    * Sends a quote tweet.
    * @param text The text of the tweet.
@@ -2453,14 +1842,6 @@ var Client = class {
     }
     return res.value;
   }
-  /**
-   * Fetches a article (long form tweet) by its ID.
-   * @param id The ID of the article to fetch. In the format of (http://x.com/i/article/id)
-   * @returns The {@link TimelineArticle} object, or `null` if it couldn't be fetched.
-   */
-  getArticle(id) {
-    return getArticle(id, this.auth);
-  }
   /**
    * Retrieves all users who retweeted the given tweet.
    * @param tweetId The ID of the tweet.
@@ -2670,72 +2051,6 @@ var _ClientBase = class _ClientBase {
   onReady() {
     throw new Error("Not implemented in base class, please call from subclass");
   }
-  /**
-   * Parse the raw tweet data into a standardized Tweet object.
-   */
-  /**
-   * Parses a raw tweet object into a structured Tweet object.
-   *
-   * @param {any} raw - The raw tweet object to parse.
-   * @param {number} [depth=0] - The current depth of parsing nested quotes/retweets.
-   * @param {number} [maxDepth=3] - The maximum depth allowed for parsing nested quotes/retweets.
-   * @returns {Tweet} The parsed Tweet object.
-   */
-  parseTweet(raw, depth = 0, maxDepth = 3) {
-    const canRecurse = depth < maxDepth;
-    const quotedStatus = raw.quoted_status_result?.result && canRecurse ? this.parseTweet(raw.quoted_status_result.result, depth + 1, maxDepth) : void 0;
-    const retweetedStatus = raw.retweeted_status_result?.result && canRecurse ? this.parseTweet(
-      raw.retweeted_status_result.result,
-      depth + 1,
-      maxDepth
-    ) : void 0;
-    const t = {
-      bookmarkCount: raw.bookmarkCount ?? raw.legacy?.bookmark_count ?? void 0,
-      conversationId: raw.conversationId ?? raw.legacy?.conversation_id_str,
-      hashtags: raw.hashtags ?? raw.legacy?.entities?.hashtags ?? [],
-      html: raw.html,
-      id: raw.id ?? raw.rest_id ?? raw.legacy.id_str ?? raw.id_str ?? void 0,
-      inReplyToStatus: raw.inReplyToStatus,
-      inReplyToStatusId: raw.inReplyToStatusId ?? raw.legacy?.in_reply_to_status_id_str ?? void 0,
-      isQuoted: raw.legacy?.is_quote_status === true,
-      isPin: raw.isPin,
-      isReply: raw.isReply,
-      isRetweet: raw.legacy?.retweeted === true,
-      isSelfThread: raw.isSelfThread,
-      language: raw.legacy?.lang,
-      likes: raw.legacy?.favorite_count ?? 0,
-      name: raw.name ?? raw?.user_results?.result?.legacy?.name ?? raw.core?.user_results?.result?.legacy?.name,
-      mentions: raw.mentions ?? raw.legacy?.entities?.user_mentions ?? [],
-      permanentUrl: raw.permanentUrl ?? (raw.core?.user_results?.result?.legacy?.screen_name && raw.rest_id ? `https://x.com/${raw.core?.user_results?.result?.legacy?.screen_name}/status/${raw.rest_id}` : void 0),
-      photos: raw.photos ?? (raw.legacy?.entities?.media?.filter((media) => media.type === "photo").map((media) => ({
-        id: media.id_str || media.rest_id || media.legacy.id_str,
-        url: media.media_url_https,
-        alt_text: media.alt_text
-      })) || []),
-      place: raw.place,
-      poll: raw.poll ?? null,
-      quotedStatus,
-      quotedStatusId: raw.quotedStatusId ?? raw.legacy?.quoted_status_id_str ?? void 0,
-      quotes: raw.legacy?.quote_count ?? 0,
-      replies: raw.legacy?.reply_count ?? 0,
-      retweets: raw.legacy?.retweet_count ?? 0,
-      retweetedStatus,
-      retweetedStatusId: raw.legacy?.retweeted_status_id_str ?? void 0,
-      text: raw.text ?? raw.legacy?.full_text ?? void 0,
-      thread: raw.thread || [],
-      timeParsed: raw.timeParsed ? new Date(raw.timeParsed) : raw.legacy?.created_at ? new Date(raw.legacy?.created_at) : void 0,
-      timestamp: raw.timestamp ?? (raw.legacy?.created_at ? new Date(raw.legacy.created_at).getTime() / 1e3 : void 0),
-      urls: raw.urls ?? raw.legacy?.entities?.urls ?? [],
-      userId: raw.userId ?? raw.legacy?.user_id_str ?? void 0,
-      username: raw.username ?? raw.core?.user_results?.result?.legacy?.screen_name ?? void 0,
-      videos: raw.videos ?? raw.legacy?.entities?.media?.filter(
-        (media) => media.type === "video"
-      ) ?? [],
-      views: raw.views?.count ? Number(raw.views.count) : 0,
-      sensitiveContent: raw.sensitiveContent
-    };
-    return t;
-  }
   async init() {
     const apiKey = this.state?.TWITTER_API_KEY || this.runtime.getSetting("TWITTER_API_KEY");
     const apiSecretKey = this.state?.TWITTER_API_SECRET_KEY || this.runtime.getSetting("TWITTER_API_SECRET_KEY");
@@ -2845,7 +2160,7 @@ var _ClientBase = class _ClientBase {
       this.profile.id,
       count
     );
-    return homeTimeline.tweets.map((t) => this.parseTweet(t));
+    return homeTimeline.tweets;
   }
   /**
    * Fetch timeline for twitter account, optionally only from followed accounts
@@ -2853,8 +2168,7 @@ var _ClientBase = class _ClientBase {
   async fetchHomeTimeline(count, following) {
     logger.debug("fetching home timeline");
     const homeTimeline = following ? await this.twitterClient.fetchFollowingTimeline(count, []) : await this.twitterClient.fetchHomeTimeline(count, []);
-    const processedTimeline = homeTimeline.filter((t) => t.__typename !== "TweetWithVisibilityResults").map((tweet) => this.parseTweet(tweet));
-    return processedTimeline;
+    return homeTimeline;
   }
   async fetchSearchTweets(query, maxTweets, searchMode, cursor) {
     try {
@@ -3162,7 +2476,7 @@ import {
   ContentType,
   EventType,
   createUniqueUuid as createUniqueUuid3,
-  logger as logger3
+  logger as logger4
 } from "@elizaos/core";
 
 // src/utils.ts
@@ -3170,9 +2484,14 @@ import fs from "fs";
 import path from "path";
 import {
   createUniqueUuid as createUniqueUuid2,
-  logger as logger2,
+  logger as logger3,
   truncateToCompleteSentence
 } from "@elizaos/core";
+
+// src/utils/error-handler.ts
+import { logger as logger2 } from "@elizaos/core";
+
+// src/utils.ts
 async function sendTweet(client, text, mediaData = [], tweetToReplyTo) {
   const isNoteTweet = text.length > TWEET_MAX_LENGTH;
   const postText = isNoteTweet ? truncateToCompleteSentence(text, TWEET_MAX_LENGTH) : text;
@@ -3183,9 +2502,9 @@ async function sendTweet(client, text, mediaData = [], tweetToReplyTo) {
       tweetToReplyTo,
       mediaData
     );
-    logger2.log("Successfully posted Tweet");
+    logger3.log("Successfully posted Tweet");
   } catch (error) {
-    logger2.error("Error posting Tweet:", error);
+    logger3.error("Error posting Tweet:", error);
     throw error;
   }
   try {
@@ -3197,14 +2516,14 @@ async function sendTweet(client, text, mediaData = [], tweetToReplyTo) {
       }
       await client.cacheLatestCheckedTweetId();
       await client.cacheTweet(tweetResult);
-      logger2.log("Successfully posted a tweet", tweetResult.id);
+      logger3.log("Successfully posted a tweet", tweetResult.id);
       return tweetResult;
     }
   } catch (error) {
-    logger2.error("Error parsing tweet response:", error);
+    logger3.error("Error parsing tweet response:", error);
     throw error;
   }
-  logger2.error("No valid response from Twitter API");
+  logger3.error("No valid response from Twitter API");
   throw new Error("Failed to send tweet - no valid response");
 }
 var parseActionResponseFromText = (text) => {
@@ -7370,7 +6689,7 @@ var TwitterInteractionClient = class {
    * Asynchronously handles Twitter interactions by checking for mentions, processing tweets, and updating the last checked tweet ID.
    */
   async handleTwitterInteractions() {
-    logger3.log("Checking Twitter interactions");
+    logger4.log("Checking Twitter interactions");
     const twitterUsername = this.client.profile?.username;
     try {
       const cursorKey = `twitter/${twitterUsername}/mention_cursor`;
@@ -7389,9 +6708,9 @@ var TwitterInteractionClient = class {
       }
       await this.processMentionTweets(mentionCandidates);
       await this.client.cacheLatestCheckedTweetId();
-      logger3.log("Finished checking Twitter interactions");
+      logger4.log("Finished checking Twitter interactions");
     } catch (error) {
-      logger3.error("Error handling Twitter interactions:", error);
+      logger4.error("Error handling Twitter interactions:", error);
     }
   }
   /**
@@ -7405,7 +6724,7 @@ var TwitterInteractionClient = class {
    * Note: MENTION_RECEIVED is currently disabled (see TODO below)
    */
   async processMentionTweets(mentionCandidates) {
-    logger3.log(
+    logger4.log(
       "Completed checking mentioned tweets:",
       mentionCandidates.length
     );
@@ -7419,7 +6738,7 @@ var TwitterInteractionClient = class {
           targetUsersConfig
         );
         if (!shouldTarget) {
-          logger3.log(
+          logger4.log(
             `Skipping tweet from @${tweet.username} - not in target users list`
           );
         }
@@ -7431,7 +6750,7 @@ var TwitterInteractionClient = class {
         const tweetId = createUniqueUuid3(this.runtime, tweet.id);
         const existingResponse = await this.runtime.getMemoryById(tweetId);
         if (existingResponse) {
-          logger3.log(`Already responded to tweet ${tweet.id}, skipping`);
+          logger4.log(`Already responded to tweet ${tweet.id}, skipping`);
           continue;
         }
         const conversationRoomId = createUniqueUuid3(
@@ -7448,12 +6767,12 @@ var TwitterInteractionClient = class {
           (memory2) => memory2.content?.inReplyTo === tweetId || memory2.content?.source === "twitter" && memory2.agentId === this.runtime.agentId && memory2.content?.inReplyTo === tweetId
         );
         if (hasExistingReply) {
-          logger3.log(
+          logger4.log(
             `Already replied to tweet ${tweet.id} (found existing reply), skipping`
           );
           continue;
         }
-        logger3.log("New Tweet found", tweet.permanentUrl);
+        logger4.log("New Tweet found", tweet.permanentUrl);
         const entityId = createUniqueUuid3(
           this.runtime,
           tweet.userId === this.client.profile.id ? this.runtime.agentId : tweet.userId
@@ -7668,23 +6987,23 @@ var TwitterInteractionClient = class {
     thread
   }) {
     if (!message.content.text) {
-      logger3.log("Skipping Tweet with no text", tweet.id);
+      logger4.log("Skipping Tweet with no text", tweet.id);
       return { text: "", actions: ["IGNORE"] };
     }
     const callback = async (response, tweetId) => {
       try {
         if (!response.text) {
-          logger3.warn("No text content in response, skipping tweet reply");
+          logger4.warn("No text content in response, skipping tweet reply");
           return [];
         }
         const tweetToReplyTo = tweetId || tweet.id;
         if (this.isDryRun) {
-          logger3.info(
+          logger4.info(
             `[DRY RUN] Would have replied to ${tweet.username} with: ${response.text}`
           );
           return [];
         }
-        logger3.info(`Replying to tweet ${tweetToReplyTo}`);
+        logger4.info(`Replying to tweet ${tweetToReplyTo}`);
         const tweetResult = await sendTweet(
           this.client,
           response.text,
@@ -7694,7 +7013,7 @@ var TwitterInteractionClient = class {
         if (!tweetResult) {
           throw new Error("Failed to get tweet result from response");
         }
-        const responseId = createUniqueUuid3(this.runtime, tweetResult.rest_id);
+        const responseId = createUniqueUuid3(this.runtime, tweetResult.id);
         const responseMemory = {
           id: responseId,
           entityId: this.runtime.agentId,
@@ -7710,7 +7029,7 @@ var TwitterInteractionClient = class {
         await this.runtime.createMemory(responseMemory, "messages");
         return [responseMemory];
       } catch (error) {
-        logger3.error("Error replying to tweet:", error);
+        logger4.error("Error replying to tweet:", error);
         return [];
       }
     };
@@ -7733,17 +7052,17 @@ var TwitterInteractionClient = class {
     const thread = [];
     const visited = /* @__PURE__ */ new Set();
     async function processThread(currentTweet, depth = 0) {
-      logger3.log("Processing tweet:", {
+      logger4.log("Processing tweet:", {
         id: currentTweet.id,
         inReplyToStatusId: currentTweet.inReplyToStatusId,
         depth
       });
       if (!currentTweet) {
-        logger3.log("No current tweet found for thread building");
+        logger4.log("No current tweet found for thread building");
         return;
       }
       if (depth >= maxReplies) {
-        logger3.log("Reached maximum reply depth", depth);
+        logger4.log("Reached maximum reply depth", depth);
         return;
       }
       const memory = await this.runtime.getMemoryById(
@@ -7781,37 +7100,37 @@ var TwitterInteractionClient = class {
         );
       }
       if (visited.has(currentTweet.id)) {
-        logger3.log("Already visited tweet:", currentTweet.id);
+        logger4.log("Already visited tweet:", currentTweet.id);
         return;
       }
       visited.add(currentTweet.id);
       thread.unshift(currentTweet);
       if (currentTweet.inReplyToStatusId) {
-        logger3.log("Fetching parent tweet:", currentTweet.inReplyToStatusId);
+        logger4.log("Fetching parent tweet:", currentTweet.inReplyToStatusId);
         try {
           const parentTweet = await this.twitterClient.getTweet(
             currentTweet.inReplyToStatusId
           );
           if (parentTweet) {
-            logger3.log("Found parent tweet:", {
+            logger4.log("Found parent tweet:", {
               id: parentTweet.id,
               text: parentTweet.text?.slice(0, 50)
             });
             await processThread(parentTweet, depth + 1);
           } else {
-            logger3.log(
+            logger4.log(
               "No parent tweet found for:",
               currentTweet.inReplyToStatusId
             );
           }
         } catch (error) {
-          logger3.log("Error fetching parent tweet:", {
+          logger4.log("Error fetching parent tweet:", {
             tweetId: currentTweet.inReplyToStatusId,
             error
           });
         }
       } else {
-        logger3.log("Reached end of reply chain at:", currentTweet.id);
+        logger4.log("Reached end of reply chain at:", currentTweet.id);
       }
     }
     await processThread.bind(this)(tweet, 0);
@@ -7837,7 +7156,7 @@ import {
   ChannelType as ChannelType3,
   EventType as EventType2,
   createUniqueUuid as createUniqueUuid4,
-  logger as logger4
+  logger as logger5
 } from "@elizaos/core";
 var TwitterPostClient = class {
   /**
@@ -7850,17 +7169,20 @@ var TwitterPostClient = class {
     this.client = client;
     this.state = state;
     this.runtime = runtime;
-    this.isDryRun = this.state?.TWITTER_DRY_RUN || this.runtime.getSetting("TWITTER_DRY_RUN");
-    logger4.log("Twitter Client Configuration:");
-    logger4.log(`- Dry Run Mode: ${this.isDryRun ? "Enabled" : "Disabled"}`);
-    logger4.log(
+    const dryRunSetting = this.state?.TWITTER_DRY_RUN ?? this.runtime.getSetting("TWITTER_DRY_RUN");
+    this.isDryRun = dryRunSetting === true || dryRunSetting === "true" || typeof dryRunSetting === "string" && dryRunSetting.toLowerCase() === "true";
+    logger5.log("Twitter Client Configuration:");
+    logger5.log(`- Dry Run Mode: ${this.isDryRun ? "Enabled" : "Disabled"}`);
+    logger5.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`
     );
-    logger4.log(
-      `- Post Immediately: ${this.state?.TWITTER_POST_IMMEDIATELY || this.runtime.getSetting("TWITTER_POST_IMMEDIATELY") ? "enabled" : "disabled"}`
+    const postImmediatelySetting = this.state?.TWITTER_POST_IMMEDIATELY ?? this.runtime.getSetting("TWITTER_POST_IMMEDIATELY");
+    const isPostImmediately = postImmediatelySetting === true || postImmediatelySetting === "true" || typeof postImmediatelySetting === "string" && postImmediatelySetting.toLowerCase() === "true";
+    logger5.log(
+      `- Post Immediately: ${isPostImmediately ? "enabled" : "disabled"}`
     );
     if (this.isDryRun) {
-      logger4.log(
+      logger5.log(
         "Twitter client initialized in dry run mode - no actual tweets should be posted"
       );
     }
@@ -7869,7 +7191,7 @@ var TwitterPostClient = class {
    * Starts the Twitter post client, setting up a loop to periodically generate new tweets.
    */
   async start() {
-    logger4.log("Starting Twitter post client...");
+    logger5.log("Starting Twitter post client...");
     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;
@@ -7879,7 +7201,9 @@ var TwitterPostClient = class {
       setTimeout(generateNewTweetLoop, interval);
     };
     setTimeout(generateNewTweetLoop, 60 * 1e3);
-    if (this.state?.TWITTER_POST_IMMEDIATELY || this.runtime.getSetting("TWITTER_POST_IMMEDIATELY")) {
+    const postImmediately = this.state?.TWITTER_POST_IMMEDIATELY ?? this.runtime.getSetting("TWITTER_POST_IMMEDIATELY");
+    const shouldPostImmediately = postImmediately === true || postImmediately === "true" || typeof postImmediately === "string" && postImmediately.toLowerCase() === "true";
+    if (shouldPostImmediately) {
       await new Promise((resolve) => setTimeout(resolve, 1e3));
       await this.generateNewTweet();
     }
@@ -7889,33 +7213,38 @@ var TwitterPostClient = class {
    * This approach aligns with our platform-independent architecture.
    */
   async generateNewTweet() {
+    logger5.info("Attempting to generate new tweet...");
     try {
       const userId = this.client.profile?.id;
       if (!userId) {
-        logger4.error("Cannot generate tweet: Twitter profile not available");
+        logger5.error("Cannot generate tweet: Twitter profile not available");
         return;
       }
+      logger5.info(`Generating tweet for user: ${this.client.profile?.username} (${userId})`);
       const worldId = createUniqueUuid4(this.runtime, userId);
       const roomId = createUniqueUuid4(this.runtime, `${userId}-home`);
       const callback = async (content) => {
+        logger5.info("Tweet generation callback triggered");
         try {
           if (this.isDryRun) {
-            logger4.info(`[DRY RUN] Would post tweet: ${content.text}`);
+            logger5.info(`[DRY RUN] Would post tweet: ${content.text}`);
             return [];
           }
           if (content.text.includes("Error: Missing")) {
-            logger4.error("Error: Missing some context", content);
+            logger5.error("Error: Missing some context", content);
             return [];
           }
+          logger5.info(`Posting tweet: ${content.text}`);
           const result = await this.postToTwitter(
             content.text,
             content.mediaData
           );
           if (result === null) {
-            logger4.info("Skipped posting duplicate tweet");
+            logger5.info("Skipped posting duplicate tweet");
             return [];
           }
-          const tweetId = result.rest_id || result.id_str || result.legacy?.id_str;
+          const tweetId = result.id;
+          logger5.info(`Tweet posted successfully! ID: ${tweetId}`);
           if (result) {
             const postedTweetId = createUniqueUuid4(this.runtime, tweetId);
             const postedMemory = {
@@ -7940,10 +7269,11 @@ var TwitterPostClient = class {
           }
           return [];
         } catch (error) {
-          logger4.error("Error posting tweet:", error, content);
+          logger5.error("Error posting tweet:", error, content);
           return [];
         }
       };
+      logger5.info("Emitting POST_GENERATED event to trigger content generation...");
       this.runtime.emitEvent(
         [EventType2.POST_GENERATED, "TWITTER_POST_GENERATED" /* POST_GENERATED */],
         {
@@ -7955,8 +7285,9 @@ var TwitterPostClient = class {
           source: "twitter"
         }
       );
+      logger5.info("POST_GENERATED event emitted successfully");
     } catch (error) {
-      logger4.error("Error generating tweet:", error);
+      logger5.error("Error generating tweet:", error);
     }
   }
   /**
@@ -7973,7 +7304,7 @@ var TwitterPostClient = class {
       if (lastPost) {
         const lastTweet = await this.client.getTweet(lastPost.id);
         if (lastTweet && lastTweet.text === text) {
-          logger4.warn(
+          logger5.warn(
             "Tweet is a duplicate of the last post. Skipping to avoid duplicate."
           );
           return null;
@@ -7983,22 +7314,22 @@ var TwitterPostClient = class {
       if (mediaData && mediaData.length > 0) {
         for (const media of mediaData) {
           try {
-            logger4.warn(
+            logger5.warn(
               "Media upload not currently supported with the modern Twitter API"
             );
           } catch (error) {
-            logger4.error("Error uploading media:", error);
+            logger5.error("Error uploading media:", error);
           }
         }
       }
       const result = await sendTweet(this.client, text, mediaData);
       if (!result) {
-        logger4.error("Error sending tweet; Bad response:");
+        logger5.error("Error sending tweet; Bad response:");
         return null;
       }
       return result;
     } catch (error) {
-      logger4.error("Error posting to Twitter:", error);
+      logger5.error("Error posting to Twitter:", error);
       throw error;
     }
   }
@@ -8014,7 +7345,7 @@ import {
   ModelType,
   parseKeyValueXml
 } from "@elizaos/core";
-import { logger as logger5 } from "@elizaos/core";
+import { logger as logger6 } from "@elizaos/core";
 
 // src/templates.ts
 var twitterActionTemplate = `
@@ -8099,30 +7430,7 @@ var TwitterTimelineClient = class {
   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);
+    return homeTimeline.filter((tweet) => tweet.username !== twitterUsername);
   }
   createTweetId(runtime, tweet) {
     return createUniqueUuid5(runtime, tweet.id);
@@ -8178,7 +7486,7 @@ Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appro
           }
         );
         if (!actionResponse) {
-          logger5.log(`No valid actions generated for tweet ${tweet.id}`);
+          logger6.log(`No valid actions generated for tweet ${tweet.id}`);
           continue;
         }
         const { actions } = parseActionResponseFromText(actionResponse.trim());
@@ -8189,7 +7497,7 @@ Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appro
           roomId
         });
       } catch (error) {
-        logger5.error(`Error processing tweet ${tweet.id}:`, error);
+        logger6.error(`Error processing tweet ${tweet.id}:`, error);
         continue;
       }
     }
@@ -8236,7 +7544,7 @@ Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appro
           this.handleReplyAction(tweet);
         }
       } catch (error) {
-        logger5.error(`Error processing tweet ${tweet.id}:`, error);
+        logger6.error(`Error processing tweet ${tweet.id}:`, error);
         continue;
       }
     }
@@ -8267,17 +7575,17 @@ Choose any combination of [LIKE], [RETWEET], [QUOTE], and [REPLY] that are appro
   async handleLikeAction(tweet) {
     try {
       await this.twitterClient.likeTweet(tweet.id);
-      logger5.log(`Liked tweet ${tweet.id}`);
+      logger6.log(`Liked tweet ${tweet.id}`);
     } catch (error) {
-      logger5.error(`Error liking tweet ${tweet.id}:`, error);
+      logger6.error(`Error liking tweet ${tweet.id}:`, error);
     }
   }
   async handleRetweetAction(tweet) {
     try {
       await this.twitterClient.retweet(tweet.id);
-      logger5.log(`Retweeted tweet ${tweet.id}`);
+      logger6.log(`Retweeted tweet ${tweet.id}`);
     } catch (error) {
-      logger5.error(`Error retweeting tweet ${tweet.id}:`, error);
+      logger6.error(`Error retweeting tweet ${tweet.id}:`, error);
     }
   }
   async handleQuoteAction(tweet) {
@@ -8304,11 +7612,11 @@ ${tweet.text}`;
         const body = await result.json();
         const tweetResult = body?.data?.create_tweet?.tweet_results?.result || body?.data || body;
         if (tweetResult) {
-          logger5.log("Successfully posted quote tweet");
+          logger6.log("Successfully posted quote tweet");
         } else {
-          logger5.error("Quote tweet creation failed:", body);
+          logger6.error("Quote tweet creation failed:", body);
         }
-        const tweetId = tweetResult?.rest_id || tweetResult?.id || Date.now().toString();
+        const tweetId = tweetResult?.id || Date.now().toString();
         const responseId = createUniqueUuid5(this.runtime, tweetId);
         const responseMemory = {
           id: responseId,
@@ -8324,7 +7632,7 @@ ${tweet.text}`;
         await this.runtime.createMemory(responseMemory, "messages");
       }
     } catch (error) {
-      logger5.error("Error in quote tweet generation:", error);
+      logger6.error("Error in quote tweet generation:", error);
     }
   }
   async handleReplyAction(tweet) {
@@ -8351,7 +7659,7 @@ ${tweet.text}`;
         if (!tweetResult) {
           throw new Error("Failed to get tweet result from response");
         }
-        const responseId = createUniqueUuid5(this.runtime, tweetResult.rest_id);
+        const responseId = createUniqueUuid5(this.runtime, tweetResult.id);
         const responseMemory = {
           id: responseId,
           entityId: this.runtime.agentId,
@@ -8366,7 +7674,7 @@ ${tweet.text}`;
         await this.runtime.createMemory(responseMemory, "messages");
       }
     } catch (error) {
-      logger5.error("Error in quote tweet generation:", error);
+      logger6.error("Error in quote tweet generation:", error);
     }
   }
 };
@@ -8479,18 +7787,35 @@ console.log(`Twitter plugin loaded with service name: ${TWITTER_SERVICE_NAME}`);
 var TwitterClientInstance = class {
   constructor(runtime, state) {
     this.client = new ClientBase(runtime, state);
-    if (runtime.getSetting("TWITTER_POST_ENABLE") === "true") {
+    const postEnableSetting = runtime.getSetting("TWITTER_POST_ENABLE");
+    logger7.info(`TWITTER_POST_ENABLE raw value: "${postEnableSetting}"`);
+    logger7.info(`TWITTER_POST_ENABLE type: ${typeof postEnableSetting}`);
+    const postEnabled = postEnableSetting === true || postEnableSetting === "true" || typeof postEnableSetting === "string" && postEnableSetting.toLowerCase() === "true";
+    if (postEnabled) {
+      logger7.info("Twitter posting is ENABLED - creating post client");
       this.post = new TwitterPostClient(this.client, runtime, state);
+    } else {
+      logger7.info("Twitter posting is DISABLED - set TWITTER_POST_ENABLE=true to enable automatic posting");
     }
-    if (runtime.getSetting("TWITTER_SEARCH_ENABLE") !== "false") {
+    const searchEnabledSetting = runtime.getSetting("TWITTER_SEARCH_ENABLE");
+    logger7.info(`TWITTER_SEARCH_ENABLE raw value: "${searchEnabledSetting}"`);
+    const searchEnabled = searchEnabledSetting !== false && searchEnabledSetting !== "false";
+    if (searchEnabled) {
+      logger7.info("Twitter search/interactions are ENABLED");
       this.interaction = new TwitterInteractionClient(
         this.client,
         runtime,
         state
       );
+    } else {
+      logger7.info("Twitter search/interactions are DISABLED");
     }
-    if (runtime.getSetting("TWITTER_ENABLE_ACTION_PROCESSING") === "true") {
+    const actionProcessingEnabled = runtime.getSetting("TWITTER_ENABLE_ACTION_PROCESSING") === "true";
+    if (actionProcessingEnabled) {
+      logger7.info("Twitter action processing is ENABLED");
       this.timeline = new TwitterTimelineClient(this.client, runtime, state);
+    } else {
+      logger7.info("Twitter action processing is DISABLED");
     }
     this.service = TwitterService.getInstance();
   }
@@ -8511,7 +7836,7 @@ var _TwitterService = class _TwitterService extends Service {
     try {
       const existingClient = this.getClient(clientId, runtime.agentId);
       if (existingClient) {
-        logger6.info(`Twitter client already exists for ${clientId}`);
+        logger7.info(`Twitter client already exists for ${clientId}`);
         return existingClient;
       }
       const client = new TwitterClientInstance(runtime, state);
@@ -8527,10 +7852,10 @@ var _TwitterService = class _TwitterService extends Service {
       }
       this.clients.set(this.getClientKey(clientId, runtime.agentId), client);
       await this.emitServerJoinedEvent(runtime, client);
-      logger6.info(`Created Twitter client for ${clientId}`);
+      logger7.info(`Created Twitter client for ${clientId}`);
       return client;
     } catch (error) {
-      logger6.error(`Failed to create Twitter client for ${clientId}:`, error);
+      logger7.error(`Failed to create Twitter client for ${clientId}:`, error);
       throw error;
     }
   }
@@ -8542,7 +7867,7 @@ var _TwitterService = class _TwitterService extends Service {
   async emitServerJoinedEvent(runtime, client) {
     try {
       if (!client.client.profile) {
-        logger6.warn(
+        logger7.warn(
           "Twitter profile not available yet, can't emit WORLD_JOINED event"
         );
         return;
@@ -8617,9 +7942,9 @@ var _TwitterService = class _TwitterService extends Service {
           source: "twitter"
         }
       );
-      logger6.info(`Emitted WORLD_JOINED event for Twitter account ${username}`);
+      logger7.info(`Emitted WORLD_JOINED event for Twitter account ${username}`);
     } catch (error) {
-      logger6.error("Failed to emit WORLD_JOINED event for Twitter:", error);
+      logger7.error("Failed to emit WORLD_JOINED event for Twitter:", error);
     }
   }
   getClient(clientId, agentId) {
@@ -8632,9 +7957,9 @@ var _TwitterService = class _TwitterService extends Service {
       try {
         await client.service.stop();
         this.clients.delete(key);
-        logger6.info(`Stopped Twitter client for ${clientId}`);
+        logger7.info(`Stopped Twitter client for ${clientId}`);
       } catch (error) {
-        logger6.error(`Error stopping Twitter client for ${clientId}:`, error);
+        logger7.error(`Error stopping Twitter client for ${clientId}:`, error);
       }
     }
   }
@@ -8651,7 +7976,7 @@ var _TwitterService = class _TwitterService extends Service {
     );
     try {
       if (config.TWITTER_API_KEY && config.TWITTER_API_SECRET_KEY && config.TWITTER_ACCESS_TOKEN && config.TWITTER_ACCESS_TOKEN_SECRET) {
-        logger6.info("Creating default Twitter client from character settings");
+        logger7.info("Creating default Twitter client from character settings");
         await twitterClientManager.createClient(
           runtime,
           runtime.agentId,
@@ -8659,7 +7984,7 @@ var _TwitterService = class _TwitterService extends Service {
         );
       }
     } catch (error) {
-      logger6.error("Failed to create default Twitter client:", error);
+      logger7.error("Failed to create default Twitter client:", error);
       throw error;
     }
     return twitterClientManager;
@@ -8673,7 +7998,7 @@ var _TwitterService = class _TwitterService extends Service {
         await client.service.stop();
         this.clients.delete(key);
       } catch (error) {
-        logger6.error(`Error stopping Twitter client ${key}:`, error);
+        logger7.error(`Error stopping Twitter client ${key}:`, error);
       }
     }
   }